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

# Upload Identification Document

> Stores one document (at most 10 MB) for the customer's next identification and returns
an `idoc_` id. Send that id instead of the base64 content in any document field of
Create Customer Identification, e.g. `identity.selfie` or `company_data.documents[].file`,
so a payload with many documents stays small. Inline base64 keeps working, and both can
be mixed. The document is validated when the identification uses it, encrypted at rest,
usable only for this customer, and deleted after 24 hours. A partner can upload at most
300 documents per rolling hour. Not available on sandbox, where documents stay inline.



## OpenAPI

````yaml https://api.sandbox.iron.xyz/spec/2026-07-01/docs post /customers/{id}/identifications/documents
openapi: 3.2.0
info:
  description: The Stablecoin Payment Network
  title: Iron API - Sandbox
  version: '2026-07-01'
servers:
  - url: https://api.sandbox.iron.xyz/api
security: []
tags:
  - description: Operations on Customers
    kind: nav
    name: Customer
  - description: Verifying a customer's identity or business
    kind: nav
    name: Identifications
    parent: Customer
  - description: The legal agreements and consents a customer signs
    kind: nav
    name: Signings
    parent: Customer
  - description: Compliance requests for documents or answers from a customer
    kind: nav
    name: Requests for information
    parent: Customer
  - description: Codes that authorize an autoramp or bank account awaiting authorization
    kind: nav
    name: Authentication codes
    parent: Customer
  - description: >-
      Wallet and bank account registration


      Every wallet address that interacts with Iron must be registered (linked)
      to a customer **before** it can be used in any flow — onramp, offramp, or
      swap. This is a regulatory requirement under the **Travel Rule**, which
      obliges Virtual Asset Service Providers to exchange originator and
      beneficiary information for crypto transfers.


      Iron supports two wallet types:


      - **Self-hosted wallets** — the customer controls the private key.
      Registration requires a signed proof-of-ownership message.

      - **Hosted wallets** — the wallet is custodied by another VASP (e.g.
      Coinbase, Kraken). Registration requires the VASP's DID so Iron can
      exchange travel-rule data with the custodian.


      Similarly, fiat bank accounts must be registered before they can receive
      offramp payouts.
    kind: nav
    name: Addresses
  - description: Bank accounts that receive offramp payouts
    kind: nav
    name: Bank accounts
    parent: Addresses
  - description: Self-hosted and hosted wallets
    kind: nav
    name: Wallets
    parent: Addresses
  - description: Pix keys that receive BRL payouts
    kind: nav
    name: Pix
    parent: Addresses
  - description: Operations on Autoramp
    kind: nav
    name: Autoramp
  - description: Prices for an autoramp's conversion
    kind: nav
    name: Quotes
    parent: Autoramp
  - description: Paying into an autoramp by open banking or Pix
    kind: nav
    name: Payments
    parent: Autoramp
  - description: The transactions autoramps execute
    kind: nav
    name: Transactions
    parent: Autoramp
  - description: Operations on Currencies
    kind: nav
    name: Currencies
  - description: Operations on Exchange Rate
    kind: nav
    name: ExchangeRate
  - description: Operations on Fee Profiles
    kind: nav
    name: FeeProfiles
  - description: Operations on Webhooks
    kind: nav
    name: Webhooks
  - description: Operations on Terms and Conditions
    kind: nav
    name: TermsAndConditions
  - description: Operations for Sandbox Testing
    kind: nav
    name: Sandbox
paths:
  /customers/{id}/identifications/documents:
    post:
      tags:
        - Identifications
      summary: Upload Identification Document
      description: >-
        Stores one document (at most 10 MB) for the customer's next
        identification and returns

        an `idoc_` id. Send that id instead of the base64 content in any
        document field of

        Create Customer Identification, e.g. `identity.selfie` or
        `company_data.documents[].file`,

        so a payload with many documents stays small. Inline base64 keeps
        working, and both can

        be mixed. The document is validated when the identification uses it,
        encrypted at rest,

        usable only for this customer, and deleted after 24 hours. A partner can
        upload at most

        300 documents per rolling hour. Not available on sandbox, where
        documents stay inline.
      operationId: uploadCustomerIdentificationDocument
      parameters:
        - deprecated: false
          description: a UUID ensuring a document upload is only processed once
          explode: true
          in: header
          name: IDEMPOTENCY-KEY
          required: true
          schema:
            type: string
        - deprecated: false
          description: >-
            Optional sub-partner UUID, if provided, the document is uploaded for
            the sub-partner's customer
          explode: true
          in: header
          name: X-SUB-PARTNER-ID
          required: false
          schema:
            type: string
        - deprecated: false
          description: the ID of the Customer the document belongs to
          explode: true
          in: path
          name: id
          required: true
          schema:
            format: uuid
            type: string
        - $ref: '#/components/parameters/XApiVersion'
      requestBody:
        content:
          multipart/form-data:
            schema:
              properties:
                file:
                  format: binary
                  type: string
              required:
                - file
              type: object
        required: true
      responses:
        '201':
          content:
            application/json; charset=utf-8:
              schema:
                $ref: '#/components/schemas/IdentificationDocumentUpload'
          description: Document stored
        '400':
          content:
            application/json; charset=utf-8:
              schema:
                type: string
          description: The file is empty or larger than 10 MB
        '401':
          content:
            application/json; charset=utf-8:
              schema:
                type: string
          description: Unauthorized
        '404':
          content:
            application/json; charset=utf-8:
              schema:
                type: string
          description: Customer not found, or uploads are not enabled (sandbox)
        '429':
          content:
            application/json; charset=utf-8:
              schema:
                type: string
          description: Upload limit reached (300 per partner per rolling hour)
        '500':
          content:
            application/json; charset=utf-8:
              schema:
                $ref: '#/components/schemas/ApiError'
          description: Internal error
      security:
        - ApiKeyAuth: []
components:
  parameters:
    XApiVersion:
      description: >-
        Selects the API version for this request, as an ISO date (`YYYY-MM-DD`).
        Omit to use the default version (`2025-03-13`). Supported versions:
        2025-03-13, 2026-07-01, 2026-08-01, 2026-10-01, 2026-10-15.
      in: header
      name: X-API-Version
      required: false
      schema:
        type: string
        x-default: '2026-07-01'
  schemas:
    IdentificationDocumentUpload:
      description: |-
        Identification Document Upload

        A document stored for one customer's identification payload.
      properties:
        expires_at:
          description: >-
            The id is rejected, and the document deleted, after this time (24
            hours after upload).
          format: date-time
          type: string
        id:
          description: >-
            Send this id instead of the base64 content in any document field of
            this customer's

            identification payload, e.g.
            `idoc_0193a1f2-5b7c-7d3e-9f10-2a3b4c5d6e7f`.
          type: string
        size_bytes:
          description: The file size in bytes
          format: int64
          type: integer
      required:
        - id
        - size_bytes
        - expires_at
      title: IdentificationDocumentUpload
      type: object
    ApiError:
      description: |-
        Standard error response returned to API clients for server errors.
        Includes a trace_id that clients can reference when reporting issues.
      properties:
        message:
          description: Human-readable error message
          type: string
        trace_id:
          description: Trace ID that can be used to look up request details in logs
          type: string
      required:
        - message
        - trace_id
      title: ApiError
      type: object
  securitySchemes:
    ApiKeyAuth:
      description: API Key
      in: header
      name: X-API-Key
      type: apiKey

````