> This page is for Taurus PROTECT, version v3.52.
> For other versions, use one of these documentation indexes:
> - v3.58 (default): https://taurushq.ferndocs.com/protect-capital/v3.58/llms.txt
> - v3.56: https://taurushq.ferndocs.com/protect-capital/v3.56/llms.txt
> - v3.54: https://taurushq.ferndocs.com/protect-capital/v3.54/llms.txt
> - v3.52: https://taurushq.ferndocs.com/protect-capital/v3.52/llms.txt
> - v3.50: https://taurushq.ferndocs.com/protect-capital/v3.50/llms.txt
> - v3.48: https://taurushq.ferndocs.com/protect-capital/v3.48/llms.txt
> - v3.46: https://taurushq.ferndocs.com/protect-capital/v3.46/llms.txt
> - v3.44: https://taurushq.ferndocs.com/protect-capital/v3.44/llms.txt
> - v3.42: https://taurushq.ferndocs.com/protect-capital/v3.42/llms.txt
> - v3.40: https://taurushq.ferndocs.com/protect-capital/v3.40/llms.txt
> - v3.38: https://taurushq.ferndocs.com/protect-capital/v3.38/llms.txt

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://taurushq.ferndocs.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://taurushq.ferndocs.com/_mcp/server.

# Create a wallet

POST https://your-protect-instance.example.com/api/rest/v1/wallets
Content-Type: application/json

This endpoint creates a new wallet.

You must specify either a `currency` (by ID or symbol) or a combination of `blockchain` and `network`.

- If `currency` is provided, `blockchain` and `network` cannot be used.
- If `currency` is not provided, you may use `blockchain`, `network`, or both together.

Only one of these approaches is allowed per request.

The `currencyID` is globally unique across blockchains and networks, and can be identified by querying the `/currencies` endpoint. We recommend using `currencyID` whenever possible to avoid ambiguity.

Required role: **AccountCreator**.

Reference: https://taurushq.ferndocs.com/protect-capital/reference/wallets/create

## Authentication

- `Authorization` header (bearer token, required) — Bearer authentication of the form `Bearer <token>`, where token is your auth token.

## Request

### Body (application/json)

This endpoint expects a tgvalidatordCreateWalletRequest.

- `name` (string, required) — The name of the wallet has to be unique per blockchain, network.
- `currency` (string, optional) — This can be a currency name or a currency ID. Needs to be the native currency of a blockchain.
- `container` (string, optional) — Deprecated: Do not use
- `isOmnibus` (boolean, optional) — When set to `true`, the Wallet can be used as source of transactions allowing the system to pick addresses with adequate funds. (This is called *Single owner* in the GUI)
- `comment` (string, optional) — Comment or description of the wallet (maximum 254 characters). It is not used or interpreted by the system and will be returned as is in the replies from endpoints such as `api/rest/v2/wallets`
- `customerId` (string, optional) — When *isOmnibus* is `true`, all addresses in the wallet will have this attribute set (maximum 254 characters)
- `blockchain` (string, optional) — A string identifying the blockchain (e.g. "BTC"). Required if currency is empty. If the blockchain is enabled on more than one network (e.g. "mainnet" and "testnet"), the network needs to be specified.
- `network` (string, optional) — A string identifying the network. Required if the specified blockchain is enabled on multiple networks
- `visibilityGroupID` (string, optional) — The UUID of a Visibility Group (uuid can be obtained from e.g. `api/rest/v1/visibilitygroups`). The created wallet will only be visible and can only be managed by users in this group.
- `externalWalletId` (string, optional) — An optional external identifier for the wallet.

## Response

### 200

A successful response.

- `result` (tgvalidatordWallet, optional)

## Errors

### 400 Bad Request Error

Bad Request: indicates that the server cannot or will not process the request due to something that is perceived to be a client error (for example, malformed request syntax, invalid request message framing, or deceptive request routing)

- `any`

### 401 Unauthorized Error

Unauthorized: indicates that the client request has not been completed because it lacks valid authentication credentials for the requested resource

- `any`

### 403 Forbidden Error

Forbidden: indicates that the server understands the request but refuses to authorize it

- `any`

### 404 Not Found Error

Not Found: indicates that the server cannot find the requested resource

- `any`

### 500 Internal Server Error

Internal Server Error: indicates that the server encountered an unexpected condition that prevented it from fulfilling the request

- `any`

### 503 Service Unavailable Error

Service Unavailable: indicates that the server is not ready to handle the request.

- `any`

## Types

### tgvalidatordWallet

- `id` (string, optional)
- `balance` (tgvalidatordBalance, optional)
- `currency` (string, optional)
- `coin` (string, optional)
- `name` (string, optional)
- `container` (string, optional)
- `seed` (string, optional)
- `accountPath` (string, optional)
- `addresses` (list of tgvalidatordAddress, optional)
- `isOmnibus` (boolean, optional)
- `creationDate` (datetime, optional)
- `updateDate` (datetime, optional)
- `customerId` (string, optional)
- `comment` (string, optional)
- `disabled` (boolean, optional)
- `blockchain` (string, optional)
- `addressesCount` (string, optional)
- `attributes` (list of tgvalidatordWalletAttribute, optional)
- `currencyInfo` (tgvalidatordCurrency, optional)
- `externalWalletId` (string, optional) — An optional external identifier for the wallet.

