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

> ## Agent Instructions
> Before reading these docs, install the relevant Circle Skill to get pre-loaded context — skills are LLM-optimized and cover architecture decisions, correct flows, and common pitfalls. In Claude Code: run /plugin marketplace add circlefin/skills then /plugin install circle-skills@circle. With Vercel Skills CLI: run npx skills add circlefin/skills. Available skills: use-usdc https://github.com/circlefin/skills/blob/master/plugins/circle/skills/use-usdc/SKILL.md (balances, transfers, approvals on EVM and Solana); EURC has no skill — see https://developers.circle.com/stablecoins/what-is-eurc.md; bridge-stablecoin https://github.com/circlefin/skills/blob/master/plugins/circle/skills/bridge-stablecoin/SKILL.md (crosschain transfers via CCTP, USDC, EURC, and third-party assets); use-arc https://github.com/circlefin/skills/blob/master/plugins/circle/skills/use-arc/SKILL.md (Arc chain config, contract deployment, USDC bridging — Arc docs: https://docs.arc.io/llms.txt); use-circle-wallets https://github.com/circlefin/skills/blob/master/plugins/circle/skills/use-circle-wallets/SKILL.md (choose wallet type); use-developer-controlled-wallets https://github.com/circlefin/skills/blob/master/plugins/circle/skills/use-developer-controlled-wallets/SKILL.md (custodial wallets for payouts and treasury); use-user-controlled-wallets https://github.com/circlefin/skills/blob/master/plugins/circle/skills/use-user-controlled-wallets/SKILL.md (embedded wallets with Web2 login); use-modular-wallets https://github.com/circlefin/skills/blob/master/plugins/circle/skills/use-modular-wallets/SKILL.md (smart contract wallets with passkeys and ERC-4337); use-gateway https://github.com/circlefin/skills/blob/master/plugins/circle/skills/use-gateway/SKILL.md (unified USDC balance, nanopayments); use-smart-contract-platform https://github.com/circlefin/skills/blob/master/plugins/circle/skills/use-smart-contract-platform/SKILL.md (deploy, interact, monitor contracts). Pair any skill with the Circle MCP server for live SDK signatures, contract addresses, and chain IDs: {"mcpServers":{"circle":{"url":"https://api.circle.com/v1/codegen/mcp"}}}.
> Read the product overview first. Each product has an overview explaining when and why to use it. Read it before quickstarts.
> Pick the right wallet type. Developer-controlled (you hold keys), user-controlled (end user holds keys via PIN/social login), or modular (smart contract wallets with passkeys). See https://developers.circle.com/wallets.md.
> Use CCTP V2 for crosschain transfers. CCTP natively transfers USDC and EURC via burn-and-mint, and supports permissionless wrapping of third-party assets via lock-and-mint. V1 is legacy; always use V2 unless V1 is specified or the chain requires it (Noble, Sui, and Aptos still require V1). Migration guide: https://developers.circle.com/cctp/migration-from-v1-to-v2.md.
> Use Bridge Kit for frontend bridging. Wraps CCTP with a simpler SDK for user-facing apps. Use CCTP directly for backend transfers.
> Gas Station vs Paymaster. Gas Station sponsors gas for Circle Wallet transactions. Paymaster lets users pay gas in USDC. Different use cases — read both overviews.
> Gateway Nanopayments for sub-cent payments. Gasless USDC micropayments down to $0.000001 via x402 and batched settlement. For pay-per-request APIs, AI agent payments, streaming.
> Look up USDC addresses per chain. Never hardcode — use https://developers.circle.com/stablecoins/usdc-contract-addresses.md.
> Prefer SDKs over raw API calls. Node.js and Python SDKs handle auth, retries, and errors.
> API key required. Bearer token in Authorization header. Testnet and mainnet use separate keys and may use different base URLs depending on the product.
> Set up webhooks when available. Most operations are async. Webhooks deliver transaction confirmations and state changes.
> When calling list endpoints, paginate using pageSize and pageAfter until no nextPageAfter cursor is returned—stopping at the first page silently misses records.
> Building an AI agent? Start with the Agent Stack—Circle CLI, agent wallets, and nanopayments built for autonomous use cases: https://developers.circle.com/agent-stack.md.

