> This page is for Taurus PROTECT, version v3.38.
> 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 an address

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

Required role: **AccountCreator**. 
 This endpoint creates a new address. 
 Address creation requires HSM signature, which makes it synchronuous. Therefore, address creation can be slow and failure could happen if HSM is either unavailable or takes too long to process. If it happens, the API can be called again safely. 

Reference: https://taurushq.ferndocs.com/protect-capital/reference/addresses/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 tgvalidatordCreateAddressRequest.

- `walletId` (string, required)
- `label` (string, required)
- `comment` (string, optional)
- `customerId` (string, optional)
- `nonHardenedDerivation` (boolean, optional)
- `workchainId` (integer, optional)
- `type` (string, optional)
- `externalAddressId` (string, optional) — Identifier for the address in the user's system. This must be unique. Attempting to create an address with an existing externalAddressId will do nothing and return the originally created address

## Response

### 200

A successful response.

- `result` (tgvalidatordAddress, 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

### tgvalidatordAddress

- `id` (string, optional)
- `walletId` (string, optional)
- `seed` (string, optional)
- `currency` (string, optional)
- `addressPath` (string, optional)
- `addressIndex` (string, optional)
- `address` (string, optional)
- `alternateAddress` (string, optional)
- `comment` (string, optional)
- `label` (string, optional)
- `customerId` (string, optional)
- `nonce` (string, optional)
- `balance` (tgvalidatordBalance, optional) — Balance in the smallest currency unit. Example: 1500000000000000000 WEI (smallest ETH unit) corresponds to 1.5 ETH
- `signature` (string, optional)
- `scores` (list of tgvalidatordScore, optional)
- `attributes` (list of tgvalidatordAddressAttribute, optional)
- `linkedWhitelistedAddressIds` (list of string, optional)
- `creationDate` (datetime, optional)
- `updateDate` (datetime, optional)
- `walletInfo` (tgvalidatordWalletInfo, optional)
- `disabled` (boolean, optional)
- `currencyInfo` (tgvalidatordCurrency, optional)
- `canUseAllFunds` (boolean, optional)
- `externalAddressId` (string, optional)

### tgvalidatordBalance

Balance in the smallest currency unit. Example: 1500000000000000000 WEI (smallest ETH unit) corresponds to 1.5 ETH

- `totalConfirmed` (string, optional)
- `totalUnconfirmed` (string, optional)
- `availableConfirmed` (string, optional)
- `availableUnconfirmed` (string, optional)
- `reservedConfirmed` (string, optional)
- `reservedUnconfirmed` (string, optional)

### tgvalidatordScore

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

### tgvalidatordAddressAttribute

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

### tgvalidatordWalletInfo

- `id` (string, optional)
- `balance` (tgvalidatordBalance, optional) — Balance in the smallest currency unit. Example: 1500000000000000000 WEI (smallest ETH unit) corresponds to 1.5 ETH
- `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)

### tgvalidatordCurrency

- `name` (string, optional)
- `symbol` (string, optional)
- `coinTypeIndex` (string, optional)
- `blockchain` (string, optional)
- `isToken` (boolean, optional)
- `isERC20` (boolean, optional)
- `decimals` (string, optional)
- `contractAddress` (string, optional)
- `hasStaking` (boolean, optional)
- `isUTXOBased` (boolean, optional)
- `isAccountBased` (boolean, optional)
- `isFiat` (boolean, optional)
- `isFA12` (boolean, optional)
- `isFA20` (boolean, optional)
- `isNFT` (boolean, optional)
- `enabled` (boolean, optional)
- `id` (string, optional)
- `displayName` (string, optional)
- `type` (string, optional)
- `wlcaId` (string, optional)
- `network` (string, optional)
- `tokenID` (string, optional)
- `logo` (string, optional) — Data URI Scheme (e.g. 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==')

### 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)

## Examples

**Request**

```json
{
  "walletId": "66313",
  "label": "Address XYZ",
  "comment": "Deposit ABC",
  "customerId": "customerXYZ",
  "currency": "ETH"
}
```

**Response**

```json
{
  "result": {
    "id": "232071",
    "walletId": "66313",
    "seed": "eth",
    "currency": "ETH",
    "addressPath": "m/44'/60'/84'/0'/0'",
    "address": "0x39c4622ac9704dfea991e9c26abcf9bde3c095ac",
    "comment": "Deposit ABC",
    "label": "Address XYZ",
    "customerId": "customerXYZ",
    "balance": {},
    "signature": "XXX",
    "creationDate": "2022-01-25T21:25:15.306338Z",
    "updateDate": "2022-01-25T21:25:15.306338Z",
    "walletInfo": {
      "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/addresses"

payload = {
    "walletId": "66313",
    "label": "Address XYZ",
    "comment": "Deposit ABC",
    "customerId": "customerXYZ",
    "currency": "ETH"
}
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/addresses';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"walletId":"66313","label":"Address XYZ","comment":"Deposit ABC","customerId":"customerXYZ","currency":"ETH"}'
};

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/addresses"

	payload := strings.NewReader("{\n  \"walletId\": \"66313\",\n  \"label\": \"Address XYZ\",\n  \"comment\": \"Deposit ABC\",\n  \"customerId\": \"customerXYZ\",\n  \"currency\": \"ETH\"\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/addresses")

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  \"walletId\": \"66313\",\n  \"label\": \"Address XYZ\",\n  \"comment\": \"Deposit ABC\",\n  \"customerId\": \"customerXYZ\",\n  \"currency\": \"ETH\"\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/addresses")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"walletId\": \"66313\",\n  \"label\": \"Address XYZ\",\n  \"comment\": \"Deposit ABC\",\n  \"customerId\": \"customerXYZ\",\n  \"currency\": \"ETH\"\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/addresses', [
  'body' => '{
  "walletId": "66313",
  "label": "Address XYZ",
  "comment": "Deposit ABC",
  "customerId": "customerXYZ",
  "currency": "ETH"
}',
  '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/addresses");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"walletId\": \"66313\",\n  \"label\": \"Address XYZ\",\n  \"comment\": \"Deposit ABC\",\n  \"customerId\": \"customerXYZ\",\n  \"currency\": \"ETH\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [
  "walletId": "66313",
  "label": "Address XYZ",
  "comment": "Deposit ABC",
  "customerId": "customerXYZ",
  "currency": "ETH"
] 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/addresses")! 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()
```