### tgvalidatordBalance

- `totalConfirmed` (string, optional) — Total confirmed balance in the smallest currency unit (e.g., WEI for ETH).
- `totalUnconfirmed` (string, optional) — Total balance including unconfirmed transactions in smallest currency unit (e.g., WEI). Exceeds totalConfirmed when transactions are pending confirmation. Equal to confirmed balance when all funds are confirmed.
- `availableConfirmed` (string, optional) — Available confirmed balance that is ready to be spent or used.
- `availableUnconfirmed` (string, optional) — Available balance including unconfirmed transactions.
- `reservedConfirmed` (string, optional) — Confirmed reserved balance that is set being held for specific purposes, such as another pending transactions.
- `reservedUnconfirmed` (string, optional) — Reserved unconfirmed balance that is not yet fully validated.

### tgvalidatordAddress

- `id` (string, optional) — uint64; Unique identifier for the address.
- `walletId` (string, optional) — uint64; Unique identifier for the wallet associated with the address (parent wallet)
- `seed` (string, optional) — Which seed in the HSM to use for address generation..
- `currency` (string, optional) — Currency associated with the address (e.g., ETH, BTC). For a list of enabled currencies, query the [currencies endpoint](https://docs.taurushq.com/protect-capital/reference/walletservice_getcurrencies).
- `addressPath` (string, optional) — The derivation path for the address, used to generate the address from the seed.
- `addressIndex` (string, optional) — uint64; Index used for address generation. Required for derivation paths.
- `address` (string, optional) — The actual address generated for the wallet.
- `alternateAddress` (string, optional) — An alternate address that can be used for transactions, if available.
- `comment` (string, optional) — An optional comment associated with the address.
- `label` (string, optional) — A user-friendly label for the address (e.g., 'Deposit Address'). Displayed as `Name` in the UI.
- `customerId` (string, optional) — Identifier for the customer associated with the address.
- `nonce` (string, optional) — uint64; The current nonce of the address. A nonce is a 32-bit (or 4-byte) number used to prevent replay attacks.
- `balance` (tgvalidatordBalance, optional)
- `signature` (string, optional) — Signature associated with the address.
- `scores` (list of tgvalidatordScore, optional) — Risk score related to the address, pulled from external reputation services. (e.g., Scorechain, Chainalysis, etc...).
- `attributes` (list of tgvalidatordAddressAttribute, optional) — Additional attributes and metadata associated with the address.
- `linkedWhitelistedAddressIds` (list of string, optional) — List of whitelisted address IDs that are linked to this address.
- `creationDate` (datetime, optional) — The date and time when the address was created.
- `updateDate` (datetime, optional) — The date and time when the address was last updated.
- `walletInfo` (tgvalidatordWalletInfo, optional)
- `disabled` (boolean, optional) — Indicates whether the address is disabled.
- `currencyInfo` (tgvalidatordCurrency, optional)
- `canUseAllFunds` (boolean, optional) — Indicates whether all funds in the address can be used.
- `externalAddressId` (string, optional) — An optional external identifier for the address.
- `status` (string, optional) — Status of address creation. Creating status is used for asynchronous address creation. Value is one of `created`, `creating, `signed`, `observed`, or `confirmed`.

### tgvalidatordWalletAttribute

- `key` (string, optional)
- `value` (string, optional)
- `id` (string, optional)
- `contentType` (string, optional)
- `owner` (string, optional)
- `type` (string, optional)
- `subtype` (string, optional)
- `isfile` (boolean, optional)

### tgvalidatordCurrency

- `name` (string, optional) — Name of the currency.
- `symbol` (string, optional) — Shorthand symbol for the currency.
- `coinTypeIndex` (string, optional) — Index used to identify the coin type in BIP44. (e.g. Bitcoin is 0, Ethereum is 60).
- `blockchain` (string, optional) — The Blockchain the currency is associated with, (e.g. ETH, BTC).
- `isToken` (boolean, optional) — Indicates if the currency is a token (e.g., ERC-20).
- `isERC20` (boolean, optional) — Indicates if the token is an ERC-20 token.
- `decimals` (string, optional) — Number of decimal places the currency uses (e.g. 18 for ETH).
- `contractAddress` (string, optional) — Smart contract address if currency is a smart contract (e.g. ERC-20.).
- `hasStaking` (boolean, optional) — Indicates if the currency supports staking.
- `isUTXOBased` (boolean, optional) — Indicates if the currency is UTXO-based (e.g. Bitcoin).
- `isAccountBased` (boolean, optional) — Indicates if the currency is account-based (e.g. Ethereum).
- `isFiat` (boolean, optional) — Indicates if the currency is a fiat currency (e.g. CHF, EUR, USD).
- `isFA12` (boolean, optional) — Indicates if the currency is based on FA12 standard (used in Tezos).
- `isFA20` (boolean, optional) — Indicates if the currency is based on FA20 standard (used in Tezos).
- `isNFT` (boolean, optional) — Indicates if the currency represents a Non-Fungible Token (NFT).
- `enabled` (boolean, optional) — Indicates if the currency is enabled in the current tenant.
- `id` (string, optional) — Unique identifier of the currency.
- `displayName` (string, optional) — Display name for the currency, (e.g. Ethereum, Bitcoin).
- `type` (string, optional) — Type of the currency. Can be `token`, `fiat`, `native` , or `signet`.
- `wlcaId` (string, optional) — White listed contract address id associated with the currency.
- `network` (string, optional) — Network or environment the currency is used on (e.g. 'mainnet', 'testnet').
- `tokenID` (string, optional) — Unique id for the token, if applicable (e.g. for NFTs).
- `logo` (string, optional) — Currency logo in Data URI scheme. Base 64 encoded. (e.g. data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==).

### tgvalidatordScore

- `id` (string, optional)
- `provider` (string, optional)
- `type` (string, optional)
- `score` (string, optional)
- `updateDate` (datetime, optional)

### tgvalidatordAddressAttribute

- `key` (string, optional) — A key that Protect assigns to the attribute. E.g., `legacyAddress` `has_any_transactions`, etc...
- `value` (string, optional) — The value of the attribute.
- `id` (string, optional) — Unique identifier for the attribute.
- `contentType` (string, optional) — Content type of the attribute value. Usually `text/plain.`
- `owner` (string, optional) — Owner of the attribute. Most commonly `system` or `user`.
- `type` (string, optional) — A Protect generated attribute type. E.g., `transaction_info`, `tag`, etc...
- `subtype` (string, optional) — A Protect generated subtype. Not commonly used but can be used to further classify the attribute.
- `isfile` (boolean, optional) — Indicates whether the attribute is a file.

### tgvalidatordWalletInfo

- `id` (string, optional)
- `balance` (tgvalidatordBalance, optional)
- `currency` (string, optional)
- `coin` (string, optional)
- `name` (string, optional)
- `container` (string, optional)
- `seed` (string, optional)
- `accountPath` (string, optional)
- `isOmnibus` (boolean, optional)
- `creationDate` (datetime, optional)
- `updateDate` (datetime, optional)
- `customerId` (string, optional)
- `comment` (string, optional)
- `disabled` (boolean, optional)
- `blockchain` (string, optional)
- `addressesCount` (string, optional)
- `currencyInfo` (tgvalidatordCurrency, optional)
- `attributes` (list of tgvalidatordWalletAttribute, optional)
- `network` (string, optional)
- `visibilityGroupID` (string, optional)
- `externalWalletId` (string, optional) — An optional external identifier for the wallet.

## Examples

**Request**

```json
{
  "name": "Hot wallet XYZ",
  "currency": "ETH",
  "isOmnibus": false,
  "comment": "1"
}
```

**Response**

```json
{
  "result": {
    "id": "66313",
    "balance": {},
    "currency": "ETH",
    "coin": "ETH",
    "name": "Hot wallet XYZ",
    "seed": "eth",
    "accountPath": "m/44'/60'/84'",
    "creationDate": "2022-01-25T08:50:15.894917Z",
    "updateDate": "2022-01-25T08:50:15.894917Z",
    "comment": "Meant for XYZ process",
    "blockchain": "ETH"
  }
}
```

**SDK Code**

```python
import requests

url = "https://your-protect-instance.example.com/api/rest/v1/wallets"

payload = {
    "name": "Hot wallet XYZ",
    "currency": "ETH",
    "isOmnibus": False,
    "comment": "1"
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://your-protect-instance.example.com/api/rest/v1/wallets';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"name":"Hot wallet XYZ","currency":"ETH","isOmnibus":false,"comment":"1"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://your-protect-instance.example.com/api/rest/v1/wallets"

	payload := strings.NewReader("{\n  \"name\": \"Hot wallet XYZ\",\n  \"currency\": \"ETH\",\n  \"isOmnibus\": false,\n  \"comment\": \"1\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://your-protect-instance.example.com/api/rest/v1/wallets")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"name\": \"Hot wallet XYZ\",\n  \"currency\": \"ETH\",\n  \"isOmnibus\": false,\n  \"comment\": \"1\"\n}"

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://your-protect-instance.example.com/api/rest/v1/wallets")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"name\": \"Hot wallet XYZ\",\n  \"currency\": \"ETH\",\n  \"isOmnibus\": false,\n  \"comment\": \"1\"\n}")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://your-protect-instance.example.com/api/rest/v1/wallets', [
  'body' => '{
  "name": "Hot wallet XYZ",
  "currency": "ETH",
  "isOmnibus": false,
  "comment": "1"
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://your-protect-instance.example.com/api/rest/v1/wallets");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"Hot wallet XYZ\",\n  \"currency\": \"ETH\",\n  \"isOmnibus\": false,\n  \"comment\": \"1\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [
  "name": "Hot wallet XYZ",
  "currency": "ETH",
  "isOmnibus": false,
  "comment": "1"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://your-protect-instance.example.com/api/rest/v1/wallets")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```