> ## Documentation Index
> Fetch the complete documentation index at: https://docs.quantumapi.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Token management overview

> Manage QRC token lifecycles through Qustody — create, deploy, mint, burn, and govern with policy-controlled approvals and post-quantum signing.

Qustody Token Management exposes structured endpoints to manage [QRC token](/reference/token-standards) lifecycles end-to-end: configure, deploy, mint, burn, transfer, govern roles, pause, freeze, and apply compliance-aware controls. Every privileged operation runs through the existing Qustody [approval policy](/concepts/policies) engine, is signed with [post-quantum signatures](/concepts/quantum-safety), and is recorded in the [audit log](/qustody/security-model).

## Two paths

Qustody supports two ways to work with tokens. Pick the path that fits your team.

### Path A — Managed Token API

The default path for most teams. Qustody abstracts the QRC standards and exposes typed endpoints that map to common operations.

* Structured request/response schemas per standard
* Approval policy enforcement out of the box
* Idempotency keys, webhooks, and audit-log integration
* Fewer moving pieces — no Solidity tooling required

Use this path when you are happy with one of the supported [QRC standards](/reference/token-standards) and want operational velocity.

→ [Managed Token API reference](/api-reference/tokens/list-token-standards)

### Path B — Advanced RPC + bytecode

For teams that need a custom contract or behaviour beyond the managed API.

* Compile your own Solidity, generate ABI + bytecode
* Submit deployment and contract-call transactions directly through Qustody (or through Quantum Chain RPC)
* Reuse the same approval-policy and post-quantum-signing flow

Use this path when you need custom logic, an extra extension, or compatibility with an existing on-chain contract.

→ [Advanced RPC and bytecode](/qustody/token-management/rpc-and-bytecode)

## What you can do

| Capability                                         | Path A (managed) |           Path B (advanced)          |
| -------------------------------------------------- | :--------------: | :----------------------------------: |
| Configure a token before deployment                |        Yes       |                  N/A                 |
| Estimate deployment cost                           |        Yes       |         Via existing tx flow         |
| Deploy a token contract through approval + signing |        Yes       |      Via `CONTRACT_CALL` / `RAW`     |
| Mint, burn, transfer with structured endpoints     |        Yes       |     Manual ABI encoding required     |
| Manage roles, pause, freeze                        |        Yes       |     Manual ABI encoding required     |
| Allowlist / compliance-aware controls              |        Yes       |     Manual ABI encoding required     |
| Idempotency, webhooks, audit per token operation   |        Yes       | Inherited from transaction lifecycle |
| Custom non-standard contract                       |        No        |                **Yes**               |

## How a token operation flows

Every token operation reuses the existing [transaction state machine](/concepts/state-machine):

```mermaid theme={null}
sequenceDiagram
  participant Op as Operator
  participant API as Custody API
  participant Pol as Approval Policy
  participant Sig as Post-Quantum Signer
  participant Chain as Quantum Chain
  participant Audit as Audit Log

  Op->>API: Request token operation (deploy / mint / burn / …)
  API->>Audit: Record operation requested
  API->>Pol: Evaluate policy
  alt Approval required
    Pol-->>API: PENDING_AUTHORIZATION
    API-->>Op: Operation pending approval
    Pol->>API: Approval granted
  end
  API->>Sig: Request post-quantum signature on transaction digest
  Sig-->>API: Signature + public key
  API->>Chain: Broadcast signed transaction
  Chain-->>API: Receipt + status
  API->>Audit: Record final result
  API-->>Op: Operation completed
```

See the full [token operation lifecycle](/qustody/token-management/token-operation-lifecycle) for deploy and mint/burn diagrams.

## Where to next

<CardGroup cols={2}>
  <Card title="Standards" icon="layer-group" href="/reference/token-standards">
    Catalogue of supported QRC standards and their operations.
  </Card>

  <Card title="Object model" icon="cubes" href="/qustody/token-management/objects">
    `Token`, `TokenStandard`, `TokenTemplate`, `TokenOperation`.
  </Card>

  <Card title="Lifecycle" icon="diagram-project" href="/qustody/token-management/token-operation-lifecycle">
    Deploy and mint/burn flows end-to-end.
  </Card>

  <Card title="Security model" icon="shield-halved" href="/qustody/token-management/security-model">
    Privileged operations, governance, and audit.
  </Card>

  <Card title="Compatibility" icon="arrows-left-right" href="/qustody/token-management/compatibility">
    Fireblocks-shape compatibility positioning.
  </Card>

  <Card title="Advanced contracts" icon="code" href="/qustody/token-management/advanced-contracts">
    Path B — deploy custom QRC-compatible contracts.
  </Card>
</CardGroup>