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

# Check Business Registry

> Checks whether the company registry has a US business before its identification is
submitted. On `match`, the business's own company documents won't be required; documents
for business owners that are themselves companies still are. If the registry is
unavailable when the identification is submitted, a `match` from the last 24 hours is
honoured as long as the name, registration number and state are identical.



## OpenAPI

````yaml https://api.sandbox.iron.xyz/spec/2025-03-13/docs post /customers/{id}/identifications/business-registry-check
openapi: 3.2.0
info:
  description: The Stablecoin Payment Network
  title: Iron API - Sandbox
  version: '2025-03-13'
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/business-registry-check:
    post:
      tags:
        - Identifications
      summary: Check Business Registry
      description: >-
        Checks whether the company registry has a US business before its
        identification is

        submitted. On `match`, the business's own company documents won't be
        required; documents

        for business owners that are themselves companies still are. If the
        registry is

        unavailable when the identification is submitted, a `match` from the
        last 24 hours is

        honoured as long as the name, registration number and state are
        identical.
      operationId: checkBusinessRegistry
      parameters:
        - deprecated: false
          description: a UUID ensuring a registry check 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 check runs under scope
            of the sub-partner
          explode: true
          in: header
          name: X-SUB-PARTNER-ID
          required: false
          schema:
            type: string
        - deprecated: false
          description: the ID of the business Customer to check
          explode: true
          in: path
          name: id
          required: true
          schema:
            format: uuid
            type: string
        - $ref: '#/components/parameters/XApiVersion'
      requestBody:
        content:
          application/json; charset=utf-8:
            schema:
              $ref: '#/components/schemas/BusinessRegistryCheckParams'
        required: true
      responses:
        '200':
          content:
            application/json; charset=utf-8:
              schema:
                $ref: '#/components/schemas/BusinessRegistryCheck'
          description: ''
        '400':
          content:
            application/json; charset=utf-8:
              schema:
                items:
                  $ref: '#/components/schemas/IdentificationError'
                type: array
          description: ''
        '401':
          content:
            application/json; charset=utf-8:
              schema:
                type: string
          description: ''
        '404':
          content:
            application/json; charset=utf-8:
              schema:
                type: string
          description: ''
        '429':
          content:
            application/json; charset=utf-8:
              schema:
                type: string
          description: ''
        '500':
          content:
            application/json; charset=utf-8:
              schema:
                $ref: '#/components/schemas/ApiError'
          description: ''
        '503':
          content:
            application/json; charset=utf-8:
              schema:
                items:
                  $ref: '#/components/schemas/IdentificationError'
                type: array
          description: >-
            The registry is temporarily unavailable; retry after `Retry-After`
            seconds.
          headers:
            RETRY-AFTER:
              deprecated: false
              required: true
              schema:
                format: uint64
                type: integer
      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: '2025-03-13'
  schemas:
    BusinessRegistryCheckParams:
      description: >-
        Business Registry Check Params


        The business as it will be submitted in the identification. A match is
        honoured at

        submission only when the name, registration number and state are
        identical.
      properties:
        company_name:
          description: Registered legal name of the business.
          type: string
        country:
          description: ISO 3166-1 alpha-2 country of registration. Only `US` is supported.
          type: string
        registration_number:
          description: The state registry's entity or file number (not the EIN).
          type: string
        registration_state:
          description: Two-letter code or name of the state the business is registered in.
          type: string
      required:
        - company_name
        - registration_number
        - country
      title: BusinessRegistryCheckParams
      type: object
    BusinessRegistryCheck:
      description: Business Registry Check
      properties:
        checked_at:
          format: date-time
          type: string
        id:
          format: uuid
          type: string
        result:
          $ref: '#/components/schemas/BusinessRegistryCheckResult'
      required:
        - id
        - result
        - checked_at
      title: BusinessRegistryCheck
      type: object
    IdentificationError:
      description: |
        Identification Error

        One machine-readable error entry. Always returned inside an array (see
        [`ApiIdentificationErrorBody`]) even though only one entry is populated
        today — validation is fail-fast — so a future move to reporting every
        problem at once doesn't require another breaking response-shape change.
      properties:
        beneficiary_index:
          description: >-
            Zero-based index into `company_data.beneficiaries` when the error

            originated inside a beneficiary. `None` for root-level errors and
            for

            non-Business identifications.
          format: uint64
          type: integer
        code:
          $ref: '#/components/schemas/ApiIdentificationErrorCode'
        docs_url:
          description: Link to a detailed description of this error code.
          type: string
        message:
          description: Human-readable description of this specific occurrence.
          type: string
      required:
        - code
        - message
        - docs_url
      title: IdentificationError
      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
    BusinessRegistryCheckResult:
      enum:
        - match
        - no_match
      type: string
    ApiIdentificationErrorCode:
      description: >
        Identification Error Code


        Machine-readable classification of a business/person/token
        identification

        failure. Categories, not a 1:1 mirror of internal validation variants —

        internal validation changes don't ripple into the public contract this

        way. See `https://docs.iron.xyz/errors` for a description of every code.
      enum:
        - invalid_request
        - selfie_required
        - selfie_expired
        - tin_required
        - identity_document_rejected
        - identity_document_images_identical
        - structure_invalid
        - attestation_invalid
        - cdd_certification_invalid
        - business_description_insufficient
        - funds_flow_disclosure_required
        - license_details_required
        - company_details_required
        - legal_presence_required
        - ownership_structure_required
        - control_structure_required
        - ubo_country_prohibited
        - ubo_share_below_threshold
        - ubo_subtype_invalid
        - proof_of_address_required_for_edd
        - outsourcing_agreement_not_signed
        - uk_customers_not_enabled
        - country_not_supported
        - duplicate_upload_blocked
        - provider_rejected_document
        - reuse_rejected
        - prohibited_industry
        - industry_required
        - miscellaneous_industry_deprecated
        - intended_use_deprecated
        - foundation_intended_use_not_supported
        - all_deposit_rails_blocked
        - customer_not_found
        - identification_not_found
        - identification_not_updatable
        - business_update_not_supported
        - customer_not_person
        - provider_conflict
        - provider_rejected_submission
        - share_token_rejected
        - signings_required
        - customer_not_business
        - registry_unavailable
      type: string
  securitySchemes:
    ApiKeyAuth:
      description: API Key
      in: header
      name: X-API-Key
      type: apiKey

````