# Create an account

> Creates a new account. This account can be used to create accounts for Mint, or
intermediary accounts for a Managed Payments customer. For Managed Payments, the
account created represents the end customer that will settle stablecoin payments
by the customer. That end customer can be either a business or an individual
(retail) end customer.

Routing for this endpoint is body based. Requests that include `businessPii`,
`individualPii`, or `endCustomerType` are routed to the Managed Payments
intermediary account creation flow, while requests that include none of those
fields are routed to the standard account creation flow.

For Managed Payments, `endCustomerType` selects which PII block is required:

- `business`, or omitted, requires `businessPii` and rejects `individualPii`.
- `individual` requires `individualPii` and rejects `businessPii`.

Both flows require an explicit `type` and `purpose` in the request body:

- Standard (digital asset / Mint) accounts use `purpose` `custody` and `type`
  `first_party` or `third_party`. When `clientEntityId` is omitted the account is
  owned by the caller and `type` must be `first_party`; when `clientEntityId` is
  provided the account is owned by a sub-entity and `type` must be `third_party`.
- Managed Payments intermediary accounts use `type` `first_party` and `purpose`
  `payments`.

To create a non-custodial account for an end customer, send
`custodyType` `self`, `type` `third_party`, `purpose` `custody`, and the end
user's `clientEntityId`. `blockchain` is optional and defaults to `ARC`. The
request must carry an `X-Device-Authorization` header from an authorization key the
end user registered through
`POST /v1/accounts/auth/deviceKeyRegistration`. The Digital Asset Accounts SDK builds and signs
this request, and your backend relay forwards it unchanged. The account is
created with `status` `pending`; get the account until its `status` is
`active` or `rejected`.
To retry after a timeout or a lost response, resend the request with the
same `idempotencyKey`; Circle returns the account it already created. A new
account (a new `idempotencyKey`) needs a new `X-Device-Authorization`
value; reusing one that already created an account returns `409` (error
code 420043).

Requests without `custodyType` create a custodial account as described above.




## OpenAPI

````yaml openapi/accounts.yaml post /v1/accounts
openapi: 3.1.0
info:
  version: 1.0.0
  title: Accounts (Stablecoin) API
  description: >
    Circle's Accounts API provides endpoints for managing stablecoin accounts --
    including transfers,

    withdrawals, deposits, wire and ACH bank accounts, and blockchain addresses.


    An **Account** is a general representation of a ledger or custody object
    that holds balances. It can be a business account,

    a stablecoin account ledger for an end user, an extra sub-ledger, or any
    future custody solution.
  license:
    name: Circle License
    url: https://circle.com/terms
servers:
  - url: https://api-sandbox.circle.com
  - url: https://api.circle.com
