# Create deposit

URL: https://docs.hanzo.ai/docs/openapi/billing/post-billing-crypto-deposit

> Issues a deposit address the caller can send crypto to, on the asset they ask for.

`POST /v1/billing/crypto/deposit`

> [Billing →](https://docs.hanzo.ai/docs/openapi/billing) · [All API references →](https://docs.hanzo.ai/docs/openapi) · [Get started →](https://docs.hanzo.ai/docs/guides)

|               |                                                  |
| ------------- | ------------------------------------------------ |
| **Address**   | `https://api.hanzo.ai/v1/billing/crypto/deposit` |
| **Method**    | `POST`                                           |
| **Operation** | `post_billing_crypto_deposit`                    |
| **Auth**      | `Authorization: Bearer $HANZO_API_KEY`           |

Issues a deposit address the caller can send crypto to, on the asset they ask
for.

The address credits the CALLER'S own wallet and nobody else's: the payer is
the validated principal, never a body value. Asking again reuses the caller's
open intent rather than minting a second address, so a refresh cannot spray
key generations — and a payer who sent to the address they saw earlier is
still credited.

No balance moves here. The chain watcher credits on real confirmations, so
what comes back is an address and a status, not a receipt.

An asset this rail cannot mint on is 400 — ask for another. A rail that is
shut for that asset is 503 — nothing sent now can be credited.

A named handler, not a closure, so zipdoc can lift this prose into the registry.

## Request

3 fields, body `application/json` (required).

| Field         | In   | Type            | Required | Description                                                    |
| ------------- | ---- | --------------- | -------- | -------------------------------------------------------------- |
| `amountCents` | body | integer (int64) | —        | AmountCents is what the payer intends to send, for the record. |
| `chain`       | body | string          | —        | Chain is the network to receive on.                            |
| `token`       | body | string          | —        | Token is the asset on that chain.                              |

## Response

| Status    | Body                  | Meaning |
| --------- | --------------------- | ------- |
| `200`     | billing.CryptoDeposit | ok      |
| `default` | problem-details       | refused |

`200` body — 7 fields.

| Field            | In   | Type   | Always | Description |
| ---------------- | ---- | ------ | ------ | ----------- |
| `addressTag`     | body | string | —      |             |
| `chain`          | body | string | —      |             |
| `depositAddress` | body | string | —      |             |
| `expiresAt`      | body | string | —      |             |
| `id`             | body | string | —      |             |
| `status`         | body | string | —      |             |
| `token`          | body | string | —      |             |

Failure carries the platform error shape — see [Errors](https://docs.hanzo.ai/docs/errors).

## Examples

**CLI**

```bash
hanzo billing crypto deposit create
```

**SDK**

**.ts**

```ts
import { Configuration, BillingApi } from 'hanzoai';

const api = new BillingApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.postBillingCryptoDeposit({ amountCents: 0, chain: "<chain>" });
```

**.py**

```python
from hanzoai.cloud import ApiClient, Configuration
from hanzoai.cloud.api import BillingApi

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = BillingApi(client).post_billing_crypto_deposit(amount_cents=0, chain="<chain>")
```

**.go**

```go
cfg := hanzoai.NewConfiguration()
cfg.AddDefaultHeader("Authorization", "Bearer "+os.Getenv("HANZO_API_KEY"))
client := hanzoai.NewAPIClient(cfg)

resp, _, err := client.BillingAPI.PostBillingCryptoDeposit(context.Background()).Execute()
if err != nil {
	return err
}
```

**.rs**

```rust
use hanzo_client::apis::{configuration::Configuration, billing_api};

let mut cfg = Configuration::new();
cfg.bearer_access_token = std::env::var("HANZO_API_KEY").ok();

let result = billing_api::post_billing_crypto_deposit(&cfg, Default::default()).await?;
```

**.java**

```java
import ai.hanzo.cloud.ApiClient;
import ai.hanzo.cloud.api.BillingApi;

ApiClient client = new ApiClient();
client.setBearerToken(System.getenv("HANZO_API_KEY"));

var result = new BillingApi(client).postBillingCryptoDeposit();
```

**HTTP**

```bash
curl -X POST https://api.hanzo.ai/v1/billing/crypto/deposit \
  -H "Authorization: Bearer $HANZO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
       "amountCents": 0,
       "chain": "<chain>"
     }'
```

**MCP**

MCP reaches **billing** through the `billing` tool, which names its 39 operations with its own verbs — this one among them, under a name only MCP declares. `describe` explains any of them:

```bash
curl -X POST https://api.hanzo.ai/v1/mcp \
  -H "Content-Type: application/json" \
  -d '{
       "jsonrpc": "2.0",
       "id": 1,
       "method": "tools/call",
       "params": {
         "name": "describe",
         "arguments": {
           "op": "list_billing_accounts"
         }
       }
     }'
```

---

[Billing API](https://docs.hanzo.ai/docs/openapi/billing) · [All Hanzo APIs](https://docs.hanzo.ai/docs/openapi) · [Interactive reference](https://docs.hanzo.ai/docs/openapi/reference)