security: []
tags:
  - name: Accounts
    description: Manage accounts.
  - name: Account Groups
    description: Manage custody account groups and their memberships.
  - name: Limits
    description: View effective account limits and current usage.
  - name: Transfers
    description: >
      Move funds between accounts or out to a verified blockchain address, and
      track inbound and outbound onchain transfers.
  - name: Contract Executions
    description: >-
      Execute EVM contract calls from non-custodial accounts and track their
      results.
  - name: Transactions
    description: |
      Get a unified, customer-friendly view of account transaction activity.
  - name: Wires
    description: Manage account bank accounts for wire transfers.
  - name: Deposits
    description: Get information on account bank deposits.
  - name: Withdrawals
    description: Manage account bank withdrawals (fiat offramp).
  - name: ACH
    description: Manage account bank accounts for ACH transfers.
  - name: Deposit Addresses
    description: Manage account deposit addresses.
  - name: Recipient Addresses
    description: Manage account recipient addresses used for transfers.
  - name: Device Authentication
    description: >
      Sign in end users of non-custodial accounts with a social login, and
      register the authorization key that signs their non-custodial requests.
      The Digital Asset Accounts SDK builds these requests on the end user's
      device, and your backend relay forwards them with your API key.
  - name: Passkeys
    description: >
      Manage WebAuthn passkeys and Strong Customer Authentication (SCA)
      challenges for end users.
  - name: Crypto Payments
    description: >
      Get crypto payments and crypto refunds received through payment intents.
      Available for Digital Asset Accounts only on custody accounts (`purpose:
      custody`), and only for third-party payments. Not supported when the
      distributor or the end user is under the Circle FR (`CIRCLE_FR`) or Circle
      SG (`CIRCLE_SG`) legal entity.
  - name: Crypto Payment Intents
    description: >
      Create, expire, refund, and track payment intents for receiving crypto
      payments. Available for Digital Asset Accounts only on custody accounts
      (`purpose: custody`), and only for third-party payments. Not supported
      when the distributor or the end user is under the Circle FR (`CIRCLE_FR`)
      or Circle SG (`CIRCLE_SG`) legal entity.
  - name: Crypto Payouts
    description: >
      Create and track crypto payouts to recipient addresses. Available for
      Digital Asset Accounts only on custody accounts (`purpose: custody`), and
      only for third-party payouts. Not supported when the distributor or the
      end user is under the Circle FR (`CIRCLE_FR`) or Circle SG (`CIRCLE_SG`)
      legal entity.
  - name: Crypto Address Book
    description: >
      Manage address book recipients used as crypto payout destinations.
      Available for Digital Asset Accounts only on custody accounts (`purpose:
      custody`), and only for third-party payouts. Not supported when the
      distributor or the end user is under the Circle FR (`CIRCLE_FR`) or Circle
      SG (`CIRCLE_SG`) legal entity.
  - name: FX Trades
    description: |
      Quote and execute USDC <> EURC swaps for end users' accounts.
  - name: FX Settlements
    description: Get settlements of FX trades.
  - name: Webhook Subscriptions
    description: Manage subscriptions to Digital Asset Accounts webhook notifications.
  - name: Webhooks
    description: |
      Webhook event payloads Circle sends to a subscribed endpoint.
paths:
  /v1/accounts:
    post:
      tags:
        - Accounts
      summary: Create an account
      description: >
        Creates a new account. This account can be used to create accounts for
        Mint, or

        intermediary accounts for a Managed Payments customer. For Managed
        Payments, the

        account created represents the end customer that will settle stablecoin
        payments

        by the customer. That end customer can be either a business or an
        individual

        (retail) end customer.


        Routing for this endpoint is body based. Requests that include
        `businessPii`,

        `individualPii`, or `endCustomerType` are routed to the Managed Payments

        intermediary account creation flow, while requests that include none of
        those

        fields are routed to the standard account creation flow.


        For Managed Payments, `endCustomerType` selects which PII block is
        required:


        - `business`, or omitted, requires `businessPii` and rejects
        `individualPii`.

        - `individual` requires `individualPii` and rejects `businessPii`.


        Both flows require an explicit `type` and `purpose` in the request body:


        - Standard (digital asset / Mint) accounts use `purpose` `custody` and
        `type`
          `first_party` or `third_party`. When `clientEntityId` is omitted the account is
          owned by the caller and `type` must be `first_party`; when `clientEntityId` is
          provided the account is owned by a sub-entity and `type` must be `third_party`.
        - Managed Payments intermediary accounts use `type` `first_party` and
        `purpose`
          `payments`.

        To create a non-custodial account for an end customer, send

        `custodyType` `self`, `type` `third_party`, `purpose` `custody`, and the
        end

        user's `clientEntityId`. `blockchain` is optional and defaults to `ARC`.
        The

        request must carry an `X-Device-Authorization` header from an
        authorization key the

        end user registered through

        `POST /v1/accounts/auth/deviceKeyRegistration`. The Digital Asset
        Accounts SDK builds and signs

        this request, and your backend relay forwards it unchanged. The account
        is

        created with `status` `pending`; get the account until its `status` is

        `active` or `rejected`.

        To retry after a timeout or a lost response, resend the request with the

        same `idempotencyKey`; Circle returns the account it already created. A
        new

        account (a new `idempotencyKey`) needs a new `X-Device-Authorization`

        value; reusing one that already created an account returns `409` (error

        code 420043).


        Requests without `custodyType` create a custodial account as described
        above.
      operationId: createAccount
      parameters:
        - $ref: '#/components/parameters/DeviceAuthorizationSelfCustody'
      requestBody:
        content:
          application/json:
            schema:
              oneOf:
                - title: Mint Account
                  description: Create a Mint account
                  allOf:
                    - $ref: '#/components/schemas/AccountCreationRequest'
                  not:
                    required:
                      - custodyType
                - title: Managed Payments Intermediary Account (Business)
                  description: >
                    Create a Managed Payments intermediary account for a
                    business end customer
                  allOf:
                    - $ref: '#/components/schemas/IntermediaryAccountCreationRequest'
                  not:
                    required:
                      - custodyType
                - title: Managed Payments Intermediary Account (Individual)
                  description: >
                    Create a Managed Payments intermediary account for an
                    individual (retail) end customer
                  allOf:
                    - $ref: '#/components/schemas/IndividualAccountCreationRequest'
                  not:
                    required:
                      - custodyType
                - title: Non-Custodial Account
                  description: >
                    Create a non-custodial account for an end customer. Requires
                    the `X-Device-Authorization` header.
                  allOf:
                    - $ref: '#/components/schemas/SelfCustodyAccountCreationRequest'
      responses:
        '201':
          description: Successfully created an account.
          headers:
            X-Request-Id:
              $ref: '#/components/headers/XRequestId'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateAccountResponse'
        '400':
          $ref: '#/components/responses/BadRequest'
        '401':
          $ref: '#/components/responses/DeviceAuthorizationNotAuthorized'
        '409':
          $ref: '#/components/responses/Conflict'
        '500':
          $ref: '#/components/responses/InternalServerError'
      security:
        - bearerAuth: []
components:
  parameters:
    DeviceAuthorizationSelfCustody:
      name: X-Device-Authorization
      in: header
      required: false
      description: >
        Compact ES256 JWS that the Digital Asset Accounts SDK creates on the end
        user's device. It signs this request's method, path, and exact body
        bytes with the authorization key the end user registered. The SDK
        creates a new value for every call. To retry a request, resend the
        original body and header unchanged when you can. Operations where a
        retry with a new header returns `409` (error code 420034) explain in
        that response how to find the original request.


        Required when the request acts on a non-custodial account (`custodyType`
        `self`), and not used for other accounts. A missing value on a
        non-custodial request returns `400` (error code 420031). A value that
        isn't a well-formed compact JWS returns `401` (error code 420031) on any
        account.


        The SDK gives each value an expiry at most 5 minutes after it signs it.
        Circle rejects a value whose expiry has passed or whose signing time is
        in the future, allowing 60 seconds of clock difference either way, with
        `400` (error code 420031). A device clock that's off by more than 60
        seconds causes the same error. Retry within the value's lifetime, or let
        the SDK sign the request again.


        Your backend relay must forward this header, and the request body,
        exactly as the SDK sent them. Don't parse, reformat, or re-serialize the
        body. If the bytes change, Circle rejects the request.
      schema:
        $ref: '#/components/schemas/DeviceAuthorizationJws'
  schemas:
    AccountCreationRequest:
      type: object
      required:
        - idempotencyKey
        - description
        - type
        - purpose
      properties:
        idempotencyKey:
          $ref: '#/components/schemas/IdempotencyKey'
        description:
          type: string
          description: Human-readable description of the account.
          example: My account
        type:
          $ref: '#/components/schemas/AccountType'
        purpose:
          type: string
          description: >
            Intended use of the account. Digital asset (Mint) accounts always
            hold stablecoin balances for the owning entity, so the only
            supported value is `custody`.
          enum:
            - custody
          example: custody
        clientEntityId:
          type: string
          format: uuid
          description: >
            Optional identifier of the client entity whose account should be
            created. If omitted, the account is owned by the caller and `type`
            must be `first_party`. If provided, the account is owned by a
            sub-entity and `type` must be `third_party`.
          example: a3f1b2c4-d5e6-7890-abcd-ef1234567890
    IntermediaryAccountCreationRequest:
      type: object
      required:
        - idempotencyKey
        - description
        - businessPii
        - type
        - purpose
      properties:
        idempotencyKey:
          $ref: '#/components/schemas/IdempotencyKey'
        description:
          description: Human-readable description of the account.
          type: string
          maxLength: 255
        type:
          type: string
          description: >
            External account type. A Managed Payments intermediary account is
            owned by the calling entity, so the only supported value is
            `first_party`.
          enum:
            - first_party
          example: first_party
        purpose:
          type: string
          description: >
            Intended use of the account. Intermediary accounts settle stablecoin
            payments for Managed Payments products, so the only supported value
            is `payments`.
          enum:
            - payments
          example: payments
        endCustomerType:
          type: string
          description: >
            Type of end customer attributed to the account. Optional for a
            business end customer: omitting it is equivalent to `business`.
          enum:
            - business
          example: business
        businessPii:
          $ref: '#/components/schemas/BusinessPii'
    IndividualAccountCreationRequest:
      type: object
      required:
        - idempotencyKey
        - description
        - endCustomerType
        - individualPii
        - type
        - purpose
      properties:
        idempotencyKey:
          $ref: '#/components/schemas/IdempotencyKey'
        description:
          description: Human-readable description of the account.
          type: string
          maxLength: 255
        type:
          type: string
          description: >
            External account type. A Managed Payments intermediary account is
            owned by the calling entity, so the only supported value is
            `first_party`.
          enum:
            - first_party
          example: first_party
        purpose:
          type: string
          description: >
            Intended use of the account. Intermediary accounts settle stablecoin
            payments for Managed Payments products, so the only supported value
            is `payments`.
          enum:
            - payments
          example: payments
        endCustomerType:
          type: string
          description: Type of end customer. Must be `individual` for this request.
          enum:
            - individual
          example: individual
        individualPii:
          $ref: '#/components/schemas/IndividualPii'
    SelfCustodyAccountCreationRequest:
      type: object
      required:
        - idempotencyKey
        - clientEntityId
        - custodyType
        - type
        - purpose
        - description
      properties:
        idempotencyKey:
          $ref: '#/components/schemas/IdempotencyKey'
        clientEntityId:
          type: string
          format: uuid
          description: >
            The end customer who owns the account. Must be the end customer
            whose end user's authorization key signed the
            `X-Device-Authorization` header.
          example: a3f1b2c4-d5e6-7890-abcd-ef1234567890
        custodyType:
          type: string
          description: >
            Must be `self` to create a non-custodial account. `self`
            (non-custodial) is available in sandbox only. Production
            non-custodial accounts are on the roadmap.
          enum:
            - self
          example: self
        type:
          type: string
          description: >
            External account type. A non-custodial account is owned by an end
            customer, so the only supported value is `third_party`.
          enum:
            - third_party
          example: third_party
        purpose:
          type: string
          description: |
            Intended use of the account. The only supported value is `custody`.
          enum:
            - custody
          example: custody
        description:
          type: string
          description: Human-readable description of the account.
          maxLength: 255
          example: USDC account
        blockchain:
          description: >
            Home blockchain of the account. Optional, and defaults to `ARC`. You
            can't change it later.
          default: ARC
          allOf:
            - $ref: '#/components/schemas/SelfCustodyBlockchain'
    CreateAccountResponse:
      title: CreateAccountResponse
      properties:
        data:
          $ref: '#/components/schemas/CreatedAccount'
    DeviceAuthorizationJws:
      type: string
      description: >-
        Compact ES256 JWS created by the Digital Asset Accounts SDK on the end
        user's device.
      minLength: 64
      maxLength: 8192
      example: >-
        eyJhbGciOiJFUzI1NiJ9.e30.AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0-Pw
    IdempotencyKey:
      type: string
      description: >-
        Universally unique identifier (UUID v4) idempotency key. This key is
        utilized to ensure exactly-once execution of mutating requests.
      format: uuid
      example: ba943ff1-ca16-49b2-ba55-1057e70ca5c7
    AccountType:
      type: string
      description: |
        External account type.

        - `first_party`: the calling entity itself owns the account.
        - `third_party`: a sub-entity or end user owns the account.
      enum:
        - first_party
        - third_party
      example: first_party
    BusinessPii:
      type: object
      description: PII for the business sub-client being onboarded.
      required:
        - businessName
        - businessUniqueIdentifier
        - identifierIssuingCountryCode
        - address
      properties:
        businessName:
          type: string
          example: Acme Corporation
        businessUniqueIdentifier:
          type: string
          description: e.g. EIN or company registration number.
          example: 12-3456789
        identifierIssuingCountryCode:
          type: string
          description: ISO 3166-1 alpha-2.
          example: US
        address:
          $ref: '#/components/schemas/ManagedPaymentsAddress'
    IndividualPii:
      type: object
      description: PII for the individual (retail) end customer being onboarded.
      required:
        - firstName
        - lastName
        - dateOfBirth
        - address
      properties:
        firstName:
          type: string
          example: John
        lastName:
          type: string
          example: Doe
        dateOfBirth:
          type: string
          format: date
          description: Date of birth in `yyyy-MM-dd` format. Must be in the past.
          example: '1990-10-23'
        address:
          $ref: '#/components/schemas/ManagedPaymentsAddress'
    SelfCustodyBlockchain:
      type: string
      description: >
        Home blockchain of a non-custodial account. Set when the account is
        created and can't be changed. If account creation omits it, the home
        blockchain is `ARC`. `MATIC` is Polygon PoS. Some other endpoints in
        this API call it `POLY`; send `MATIC` here. Not every value is available
        in every environment. A blockchain that isn't available returns `400`.
      enum:
        - APTOS
        - ARB
        - ARC
        - AVAX
        - BASE
        - ETH
        - MATIC
        - MONAD
        - NEAR
        - OP
        - SOL
        - UNI
      example: ARC
    XRequestId:
      type: string
      format: uuid
      example: 2adba88e-9d63-44bc-b975-9b6ae3440dde
    CreatedAccount:
      type: object
      description: An account returned by the create account endpoint.
      required:
        - accountId
        - entityId
        - type
        - purpose
        - status
        - description
        - balances
      properties:
        accountId:
          type: string
          description: Identifier of the account.
          example: '1000662322'
        entityId:
          type: string
          format: uuid
          description: Identifier of the owning entity.
          example: a49f9b1d-75e0-44a9-b8d2-4293b3f11ebd
        clientEntityId:
          type: string
          format: uuid
          description: Identifier of the client entity, if applicable.
          example: a3f1b2c4-d5e6-7890-abcd-ef1234567890
        custodyType:
          $ref: '#/components/schemas/CustodyType'
        type:
          $ref: '#/components/schemas/AccountType'
        purpose:
          $ref: '#/components/schemas/AccountPurpose'
        status:
          $ref: '#/components/schemas/AccountStatus'
        description:
          type: string
          description: Human-readable description of the account.
          example: My account
        balances:
          type: array
          description: Balances currently associated with the account.
          items:
            $ref: '#/components/schemas/Money'
        businessPii:
          $ref: '#/components/schemas/BusinessPii'
          description: >
            PII for the business sub-client associated with a Managed Payments
            intermediary account. Omitted for accounts that are not Managed
            Payments intermediary accounts.
        groupId:
          type:
            - string
            - 'null'
          format: uuid
          description: >
            Identifier of the custody account group this account belongs to, or
            `null` if it is not assigned to any group.
          example: 9c0f1c0d-6c61-4f3d-9b8a-1a3a4b3c5d6e
        blockchain:
          $ref: '#/components/schemas/SelfCustodyBlockchain'
        depositAddress:
          $ref: '#/components/schemas/SelfCustodyDepositAddress'
    Error:
      type: object
      required:
        - code
        - message
      properties:
        code:
          type: integer
          description: >
            Circle internal status code from the platform `CoreStatusCode` enum
            (and its domain-specific extensions). **This is not the HTTP status
            code** — `-1` is the catch-all unknown error, `1`/`2` indicate API
            parameter problems, `3` is forbidden, `4` is unauthorized, and
            larger values identify domain-specific failures. Consumers should
            rely on the HTTP status line for transport-level error class and on
            this field for the specific Circle error case.
          example: 2
        message:
          type: string
          description: >-
            Internal error message; suitable for logging but not for end-user
            display.
          example: API parameter invalid.
        externalMessage:
          type: string
          description: >
            End-user-displayable error message. Present when the server has
            generated a customer-facing variant for this error; omitted
            otherwise.
          example: The provided amount exceeds the maximum allowed.
        errors:
          type: array
          description: Additional request-field validation errors, when available.
          items:
            $ref: '#/components/schemas/ErrorDetail'
    ManagedPaymentsAddress:
      type: object
      description: Physical address of the end customer being onboarded.
      required:
        - line1
        - city
        - postalCode
        - country
      properties:
        line1:
          type: string
          description: Address line 1.
          example: 100 Pine Street
        line2:
          type: string
          description: Address line 2 (optional).
          example: Suite 2500
        city:
          type: string
          example: San Francisco
        district:
          type: string
          description: State or province code.
          example: CA
        postalCode:
          type: string
          example: '94111'
        country:
          type: string
          description: ISO 3166-1 alpha-2 country code.
          example: US
    CustodyType:
      type: string
      description: >
        How the account's assets are held.


        - `omnibus`: Circle holds the assets in a pooled account. This is the
        default
          for new accounts.

        - `self`: a non-custodial account. The end user authorizes changes
          with the authorization key registered through the Digital Asset Accounts SDK.
          `self` (non-custodial) is available in sandbox only. Production
          non-custodial accounts are on the roadmap.
      enum:
        - omnibus
        - self
      example: omnibus
    AccountPurpose:
      type: string
      description: |
        Intended use of the account.

        - `custody`: the account holds stablecoin balances for the owning
          entity. This is the default for new accounts.

        - `payments`: the account is used for Managed Payments products.
      enum:
        - custody
        - payments
      example: custody
    AccountStatus:
      type: string
      description: >
        Lifecycle status of the account.


        - `active`: account is fully operational.

        - `pending`: account has been created but is not yet operational.

        - `rejected`: account creation was rejected and the account cannot be
        used.

        - `archived`: account has been archived and is excluded from default
          listings. Most mutating operations on the account (transfers, withdrawals,
          new address generation, etc.) are blocked while archived.
      enum:
        - active
        - pending
        - rejected
        - archived
      example: active
    Money:
      type: object
      required:
        - amount
        - currency
      properties:
        amount:
          type: string
          description: Magnitude of the amount, in units of the currency, with a `.`.
          example: '3.14'
        currency:
          type: string
          description: >
            Currency code for the amount. `ETH` appears only in responses, as
            the native value of `contract_execution` activity on ETH-native
            chains.
          example: USD
          enum:
            - USD
            - EUR
            - ETH
    SelfCustodyDepositAddress:
      type: string
      description: >
        Address where a non-custodial account receives funds on its home
        blockchain. Omitted until the address is ready.
      example: '0x8f3a2b1c4d5e6f708192a3b4c5d6e7f8091a2b3c'
    ErrorDetail:
      type: object
      required:
        - error
        - message
      properties:
        error:
          type: string
          description: Machine-readable error identifier.
          example: invalid_value
        location:
          type: string
          description: Query parameter or request field that caused the error.
          example: assetType
        message:
          type: string
          description: Human-readable description of the specific error.
          example: The operation and assetType combination is invalid.
  headers:
    XRequestId:
      description: >
        Circle-generated universally unique identifier (UUID v4). Useful for
        identifying a specific request when communicating with Circle Support.
      schema:
        $ref: '#/components/schemas/XRequestId'
  responses:
    BadRequest:
      description: The request cannot be processed due to a client error.
      headers:
        X-Request-Id:
          $ref: '#/components/headers/XRequestId'
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            code: 2
            message: API parameter invalid.
    DeviceAuthorizationNotAuthorized:
      description: >
        The request lacks valid API credentials, or a device authorization
        header (`X-Device-Authorization` or `X-Registration-Flow-Authorization`)
        is present but isn't a well-formed compact JWS (error code 420031).
      headers:
        X-Request-Id:
          $ref: '#/components/headers/XRequestId'
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            code: 420031
            message: The device authorization is invalid
    Conflict:
      description: The request conflicts with an existing resource or idempotent request.
      headers:
        X-Request-Id:
          $ref: '#/components/headers/XRequestId'
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            code: 409
            message: Conflict.
    InternalServerError:
      description: >-
        The server encountered an unexpected condition that prevented it from
        fulfilling the request.
      headers:
        X-Request-Id:
          $ref: '#/components/headers/XRequestId'
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            code: -1
            message: 'Something went wrong. errId: 1f0b0c455e40f753f07b4f0ae6abd4b4'
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer

````