# Get Usage
Source: https://docs.crossmint.com/api-reference/admin/get-usage

get /v1-alpha1/projects/{projectId}/usage
Get usage data for a project.

**API scope required** `projects:usage.read`


<Snippet />


# Get Action Status
Source: https://docs.crossmint.com/api-reference/common/get-action-status

get /2022-06-09/actions/{actionId}
Use this API to poll for the status of asynchonous actions such as NFT mints, transfers, etc.

**API scope required**: `nfts.create`


<Note>
  The shape of the data property in the `200` response for this API depends on the type of action initially performed.
  For example, minting/burning an NFT, creating/updating a collection or template, or NFT transfers.
</Note>

The `action` property will indicate the type of action originally performed and will be one of:

* `nfts.create`
* `nfts.delete`
* `nfts.update`
* `collections.create`
* `collections.update`
* `wallets:nfts.transfer`


# Check Token Support
Source: https://docs.crossmint.com/api-reference/headless/check-token-support

GET /v1-alpha2/tokens/{tokenLocator}
Get a token by its locator



# Create Order
Source: https://docs.crossmint.com/api-reference/headless/create-order

post /2022-06-09/orders
Creates a new order that can be used to complete a headless checkout.

**API scope required**: `orders.create`




# Edit Order
Source: https://docs.crossmint.com/api-reference/headless/edit-order

patch /2022-06-09/orders/{orderId}
Edit an existing order. You can update the recipient, the payment method, and/or the locale.

**API scope required**: `orders.update`




# Get All Tokens
Source: https://docs.crossmint.com/api-reference/headless/get-all-tokens

GET /v1-alpha2/tokens
Retrieve a paginated list of all supported tokens for checkout. Sorted by most recent first.



# Get Order
Source: https://docs.crossmint.com/api-reference/headless/get-order

get /2022-06-09/orders/{orderId}
Get specific order by ID.

**Authentication**: Use either a server-side API key with `orders.read` scope, or the `clientSecret` from order creation as an authorization header.




# Process Payment
Source: https://docs.crossmint.com/api-reference/headless/process-payment

post /2022-06-09/orders/{orderId}/payment
Process payment for an order using a crypto transaction ID.

**Authentication**: Use either a server-side API key with `orders.update` scope, the `clientSecret` from order creation as an authorization header, or a JWT token with `orders.create` scope.




# Introduction
Source: https://docs.crossmint.com/api-reference/introduction

Explore the APIs and test them live from the browser

This section provides a detailed guide for each of the APIs, with sample code and responses.

## Testing the APIs from the browser

The reference pages allow you to call the APIs directly from the browser. To get started:

1. Create a developer account on the [Staging](https://staging.crossmint.com/console) or [Production](https://www.crossmint.com/console) consoles. Read more about the environments [here](/introduction/platform/staging-vs-production).
2. Create an [API key](/introduction/platform/api-keys) from the `API keys` tab on the console, with the permissions required for the APIs you want to use.
3. From the page of your API of choice, insert the right API key in the authorization slot, introduce the different parameters, and call "Send".
4. (Optional) To call APIs in the production environment, find the API endpoint selector (`⌄`) next to the endpoint URL, and change it to `www.crossmint.com/api`.

The following guide will show you how to create a wallet and mint an NFT into it within 5 minutes. For this, make sure your API key has the scopes `wallets.create`, and `nfts.create`.

<AccordionGroup>
  <Accordion title="1. Creating Wallets from the API Reference">
    Follow the next steps to create a wallet within 5 minutes:

    <Steps>
      <Step title="Navigate to the Create Wallet page">
        <Frame type="simple">
          <img alt="Navigate to create wallet endpoint screenshot with light theme" />

          <img alt="Navigate to create wallet endpoint screenshot with dark theme" />
        </Frame>
      </Step>

      <Step title="Select the correct environment for the API key you created">
        <Frame type="simple">
          <img alt="Set environment URL screenshot" />

          <img alt="Set environment URL screenshot" />
        </Frame>
      </Step>

      <Step title="Input your API key into the Authorization section">
        <Frame type="simple">
          <img alt="Set x-api-key screenshot" />

          <img alt="Set x-api-key screenshot" />
        </Frame>
      </Step>

      <Step title="Input the `body` parameters">
        You may add any additional properties. Each API reference page includes the full list of properties and admissible values.

        <Frame type="simple">
          <img alt="Set body params screenshot with light theme" />

          <img alt="Set body params screenshot with dark theme" />
        </Frame>
      </Step>

      <Step title="Send the request">
        Scroll back to the top of the page and click the blue `Send` button to trigger
        the API call.

        <Frame type="simple">
          <img alt="Send request screenshot with light theme" />

          <img alt="Send request screenshot with dark theme" />
        </Frame>

        Here is an example response object:

        <Frame type="simple">
          <img alt="create user wallet response screenshot with light theme" />

          <img alt="create user wallet response screenshot with dark theme" />
        </Frame>
      </Step>
    </Steps>

    **Success!** The next guide will show you how to mint an NFT into this wallet and view the content.
  </Accordion>

  <Accordion title="2. Mint NFTs from the API Reference">
    In the previous guide, you created a wallet. Now you will deliver an NFT into it and read the wallet's content.

    <Steps>
      <Step title="Navigate to the Mint NFT page">
        <p>Open in a new tab here: <a href="/api-reference/minting/nfts/mint-nft">/api-reference/minting/nfts/mint-nft</a></p>

        <Frame type="simple">
          <img alt="Mint NFT in api playground screenshot with light theme" />

          <img alt="Mint NFT in api playground screenshot with light theme" />
        </Frame>
      </Step>

      <Step title="Enter the `default-polygon` collectionId">
        This is a default collection associated to your account. You can create new ones using the [Create Collections](/minting/nfts/integrate/create-collections) API.

        <Frame type="simple">
          <img alt="Enter collectionId screenshot with light theme" />

          <img alt="Enter collectionId screenshot with dark theme" />
        </Frame>
      </Step>

      <Step title="Select the [EVM] Metadata URL metadata option">
        <Note>The selector to choose between the different metadata option can be hard to spot. Look closely at the screenshots below to see where it is.</Note>

        <Frame type="simple">
          <img alt="Select EVM metadata URL option screenshot with light theme" />

          <img alt="Select EVM metadata URL option screenshot with dark theme" />
        </Frame>

        <br />

        <Frame type="simple">
          <img alt="Enter metadata URL screenshot with light theme" />

          <img alt="Enter metadata URL screenshot with dark theme" />
        </Frame>
      </Step>

      <Step title="Enter metadata URL">
        You can provide your own or use this example URL:

        <CodeGroup>
          ```bash metadata URL theme={null}
          https://bafkreidbf4jpxpecwezjbagwmua5qv62ifhhtzsspoml7zls6iq6ms4byi.ipfs.nftstorage.link/
          ```

          ```json example JSON theme={null}
          {
            "name": "Crossmint Test NFT",
            "description": "Created with the Crossmint minting API",
            "image": "https://bafkreiexjl6kw4khdxkrt6dojgacscnzvrys47t472l2t7d6r2ss65kifq.ipfs.nftstorage.link/",
            "external_url": "https://docs.crossmint.com",
            "attributes":  [
              {
                "trait_type": "contract",
                "value": "ERC-721"
              },
              {
                "trait_type": "background",
                "value": "black"
              }
            ]
          }
          ```
        </CodeGroup>

        <br />

        <Note>This URL must point to a valid JSON file that adheres to [EVM metadata standards](/minting/nfts/integrate/define-metadata).</Note>

        <Frame type="simple">
          <img alt="Enter metadata url screenshot with light theme" />

          <img alt="Enter metadata url screenshot with dark theme" />
        </Frame>
      </Step>

      <Step title="Enter the `recipient`">
        There are two options for the `recipient` parameter. The first enables minting to an email address. The second enables minting directly to a wallet address.

        <CodeGroup>
          ```javascript email recipient theme={null}
            // format
            email:<email_address>:<chain>

            // example
            email:testy@crossmint.xyz:polygon
          ```

          ```javascript wallet recipient theme={null}
            // format
            <chain>:<address>

            // example
            polygon:0x0359Cd99FD20e853a85489DFC93EaDFeF7461590
          ```
        </CodeGroup>

        <br />

        <Tip>Enter your own email address on this step and you can login to see your NFT in the Crossmint wallet later, which can be accessed from [crossmint.com](https://crossmint.com) or [staging.crossmint.com](https://staging.crossmint.com) if you are in staging.</Tip>

        <Frame type="simple">
          <img alt="Set recipient screenshot with light theme" />

          <img alt="Set recipient screenshot with dark theme" />
        </Frame>
      </Step>

      <Step title="Set `reuploadLinkedFiles` to false">
        This will prevent unnecessary uploading of files that are already pinned to IPFS.

        <Check><p>Crossmint has a 10MB re-upload size limit. For larger files, upload your media to IPFS, create a metadata.json as shown above, submit the metadata file's URL, and ensure `reuploadLinkedFiles` is set to `false`.</p>
        <p>The default option is `true`.</p></Check>

        <Frame type="simple">
          <img alt="Set reuploadLinkedFiles to false screenshot with light theme" />

          <img alt="Set reuploadLinkedFiles to false screenshot with dark theme" />
        </Frame>
      </Step>

      <Step title="Send the request">
        Scroll back to the top of the page and click the blue `Send` button to trigger
        the API call.

        <Frame type="simple">
          <img alt="Click send screenshot with light theme" />

          <img alt="Click send screenshot with dark theme" />
        </Frame>

        Here is an example response object:

        <Frame type="simple">
          <img alt="mint nft example response screenshot with light theme" />

          <img alt="mint nft example response screenshot with dark theme" />
        </Frame>
      </Step>

      <Step title="View the NFT in your wallet">
        If you followed this guide closely you can view the NFT in the staging wallet at <a href="https://staging.crossmint.com/user/collection">[https://staging.crossmint.com/user/collection](https://staging.crossmint.com/user/collection)</a>.

        If you minted directly to a wallet address you can view the NFT in that application. Ensure you are accessing it from a testnet if you used staging.
      </Step>
    </Steps>
  </Accordion>
</AccordionGroup>


# Create IP Asset
Source: https://docs.crossmint.com/api-reference/ip/create-ip-asset

post /v1/ip/collections/{collectionId}/ipassets
Create a new IP Asset

**API scope required**: `nfts.create`

<Warning>This API is still under development. Contact support for early access.</Warning>


# Create IP Asset (Idempotent)
Source: https://docs.crossmint.com/api-reference/ip/create-ip-asset-idempotent

put /v1/ip/collections/{collectionId}/ipassets/{customerFacingId}
Create a new IP Asset with a pre-computed id, or get an existing one if the id already exists

**API scope required**: `nfts.create`

<Warning>This API is still under development. Contact support for early access.</Warning>


# Create IP Collection
Source: https://docs.crossmint.com/api-reference/ip/create-ip-collection

post /v1/ip/collections
Create a new collection with a pre-computed id, or get an existing one if the id already exists

**API scope required**: `collections.create`

<Warning>This API is still under development. Contact support for early access.</Warning>


# Create IP Collection (Idempotent)
Source: https://docs.crossmint.com/api-reference/ip/create-ip-collection-idempotent

put /v1/ip/collections/{collectionId}
Create a new collection with a pre-computed id, or get an existing one if the id already exists

**API scope required**: `collections.create`

<Warning>This API is still under development. Contact support for early access.</Warning>


# Get All IP Collections
Source: https://docs.crossmint.com/api-reference/ip/get-all-ip-collections

get /v1/ip/collections
Get all collections associated with the Developer Project

**API scope required**: `collections.read`

<Warning>This API is still under development. Contact support for early access.</Warning>


# Get IP Action
Source: https://docs.crossmint.com/api-reference/ip/get-ip-action

get /v1/ip/actions/{actionId}
Get an action by its id

**API scope required**: `nfts.create`

<Warning>This API is still under development. Contact support for early access.</Warning>


# Get IP Asset
Source: https://docs.crossmint.com/api-reference/ip/get-ip-asset

get /v1/ip/collections/{collectionId}/ipassets/{customerFacingId}
Get a single IP Asset

**API scope required**: `nfts.read`

<Warning>This API is still under development. Contact support for early access.</Warning>


# Get IP Assets in Collection
Source: https://docs.crossmint.com/api-reference/ip/get-ip-assets

get /v1/ip/collections/{collectionId}/ipassets
Get all IP Assets in a collection

**API scope required**: `nfts.read`

<Warning>This API is still under development. Contact support for early access.</Warning>


# Get IP Collection
Source: https://docs.crossmint.com/api-reference/ip/get-ip-collection

get /v1/ip/collections/{collectionId}
Get a collection by its id deployed on the Story chain

**API scope required**: `collections.read`

<Warning>This API is still under development. Contact support for early access.</Warning>


# Get IP Asset Graph
Source: https://docs.crossmint.com/api-reference/ip/get-ip-graph

get /v1/ip/graph/{ipAssetId}
Get the graph of an IP Asset, by default it will fetch the first level of parents and children (depth = 1). You can customize the depth using the query parameter 'depth' to a maximum of 3. Maximum 100 parents or children will be returned for each level.

The ipAssetId parameter should be the Story Protocol asset ID (not the Crossmint ID). Must start with '0x' followed by hexadecimal characters.

**API scope required**: `nfts.read`

<Warning>This API is still under development. Contact support for early access.</Warning>


# Get IP Asset License
Source: https://docs.crossmint.com/api-reference/ip/get-ip-license

get /v1/ip/licenses/{ipassetId}
Get the licenses of an IP Asset

The ipassetId parameter should be the Story Protocol asset ID (not the Crossmint ID). Must start with '0x' followed by hexadecimal characters.

**API scope required**: `nfts.read`

<Warning>This API is still under development. Contact support for early access.</Warning>


# Update IP Asset
Source: https://docs.crossmint.com/api-reference/ip/update-ip-asset

patch /v1/ip/collections/{collectionId}/ipassets/{customerFacingId}
Update an existing IP Asset

**API scope required**: `nfts.update`

<Warning>This API is still under development. Contact support for early access.</Warning>


# Create Collection
Source: https://docs.crossmint.com/api-reference/minting/collection/create-collection

post /2022-06-09/collections/
Create a collection that you can mint NFTs/SFTs from

**API scope required**: `collections.create`




# Create Collection (Idempotent)
Source: https://docs.crossmint.com/api-reference/minting/collection/create-collection-idempotent

put /2022-06-09/collections/{collectionId}
Create a collection that you can mint NFTs/SFTs from. This API is idempotent, 
if you call it multiple times with the same ID, only one will be created.

**API scope required**: `collections.create`




# Get All Collections
Source: https://docs.crossmint.com/api-reference/minting/collection/get-all-collections

get /2022-06-09/collections/
List all collections created under the current Crossmint project

**API scope required**: `collections.read`


<Note>For Solana collections the `onChain.contractAddress` property will be named `onChain.mintAddress`</Note>

<ResponseExample>
  ```json 200 theme={null}
  {
    "results": [
      {
        "id": "bb691876-edb3-404c-af3e-c019b8e2ed2c",
        "metadata": {
          "name": "Test Collection",
          "description": "Test",
          "imageUrl": "ipfs://QmVocoiYXZLAtheEHV3VF8w4pa68bkPutT8cQZdMrrpzxh",
          "symbol": "XMINT"
        },
        "fungibility": "non-fungible",
        "onChain": {
          "chain": "polygon",
          "type": "erc-721",
          "contractAddress": "0x9564bD85f3D5677D86244dDb06F06bbD22D9d0DB"
        },
        "supplyLimit": 95,
        "payments": {
          "price": "0.001",
          "recipientAddress": "0x6C3b3225759Cbda68F96378A9F0277B4374f9F06"
        }
      }
    ]
  }
  ```

  <Snippet />
</ResponseExample>


# Get Base URI
Source: https://docs.crossmint.com/api-reference/minting/collection/get-base-uri

get /v1-alpha1/minting/collections/{collectionId}/base-uri
Get the Base URI of a collection as it appears onchain.

**API scope required**: `collections.read`


<Snippet />


# Get Collection Info
Source: https://docs.crossmint.com/api-reference/minting/collection/get-collection

get /2022-06-09/collections/{collectionId}
Get information about a specific collection.

**API scope required**: `collections.read`


<Note>For Solana collections the `onChain.contractAddress` property will be named `onChain.mintAddress`</Note>


# Get Royalties Configuration
Source: https://docs.crossmint.com/api-reference/minting/collection/get-royalties-configuration

get /v1-alpha1/minting/collections/{collectionId}/royalties
Fetch the royalty configuration for a collection, from its current state
in the blockchain. 

This API is only supported on EVM chains.

If you call GET too soon after PUT/DELETE,
you may not yet see your latest changes, as they can take a few seconds to
record on the blockchain.

**API scope required**: `collections.read`


<Snippet />


# Get Transferability
Source: https://docs.crossmint.com/api-reference/minting/collection/get-transferability

get /v1-alpha1/minting/collections/{collectionId}/transferable
Get the transferable status of a collection. 

This API is supported on EVM and Aptos chains. 

You must contact sales to gain access to this API. 

**API scope required**: `collections.read`


<Snippet />


# Remove Royalties
Source: https://docs.crossmint.com/api-reference/minting/collection/remove-royalties

delete /v1-alpha1/minting/collections/{collectionId}/royalties
Remove all royalties from a given collection. No new NFT sales will yield royalties to the creator. 

This API is only supported on EVM Chains.

**API scope required**: `collections.update`


<Snippet />


# Set Base URI
Source: https://docs.crossmint.com/api-reference/minting/collection/set-base-uri

put /v1-alpha1/minting/collections/{collectionId}/base-uri
Update the Base URI of a collection. Setting the baseURI enables
excluding the metadata param when minting. Tokens minted without the metadata
param will have a tokenURI of: 

`{BASE_URI}/{TOKEN_ID}`

This API is currently only supported on EVM Chains.

**API scope required**: `collections.update`


<Snippet />


# Set Royalties
Source: https://docs.crossmint.com/api-reference/minting/collection/set-royalties

put /v1-alpha1/minting/collections/{collectionId}/royalties
Configure royalties for all NFTs in a collection.

This API is only supported for EVM chains and implements the EIP-2981 standard.

**API scope required**: `collections.update`


<Snippet />


# Set Transferability
Source: https://docs.crossmint.com/api-reference/minting/collection/set-transferability

put /v1-alpha1/minting/collections/{collectionId}/transferable
Update the transferable status of a collection. 

This API is supported on EVM and Aptos chains. 
You must contact sales to gain access to this API. 

**API scope required**: `collections.update`


<Snippet />


# Update Collection
Source: https://docs.crossmint.com/api-reference/minting/collection/update-collection

patch /2022-06-09/collections/{collectionId}
Update the sales details of a collection

**API scope required**: `collections.update`




# Burn NFT
Source: https://docs.crossmint.com/api-reference/minting/nfts/burn-nft

delete /2022-06-09/collections/{collectionId}/nfts/{id}
Burn a minted NFT.

**API scope required**: `nfts.delete`


<Snippet />


# Edit NFT
Source: https://docs.crossmint.com/api-reference/minting/nfts/edit-nft

patch /2022-06-09/collections/{collectionId}/nfts/{id}
Edit a minted NFT's metadata on IPFS. 

If you are using a custom baseURI, invoking this will overwrite the specific tokenURI for the edited token.

**API scope required**: `nfts.update`




# Get All NFTs
Source: https://docs.crossmint.com/api-reference/minting/nfts/get-nfts

get /2022-06-09/collections/{collectionId}/nfts
Get a list of all the NFTs in a given collection.

**API scope required**: `nfts.read`




# Mint NFT
Source: https://docs.crossmint.com/api-reference/minting/nfts/mint-nft

post /2022-06-09/collections/{collectionId}/nfts
Mint your NFTs and deliver them to a web3 wallet or an email address

**API scope required**: `nfts.create`


<Note>For uncompressed Solana NFTs, [contact sales](https://www.crossmint.com/contact/sales) for access.</Note>

<ResponseExample>
  <Snippet />

  <Snippet />
</ResponseExample>


# Mint NFT with ID
Source: https://docs.crossmint.com/api-reference/minting/nfts/mint-nft-idempotent

put /2022-06-09/collections/{collectionId}/nfts/{id}
This pathway allows you to mint NFTs and guarantee idempotency
to ensure you never double mint for the same NFT. 

**API scope required**: `nfts.create`


Subsequent requests to this endpoint with the same `id` in the path will ***not*** mint additional NFTs.

Furthermore, the success responses (with status code 200) will be different once the initial request has completed and includes the metadata for the minted NFT.

<Accordion title="200 response examples for subsequent requests">
  <CodeGroup>
    ```json EVM theme={null}
    {
      "id": "<string>",
      "metadata": {
        "name": "<string>",
        "image": "<string>",
        "description": "<string>"
      },
      "onChain": {
        "status": "<string>",
        "tokenId": "<string>",
        "owner": "<string>",
        "txId": "<string>",
        "contractAddress": "<string>",
        "chain": "<string>"
      },
      "actionId": "<string>"
    }
    ```

    ```json Solana theme={null}
    {
        "id": "<string>",
        "metadata": {
            "name": "<string>",
            "symbol": "<string>",
            "description": "<string>",
            "seller_fee_basis_points": 0,
            "image": "<string>",
            "attributes": [],
            "properties": {}
        },
        "onChain": {
            "status": "success",
            "mintHash": "<string>",
            "txId": "<string>",
            "owner": "<string>",
            "chain": "solana"
        },
        "actionId": "<string>"
    }
    ```
  </CodeGroup>
</Accordion>

<ResponseExample>
  <Snippet />

  <Snippet />
</ResponseExample>


# Mint SFT
Source: https://docs.crossmint.com/api-reference/minting/nfts/mint-sft

post /2022-06-09/collections/{collectionId}/sfts
Mint your SFTs and deliver them to a web3 wallet or an email address

**API scope required**: `nfts.create`




# Mint Status
Source: https://docs.crossmint.com/api-reference/minting/nfts/mint-status

get /2022-06-09/collections/{collectionId}/nfts/{id}
Get the status and associated information for a mint operation.

**API scope required**: `nfts.read`


<ResponseExample>
  ```json 200 EVM  theme={null}
    {
      "id": "<string>",
      "metadata": {
        "name": "<string>",
        "image": "<string>",
        "description": "<string>"
      },
      "onChain": {
        "status": "success",
        "tokenId": "<string>",
        "owner": "<string>",
        "txId": "<string>",
        "contractAddress": "<string>",
        "chain": "polygon"
      },
      "action": "https://staging.crossmint.com/api/2022-06-09/actions/<actionId>"
    }
  ```

  ```json 200 Solana theme={null}
  {
      "id": "<string>",
      "metadata": {
          "name": "<string>",
          "symbol": "<string>",
          "seller_fee_basis_points": 0,
          "properties": {},
          "description": "<string>",
          "image": "<string>",
          "attributes": []
      },
      "onChain": {
          "status": "success",
          "mintHash": "<string>",
          "txId": "<string>",
          "owner": "<string>",
          "chain": "solana"
      },
      "action": "https://staging.crossmint.com/api/2022-06-09/actions/<actionId>"
  }
  ```

  <Snippet />
</ResponseExample>


# Create Template
Source: https://docs.crossmint.com/api-reference/minting/template/create-template

post /2022-06-09/collections/{collectionId}/templates
Create a token template, that NFTs or SFTs may be minted from

**API scope required**: `nfts.create`




# Create Template with ID
Source: https://docs.crossmint.com/api-reference/minting/template/create-template-idempotent

put /2022-06-09/collections/{collectionId}/templates/{templateId}
Create a token template with preconfigured metadata

**API scope required**: `nfts.create`




# Delete Template
Source: https://docs.crossmint.com/api-reference/minting/template/delete-template

delete /2022-06-09/collections/{collectionId}/templates/{templateId}
Delete a Token template.

**API scope required**: `nfts.delete`




# Edit Template
Source: https://docs.crossmint.com/api-reference/minting/template/edit-template

patch /2022-06-09/collections/{collectionId}/templates/{templateId}
Edit a Token template.

**API scope required**: `nfts.update`




# Get All Templates
Source: https://docs.crossmint.com/api-reference/minting/template/get-all-templates

get /2022-06-09/collections/{collectionId}/templates
Get all of the templates for a collection

**API scope required**: `nfts.read`




# Get Template
Source: https://docs.crossmint.com/api-reference/minting/template/get-template

get /2022-06-09/collections/{collectionId}/templates/{templateId}
Fetch the contents of a token template.

**API scope required**: `nfts.read`




# Accept Legal Document
Source: https://docs.crossmint.com/api-reference/users/accept-legal-document

put /2025-06-09/users/{userLocator}/legal-documents
Record user acceptance of a legal document.

**API scope required**: `users.create`



# Get a User Document by ID
Source: https://docs.crossmint.com/api-reference/users/get-document

get /2025-06-09/documents/{documentId}
Get a specific document by its ID.

**API scope required**: `users.read`



# Get Identity Verification Status
Source: https://docs.crossmint.com/api-reference/users/get-identity-verification

get /2025-06-09/users/{userLocator}/identity-verification
Get identity verification status for a user.

**API scope required**: `users.read`



# Get Linked External Wallet
Source: https://docs.crossmint.com/api-reference/users/get-linked-wallet

get /2025-06-09/users/{userLocator}/linked-wallets/{address}
Get a linked external wallet for a user by address.

**API scope required**: `users.read`



# Get a User
Source: https://docs.crossmint.com/api-reference/users/get-user

get /2025-06-09/users/{userLocator}
Get a user by its id

**API scope required**: `users.read`



# Link External Wallet to User
Source: https://docs.crossmint.com/api-reference/users/link-wallet

put /2025-06-09/users/{userLocator}/linked-wallets/{address}
Link an external wallet address to a user. Optionally provide a proof to verify ownership.

**API scope required**: `users.create`



# Trigger Identity Verification
Source: https://docs.crossmint.com/api-reference/users/trigger-identity-verification

put /2025-06-09/users/{userLocator}/identity-verification
Trigger identity verification for a user.

**API scope required**: `users.create`



# Upload a User Document
Source: https://docs.crossmint.com/api-reference/users/upload-document

post /2025-06-09/documents
Upload a document for a user. 

**API scope required**: `users.create`



# Create or Update User
Source: https://docs.crossmint.com/api-reference/users/upsert-user

put /2025-06-09/users/{userLocator}
Create or update a user and their personal data by user locator. If the user doesn't exist, they will be created.

**API scope required**: `users.create`



# Issue Credential
Source: https://docs.crossmint.com/api-reference/verifiable-credentials/credentials/issue-credential

post /v1-alpha1/credentials/templates/{templateId}/vcs
Issue a credential and deliver it to a wallet or email address.

**API scope required** `credentials.create`


<Snippet />


# Get Credential by Credential ID
Source: https://docs.crossmint.com/api-reference/verifiable-credentials/credentials/retrieve-credential-by-id

get /v1-alpha1/credentials/{id}
Get a verifiable credential by the ID associated with it. 

This ID will have the format: `urn:uuid:<UUID>`. For example: `urn:uuid:64f9877d-a19a-4205-8d61-f8c2abed5766`

**API scope required** `credentials.read`. This enpoint will work also with a client side API key.


<Snippet />


# Get Credential by NFT ID
Source: https://docs.crossmint.com/api-reference/verifiable-credentials/credentials/retrieve-credential-by-nft

get /v1-alpha1/credentials/templates/{collectionId}/nfts/{id}/credentials
Get a verifiable credential by the ID associated with the minted NFT.

This ID will have the format: `<UUID>`. For example: `d7eb777b-e9b4-4f34-ab5f-ce199111166a`

**API scope required** `credentials.read`. This endpoint will not work with a client side API key.


<Snippet />


# Get Credential by NFT Locator
Source: https://docs.crossmint.com/api-reference/verifiable-credentials/credentials/retrieve-credential-by-nft-locator

get /v1-alpha1/nfts/{nftLocator}/credentials
Get a verifiable credential by the NFT locator. 

This locator will have the format: `<chain>:<contract_address>:<tokenId>`. 
For example: `polygon:0x1234abcde...:1`

**API scope required** `credentials.read`. This enpoint will work also with a client side API key.


<Snippet />


# null
Source: https://docs.crossmint.com/api-reference/verifiable-credentials/credentials/retrieve-credential-nfts

get /api/v1-alpha1/wallets/{walletLocator}/credential_nfts

<Snippet />


# Revoke Credential
Source: https://docs.crossmint.com/api-reference/verifiable-credentials/credentials/revoke-credential

DELETE /v1-alpha1/credentials/{id}
Revoke a verifiable credential by the credential ID. 
This involves burning the associated nft.

This ID will have the format: `urn:uuid:<UUID>`. For example: `urn:uuid:64f9877d-a19a-4205-8d61-f8c2abed5766`

**API scope required** `credentials.create`.


<Snippet />


# Verify Credential
Source: https://docs.crossmint.com/api-reference/verifiable-credentials/credentials/verify-credential

post /v1-alpha1/credentials/verification/verify
Verify that a verifiable credential is valid.

**API scope required** `credentials.read`


<Snippet />

<Warning>
  It is impractical to use the API Playground to verify a credential. Instead you can copy the sample code for your
  preferred language in the righthand sidebar and fill in the JSON of the credential you intend to verify.
</Warning>

Here is an example of how to verify a credential using javascript:

```javascript verifyVC.js theme={null}
const options = {
    method: "POST",
    headers: {
        "X-API-KEY": "YOUR_API_KEY",
        "Content-Type": "application/json",
    },
    body: '{"credential": {"id":"urn:uuid:e31316b6-3be1-49af-a95f-c7f4c3f52aa1","credentialSubject":{"course":"Blockchain 101","passed":true,"id":"did:polygon:0x6C3b3225759Cbda68F96378A9F0277B4374f9F06"},"expirationDate":"2034-02-03","nft":{"tokenId":"1","chain":"polygon","contractAddress":"0xdC444A3F4768185497Dae6250E2F348b99bE89F3"},"issuer":{"id":"did:polygon:0xa22CaDEdE67c11dc1444E507fDdd9b831a67aBd1"},"type":["VerifiableCredential","65c15243e9bee8deac219d57"],"issuanceDate":"2024-02-05T23:21:32.641Z","@context":["https://www.w3.org/2018/credentials/v1","https://github.com/haardikk21/ethereum-eip712-signature-2021-spec/blob/main/index.html","DUMMY_CROSSMINT/65c15243e9bee8deac219d57"],"proof":{"verificationMethod":"did:polygon:0xa22CaDEdE67c11dc1444E507fDdd9b831a67aBd1#ethereumAddress","ethereumAddress":null,"created":"2024-02-05T23:22:24.058Z","proofPurpose":"assertionMethod","type":"EthereumEip712Signature2021","proofValue":"0x748a55d9770cbc6ef16689f0d9547355e288bcce03a8949a32d2aac59244cb9e08cbf54c960bc00d133fc51e6651a4ac1366aeda320dd121777118a4e74980631b","eip712":{"domain":{"name":"Krebit","version":"0.1","chainId":4,"verifyingContract":"0xD8393a735e8b7B6E199db9A537cf27C61Aa74954"},"types":{"VerifiableCredential":[{"name":"@context","type":"string[]"},{"name":"type","type":"string[]"},{"name":"id","type":"string"},{"name":"issuer","type":"Issuer"},{"name":"credentialSubject","type":"CredentialSubject"},{"name":"issuanceDate","type":"string"},{"name":"expirationDate","type":"string"},{"name":"nft","type":"Nft"}],"CredentialSubject":[{"name":"id","type":"string"},{"name":"course","type":"string"},{"name":"passed","type":"bool"}],"Issuer":[{"name":"id","type":"string"}],"Nft":[{"name":"tokenId","type":"string"},{"name":"contractAddress","type":"string"},{"name":"chain","type":"string"}]},"primaryType":"VerifiableCredential"}}}}',
};

// note the gigantic VC JSON string in the body property

fetch("https://staging.crossmint.com/api/v1-alpha1/credentials/verification/verify", options)
    .then((response) => response.json())
    .then((response) => console.log(response))
    .catch((err) => console.error(err));
```

<ResponseExample>
  ```json 200 valid theme={null}
  {
      "isValid": true,
      "error": null
  }
  ```

  ```json 200 revoked theme={null}
  {
      "isValid": false,
      "error": "Credential Revoked"
  }
  ```

  ```json 200 expired theme={null}
  {
      "isValid": false,
      "error": "Credential expired at <date>"
  }
  ```

  ```json 200 invalid_proof theme={null}
  {
      "isValid": false,
      "error": "Invalid proof"
  }
  ```
</ResponseExample>


# Create Credential template
Source: https://docs.crossmint.com/api-reference/verifiable-credentials/templates/create-template

post /v1-alpha1/credentials/templates/
Create a template, similar to an NFT collection, for issuing verifiable credentials.

**API scope required** `credentials:template.create`


<Snippet />


# Create Credential Type with Name
Source: https://docs.crossmint.com/api-reference/verifiable-credentials/types/create-named-type

put /v1-alpha1/credentials/types/{typeName}
Create or import a type with a given name. This is how you define a custom credential schema.

**API scope required** `credentials.create`


<Snippet />


# Create Credential Type
Source: https://docs.crossmint.com/api-reference/verifiable-credentials/types/create-type

post /v1-alpha1/credentials/types
Create or import a credential type with a random UUID. This is how you define a custom credential schema.

**API scope required** `credentials.create`


<Snippet />


# Get a Credential Type
Source: https://docs.crossmint.com/api-reference/verifiable-credentials/types/get-type

get /v1-alpha1/credentials/types/{typeName}
Get the schema of a given type by name (or id)
        
**API scope required** `credentials.read`


<Snippet />


# Approve Signature
Source: https://docs.crossmint.com/api-reference/wallets/approve-signature

post /2025-06-09/wallets/{walletLocator}/signatures/{signatureId}/approvals
Submit approval for a signature to sign a message or typed data.

**API scope required**: `wallets:signatures.create`



# Approve Transaction
Source: https://docs.crossmint.com/api-reference/wallets/approve-transaction

post /2025-06-09/wallets/{walletLocator}/transactions/{transactionId}/approvals
Submit approval signature for a pending transaction. Required for transactions using external signers.

**API scope required**: `wallets:transactions.sign`



# Create Signature
Source: https://docs.crossmint.com/api-reference/wallets/create-signature

post /2025-06-09/wallets/{walletLocator}/signatures
Creates a new signature for signing messages or typed data.

**API scope required**: `wallets:signatures.create`



# Create Transaction
Source: https://docs.crossmint.com/api-reference/wallets/create-transaction

post /2025-06-09/wallets/{walletLocator}/transactions
Creates a new transaction for the specified wallet. Transaction will be automatically broadcast once it has all necessary approvals.

**API scope required**: `wallets:transactions.create`



# Create Wallet
Source: https://docs.crossmint.com/api-reference/wallets/create-wallet

post /2025-06-09/wallets
Creates a new wallet of specified type. If called with an idempotency key or for a user who already has a wallet, returns existing wallet. When owner is provided, subsequent calls with the same owner will return the existing wallet. Supports both custodial and non-custodial wallet types.

**API scope required**: `wallets.create`



# Fund Wallet
Source: https://docs.crossmint.com/api-reference/wallets/fund-wallet

post /v1-alpha2/wallets/{walletLocator}/balances
Send funds to a wallet.

**API scope required**: `wallets.fund`

<Snippet />

<Note>This endpoint is only available in **staging** and only supports **USDXM**.</Note>


# Get NFTs from Wallet
Source: https://docs.crossmint.com/api-reference/wallets/get-nfts-from-wallet

get /2022-06-09/wallets/{identifier}/nfts
Fetch the NFTs in a provided wallet

**API scope required**: `wallets:nfts.read`


This API enables fetching the NFTs for a provided wallet address and chain.

The response will be slightly different between EVM, Solana, and other wallets. See the example responses to the right.

<ResponseExample>
  ```json 200 EVM theme={null}
  [
    {
      "chain": "<string>",
      "contractAddress": "<string>",
      "tokenId": "<string>",
      "metadata": {
        "attributes": [],
        "collection": {},
        "description": "<string>",
        "image": "<string>",
        "animation_url": "<string>",
        "name": "<string>"
      },
      "locator": "<string>",
      "tokenStandard": "<string>"
    }
  ]
  ```

  ```json 200 EVM (with subscription) theme={null}
  [
      {
          "chain": "<string>",
          "contractAddress": "<string>",
          "tokenId": "<string>",
          "metadata": {
              "attributes": [],
              "collection": {},
              "description": "<string>",
              "image": "<string>",
              "animation_url": "<string>",
              "name": "<string>"
          },
          "locator": "<string>",
          "tokenStandard": "<string>",
          "subscription": {
              "expiresAt": "<ISO_string>"
          }
      }
  ]
  ```

  ```json 200 Solana theme={null}
  [
      {
          "chain": "<string>",
          "mintHash": "<string>",
          "metadata": {
              "name": "<string>",
              "description": "<string>",
              "image": "<string>",
              "attributes": []
          },
          "locator": "<string>"
      }
  ]
  ```

  ```json 400 theme={null}
  {
      "error": "<string>"
  }
  ```
</ResponseExample>


# Get Signature
Source: https://docs.crossmint.com/api-reference/wallets/get-signature

get /2025-06-09/wallets/{walletLocator}/signatures/{signatureId}
Retrieves details about a specific signature by its ID.

**API scope required**: `wallets:signatures.read`



# Get All Signatures
Source: https://docs.crossmint.com/api-reference/wallets/get-signatures

get /2025-06-09/wallets/{walletLocator}/signatures
Retrieves all signatures associated with the specified wallet.

**API scope required**: `wallets:signatures.read`



# Get Delegated Signer
Source: https://docs.crossmint.com/api-reference/wallets/get-signer

get /2025-06-09/wallets/{walletLocator}/signers/{signer}
Retrieve details about a specific delegated signer by its locator.

**API scope required**: `wallets.read`



# Get Transaction
Source: https://docs.crossmint.com/api-reference/wallets/get-transaction

get /2025-06-09/wallets/{walletLocator}/transactions/{transactionId}
Retrieves the current status and details of a specific transaction.

**API scope required**: `wallets:transactions.read`



# Get Wallet Transactions
Source: https://docs.crossmint.com/api-reference/wallets/get-transactions

get /2025-06-09/wallets/{walletLocator}/transactions
Retrieves all transactions associated with the specified wallet. Optionally filter by date range using ISO 8601 format (e.g., 2025-10-27T00:00:00Z).

**API scope required**: `wallets:transactions.read`



# Get Transfer Transaction
Source: https://docs.crossmint.com/api-reference/wallets/get-transfer-token

get /2025-06-09/wallets/{walletLocator}/tokens/{tokenLocator}/transfers/{transactionId}
Retrieves the current status and details of a specific transfer transaction.

**API scope required**: `wallets:transactions.read`



# Get Wallet Balance
Source: https://docs.crossmint.com/api-reference/wallets/get-wallet-balance

get /2025-06-09/wallets/{walletLocator}/balances
Get the balance of a wallet for a given chain and currency

**API scope required**: `wallets:balance.read`

<Snippet />

## Example Request

This example uses placeholder values. Modify the call with the wallet locator, tokens, and chains you would like to use.

<CodeGroup>
  ```bash cURL theme={null}
  curl --request GET \
    --url 'https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:evm/balances?tokens=usdc,eth,pol&chains=base-sepolia,polygon-amoy' \
    --header 'X-API-KEY: <x-api-key>'
  ```

  ```js Node.js theme={null}
  const url =
      "https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:evm/balances?tokens=usdc,eth,pol&chains=base-sepolia,polygon-amoy";
  const options = { method: "GET", headers: { "X-API-KEY": "<x-api-key>" }, body: undefined };

  try {
      const response = await fetch(url, options);
      const data = await response.json();

      // Process each token's balance across chains
      data.forEach((token) => {
          console.log(`${token.symbol}${token.name ? ` (${token.name})` : ""}:`);
          console.log(`  Total amount: ${token.amount} (${token.rawAmount} raw)`);
          console.log(`  Decimals: ${token.decimals}`);

          // Access balance data for each chain
          Object.entries(token.chains).forEach(([chainName, chainBalance]) => {
              console.log(`  ${chainName}: ${chainBalance.amount}`);
              console.log(`    Locator: ${chainBalance.locator}`);
              if (chainBalance.contractAddress) {
                  console.log(`    Contract: ${chainBalance.contractAddress}`);
              } else if (chainBalance.mintHash) {
                  console.log(`    Mint Hash: ${chainBalance.mintHash}`);
              } else if (chainBalance.contractId) {
                  console.log(`    Contract ID: ${chainBalance.contractId}`);
              }
          });
          console.log();
      });
  } catch (error) {
      console.error(error);
  }
  ```

  ```python Python theme={null}
  import requests

  url = "https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:evm/balances"

  querystring = { "tokens": "usdc,eth,pol", "chains": "base-sepolia,polygon-amoy" }

  headers = { "X-API-KEY": "<x-api-key>" }

  response = requests.get(url, params=querystring, headers=headers)
  data = response.json()

  # Process each token's balance across chains
  for token in data:
      name_part = f" ({token['name']})" if token.get('name') else ""
      print(f"{token['symbol']}{name_part}:")
      print(f"  Total amount: {token['amount']} ({token['rawAmount']} raw)")
      print(f"  Decimals: {token['decimals']}")

      # Access balance data for each chain
      for chain_name, chain_balance in token['chains'].items():
          print(f"  {chain_name}: {chain_balance['amount']}")
          print(f"    Locator: {chain_balance['locator']}")
          if 'contractAddress' in chain_balance:
              print(f"    Contract: {chain_balance['contractAddress']}")
          elif 'mintHash' in chain_balance:
              print(f"    Mint Hash: {chain_balance['mintHash']}")
          elif 'contractId' in chain_balance:
              print(f"    Contract ID: {chain_balance['contractId']}")
      print()
  ```
</CodeGroup>

## Example Response

The response returns an array of token objects, each containing balance information across the specified chains:

```json theme={null}
[
    {
        "symbol": "ETH",
        "name": "Ethereum",
        "decimals": 18,
        "amount": "1.5",
        "rawAmount": "1500000000000000000",
        "chains": {
            "base-sepolia": {
                "locator": "base-sepolia:eth",
                "amount": "1.0",
                "rawAmount": "1000000000000000000"
            },
            "polygon-amoy": {
                "locator": "polygon-amoy:eth",
                "amount": "0.5",
                "rawAmount": "500000000000000000"
            }
        }
    },
    {
        "symbol": "USDC",
        "name": "USD Coin",
        "decimals": 6,
        "amount": "100.0",
        "rawAmount": "100000000",
        "chains": {
            "base-sepolia": {
                "locator": "base-sepolia:0x036CbD53842c5426634e7929541eC2318f3dCF7e",
                "amount": "50.0",
                "rawAmount": "50000000",
                "contractAddress": "0x036CbD53842c5426634e7929541eC2318f3dCF7e"
            },
            "polygon-amoy": {
                "locator": "polygon-amoy:0x41E94Eb019C0762f9Bfcf9Fb1E58725BfB0e7582",
                "amount": "50.0",
                "rawAmount": "50000000",
                "contractAddress": "0x41E94Eb019C0762f9Bfcf9Fb1E58725BfB0e7582"
            }
        }
    },
    {
        "symbol": "SOL",
        "decimals": 9,
        "amount": "2.5",
        "rawAmount": "2500000000",
        "chains": {
            "solana": {
                "locator": "solana:sol",
                "amount": "2.5",
                "rawAmount": "2500000000"
            }
        }
    },
    {
        "symbol": "USDC",
        "name": "USD Coin",
        "decimals": 6,
        "amount": "75.0",
        "rawAmount": "75000000",
        "chains": {
            "solana": {
                "locator": "solana:EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
                "amount": "75.0",
                "rawAmount": "75000000",
                "mintHash": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
            }
        }
    }
]
```


# Get Wallet By Locator
Source: https://docs.crossmint.com/api-reference/wallets/get-wallet-by-locator

get /2025-06-09/wallets/{walletLocator}
Retrieves a wallet by its locator (address or user identifier and wallet type)

**API scope required**: `wallets.read`



# List Wallet Transfers
Source: https://docs.crossmint.com/api-reference/wallets/list-transfers

get /unstable/wallets/{walletLocator}/transfers
Retrieves activity history for the specified wallet including transactions and other relevant events. This is an unstable API that may change without notice.

**API scope required**: `wallets.read`

<Warning>
  This is an **unstable API** that may change without notice. The `unstable` prefix indicates that breaking changes may occur in future releases.
</Warning>


# Create Delegated Signer
Source: https://docs.crossmint.com/api-reference/wallets/register-delegated-key

post /2025-06-09/wallets/{walletLocator}/signers
Create a delegated signer for a smart wallet with optional restrictions around permissions and expiry date.

**API scope required**: `wallets.create`



# Transfer Token
Source: https://docs.crossmint.com/api-reference/wallets/transfer-token

post /2025-06-09/wallets/{walletLocator}/tokens/{tokenLocator}/transfers
Sends a token of any type from this wallet to a recipient



# Customization
Source: https://docs.crossmint.com/authentication/customization

Customize the authentication flow and email templates

With Crossmint Auth, you can customize the authentication flow and email templates with your brand's identity.

## Modal Customization

The `CrossmintAuthProvider` component allows you to customize the authentication modal appearance and content.

```tsx theme={null}
import { CrossmintAuthProvider } from "@crossmint/client-sdk-react-ui";

<CrossmintAuthProvider
    authModalTitle="Sign in to My App"
    termsOfServiceText={
        <p>
            By continuing, you agree to our <a href="/terms">Terms of Service</a> and{" "}
            <a href="/privacy">Privacy Policy</a>
        </p>
    }
    appearance={{
        spacingUnit: "8px",
        borderRadius: "12px",
        colors: {
            inputBackground: "#fffdf9",
            buttonBackground: "#fffaf2",
            border: "#835911",
            background: "#FAF5EC",
            textPrimary: "#5f2c1b",
            textSecondary: "#835911",
            textLink: "#1400cb",
            danger: "#ff3333",
            accent: "#602C1B",
        },
    }}
>
    {children}
</CrossmintAuthProvider>
```

### Modal props

| Prop                 | Type                  | Description                                                          |
| -------------------- | --------------------- | -------------------------------------------------------------------- |
| `authModalTitle`     | `string`              | Custom title displayed at the top of the authentication modal        |
| `termsOfServiceText` | `string \| ReactNode` | Custom terms of service text displayed below the authentication form |
| `appearance`         | `UIConfig`            | Styling configuration for the modal (see example above)              |

The modal will also use your display name configured in the Crossmint Console. To learn more, see the "Email Customization" section below.

## Embedded Login

For a more integrated experience, you can use our embedded login component, which offers flexibility to display the login form in your own modal or as part of a split login screen.

```tsx theme={null}
import { EmbeddedAuthForm, useAuth } from "@crossmint/client-sdk-react-ui";

export default function Home() {
    const { user, status } = useAuth(); // "in-progress" | "logged-in" | "logged-out"

    return <div className="max-w-[150px]">{status === "logged-in" ? user?.email : <EmbeddedAuthForm />}</div>;
}
```

## Email Customization

Email OTP is a login method that allows users to sign in to your app using their email address. They receive a one-time code via email that they can use to log in.

You can customize the email template to align with your brand's identity. We **strongly recommend** doing so, as it increases user trust and security.

To modify the email template:

1. In the Crossmint Console, click on Settings, and navigate to the **Branding** tab.
2. Here, you can customize:
   * The **logo** displayed in the email with your logo.
   * The **display name** textbox to include your brand's name.

<Warning>
  When customizing email text, avoid using terms like "airdrop", "token", or "crypto" as these can trigger spam
  filters and hurt email deliverability.
</Warning>

<img alt="Customize email template" />


# Overview
Source: https://docs.crossmint.com/authentication/introduction

Allow users to authenticate into your app

Crossmint Auth is a quick-to-integrate authentication solution, ideal for staging environments, demos, and prototyping. It lets you authenticate users using web3 or traditional sign-in methods:

* **Email OTP**: passwordless sign-in using a one time code delivered to the user's email.
* **Social Accounts**: Sign in with Google, Apple, X, and more.
* **Farcaster**: using the [Sign In With Farcaster (SIWF) standard](https://github.com/farcasterxyz/protocol/discussions/110).
* **External wallets**: connect with crypto wallets for Web3 authentication.

## When to use Crossmint Auth

| Scenario                    | Recommendation                                                                                            |
| --------------------------- | --------------------------------------------------------------------------------------------------------- |
| **Staging / prototyping**   | Use Crossmint Auth. Get up and running in minutes                                                         |
| **Demos and quickstarts**   | Use Crossmint Auth. Minimal setup, great for testing                                                      |
| **Production applications** | [Bring your own auth provider](/wallets/guides/bring-your-own-auth) for full control over user management |

## Key Characteristics

<CardGroup>
  <Card title="Securely authorize your users" icon="table-list">
    Authorize calls to your backend services and any Crossmint product.
  </Card>

  <Card title="Link wallets and user accounts" icon="wallet">
    Unified identities across your backend and the blockchain.
  </Card>

  <Card title="Drag and drop integration" icon="bolt">
    Launch your app in under 5 minutes.
  </Card>
</CardGroup>

## Get started

<CardGroup>
  <Card title="Quickstart" icon="bolt" href="/authentication/quickstart">
    Get started with Crossmint Auth in under 5 minutes. Great for staging and prototyping.
  </Card>

  <Card title="Bring Your Own Auth" icon="key" href="/wallets/guides/bring-your-own-auth">
    Recommended for production. Use Auth0, Firebase, Supabase, or any JWT-based provider with Crossmint.
  </Card>
</CardGroup>

<CardGroup>
  <Card title="Create wallets" icon="wallet" href="/wallets/quickstarts/react">
    Detailed wallet creation guide.
  </Card>

  <Card title="User Profile" icon="user" href="/authentication/user-profile">
    Get and update user information.
  </Card>

  <Card title="Talk to an expert" icon="message" href="https://www.crossmint.com/contact/sales">
    Contact our sales team for advanced support.
  </Card>
</CardGroup>


# Login Methods
Source: https://docs.crossmint.com/authentication/login-methods

Customize how users can log in to your app

Crossmint Auth supports the following login methods:

* **Email OTP**: passwordless sign-in using a one time code delivered to the user's email.
* **Social Accounts**: Sign in with Google, X, Farcaster, and more.
* **External wallets**: connect with crypto wallets for Web3 authentication. Use `"web3"` for all wallets, `"web3:evm-only"` for Ethereum-compatible wallets only, or `"web3:solana-only"` for Solana wallets only.

To customize which login methods are shown to your users, use the `loginMethods` prop when initializing Crossmint Auth.

By default, only email and Google are enabled.

```tsx app/providers/Providers.tsx theme={null}
"use client";

import { CrossmintProvider, CrossmintAuthProvider } from "@crossmint/client-sdk-react-ui";

export default function Providers({ children }: { children: React.ReactNode }) {
    return (
        <CrossmintProvider apiKey={process.env.NEXT_PUBLIC_CROSSMINT_API_KEY ?? ""}>
            <CrossmintAuthProvider
                loginMethods={["email", "google", "farcaster", "twitter", "web3"]} // Show email, Google, Farcaster, X (Twitter), and external wallets as login methods
            >
                {children}
            </CrossmintAuthProvider>
        </CrossmintProvider>
    );
}
```


# Quickstart ⚡
Source: https://docs.crossmint.com/authentication/quickstart

Sign up your first user in 5 minutes

<CardGroup>
  <Snippet />

  <Card title="Auth with Wallets Quickstart" icon="github" href="https://github.com/Crossmint/wallets-quickstart">
    See a full working example with auth and wallets.
  </Card>
</CardGroup>

<Steps>
  <Step title="Install the SDK">
    Run the following command to install the SDK:

    <Snippet />
  </Step>

  <Step title="Add the Crossmint providers to your app">
    Add the necessary Crossmint providers to your app.

    <CodeGroup>
      ```tsx next.js theme={null}
      "use client";

      import {
          CrossmintProvider,
          CrossmintAuthProvider,
      } from "@crossmint/client-sdk-react-ui";

      export function Providers({ children }: { children: React.ReactNode }) {
          return (
              <CrossmintProvider apiKey="<YOUR_CLIENT_API_KEY>">
                  <CrossmintAuthProvider>
                      {children}
                  </CrossmintAuthProvider>
              </CrossmintProvider>
          );
      }
      ```

      ```jsx create-react-app theme={null}
      import React from "react";
      import ReactDOM from "react-dom/client";
      import {
          CrossmintProvider,
          CrossmintAuthProvider,
      } from "@crossmint/client-sdk-react-ui";
      import App from "./App";
      import "./index.css";

      const root = ReactDOM.createRoot(document.getElementById("root"));

      root.render(
          <React.StrictMode>
              <CrossmintProvider apiKey="<YOUR_CLIENT_API_KEY>">
                  <CrossmintAuthProvider>
                      <App />
                  </CrossmintAuthProvider>
              </CrossmintProvider>
          </React.StrictMode>
      );
      ```
    </CodeGroup>
  </Step>

  <Step title="Add login and logout functionality">
    <CodeGroup>
      ```tsx next.js theme={null}
      "use client";

      import { useAuth } from "@crossmint/client-sdk-react-ui";

      export function AuthButton() {
        const { login, logout, user, jwt } = useAuth();

        return (
          <div className="flex gap-4">
            {user == null ? (
              <button
                type="button"
                onClick={login}
                className="bg-blue-500 text-white font-bold py-2 px-4 rounded"
              >
                Login
              </button>
            ) : (
              <button
                type="button"
                onClick={logout}
                className="bg-black text-white font-bold py-2 px-4 rounded border-2 border-blue-500"
              >
                Logout
              </button>
            )}
            <p>User: {user?.id}</p>
            <p>Email: {user?.email ?? "None"}</p>
            <p>Phone Number: {user?.phoneNumber ?? "None"}</p>
            <p>Farcaster username: {user?.farcaster?.username ?? "None"}</p>
            <p>Twitter username: {user?.twitter?.username ?? "None"}</p>
            <p>JWT: {jwt}</p>
          </div>
        );
      }
      ```

      ```tsx create-react-app theme={null}
      import { useAuth } from "@crossmint/client-sdk-react-ui";

      export function AuthButton() {
        const { login, logout, user, jwt } = useAuth();

        return (
          <div className="flex gap-4">
            {user == null ? (
              <button
                type="button"
                onClick={login}
                className="bg-blue-500 text-white font-bold py-2 px-4 rounded"
              >
                Login
              </button>
            ) : (
              <button
                type="button"
                onClick={logout}
                className="bg-black text-white font-bold py-2 px-4 rounded border-2 border-blue-500"
              >
                Logout
              </button>
            )}
            <p>User: {user?.id}</p>
            <p>Email: {user?.email ?? "None"}</p>
            <p>Phone Number: {user?.phoneNumber ?? "None"}</p>
            <p>Farcaster username: {user?.farcaster?.username ?? "None"}</p>
            <p>Twitter username: {user?.twitter?.username ?? "None"}</p>
            <p>JWT: {jwt}</p>
          </div>
        );
      }
      ```
    </CodeGroup>
  </Step>
</Steps>

## Moving to Production

<Warning>
  **Crossmint Auth is designed for staging and getting started quickly.** For production applications, we strongly recommend migrating to your own authentication provider for full control over user management.
</Warning>

When you're ready to go to production, Crossmint recommends:

1. **Set up your own auth provider** (Auth0, Firebase, Supabase, Stytch, etc.) and follow the [Bring Your Own Auth guide](/wallets/guides/bring-your-own-auth) to integrate it with Crossmint via JWT.
2. Create a developer account on the [production console](https://www.crossmint.com/console).
3. Create a production client API key on the [API Keys](https://www.crossmint.com/console/projects/apiKeys) page with the API scopes `users.create`, `users.read`, `wallets.read`.
4. [Configure JWT authentication](/introduction/platform/api-keys/jwt-authentication) for your auth provider in the Crossmint Console.

## Next steps

* [Bring Your Own Auth](/wallets/guides/bring-your-own-auth), recommended for production
* Read and update [user information](/authentication/user-profile)
* Use [webhooks](/authentication/webhooks) to get notified when a user signs up
* [Create Smart Wallets on sign up](/wallets/quickstarts/react)


# Secure Cookies
Source: https://docs.crossmint.com/authentication/security

Learn how to securely store Crossmint Auth cookies in your application

Authentication tokens are accessible to client-side JavaScript by default through non-HttpOnly cookies. For stronger security, you can store tokens in HttpOnly cookies, which are accessible only on the server side. This setup requires custom routes for refreshing tokens and logging out, using utilities from `@crossmint/server-sdk`.

## 1. Configure Cookie Options

When initializing the server SDK, configure secure cookie options:

```typescript theme={null}
import { createCrossmint, CrossmintAuth } from "@crossmint/server-sdk";

const crossmint = createCrossmint({ apiKey: process.env.SERVER_CROSSMINT_API_KEY });
const crossmintAuth = CrossmintAuth.from(crossmint, {
    cookieOptions: {
        httpOnly: true,
        secure: true, // Only send cookies over HTTPS
        domain: ".yourdomain.com", // Optional: specify cookie domain
    },
});
```

**Note:** The `httpOnly` flag only applies to the refresh token. The session JWT remains accessible to client-side JavaScript since it's needed for API calls.

## 2. Custom Routes Implementation

### Token Refresh Route

<Tabs>
  <Tab title="Next.js (App Router)">
    ```typescript theme={null}
    import { createCrossmint, CrossmintAuth } from "@crossmint/server-sdk";
    import { NextRequest } from "next/server";

    const crossmint = createCrossmint({ apiKey: process.env.SERVER_CROSSMINT_API_KEY! });
    const crossmintAuth = CrossmintAuth.from(crossmint);

    export async function POST(request: NextRequest) {
        return await crossmintAuth.handleCustomRefresh(request);
    }
    ```
  </Tab>

  <Tab title="Express.js">
    ```typescript theme={null}
    import express from "express";
    import { createCrossmint, CrossmintAuth } from "@crossmint/server-sdk";

    const app = express()
    const crossmint = createCrossmint({ apiKey: process.env.SERVER_CROSSMINT_API_KEY! });
    const crossmintAuth = CrossmintAuth.from(crossmint);

    app.post("/api/auth/refresh", async (req, res) => {
        await crossmintAuth.handleCustomRefresh(req, res);
        res.end();
    });
    ```
  </Tab>
</Tabs>

### Logout Route

<Tabs>
  <Tab title="Next.js (App Router)">
    ```typescript theme={null}
    import { createCrossmint, CrossmintAuth } from "@crossmint/server-sdk";
    import { NextRequest } from "next/server";

    const crossmint = createCrossmint({ apiKey: process.env.SERVER_CROSSMINT_API_KEY! });
    const crossmintAuth = CrossmintAuth.from(crossmint);

    export async function POST(request: NextRequest) {
        return await crossmintAuth.logout(request);
    }
    ```
  </Tab>

  <Tab title="Express.js">
    ```typescript theme={null}
    import express from "express";
    import { createCrossmint, CrossmintAuth } from "@crossmint/server-sdk";

    const app = express()
    const crossmint = createCrossmint({ apiKey: process.env.SERVER_CROSSMINT_API_KEY! });
    const crossmintAuth = CrossmintAuth.from(crossmint);

    app.post("/api/auth/logout", async (req, res) => {
        await crossmintAuth.logout(req, res);
        res.end();
    });
    ```
  </Tab>
</Tabs>

## 3. Client Configuration

Configure the client SDK to use your custom routes:

<Tabs>
  <Tab title="TypeScript">
    ```typescript theme={null}
    import { createCrossmint, CrossmintAuth } from "@crossmint/client-sdk-auth";

    const crossmint = createCrossmint({ apiKey: process.env.NEXT_PUBLIC_CLIENT_CROSSMINT_API_KEY! });
    const crossmintAuth = CrossmintAuth.from(crossmint, {
        refreshRoute: "/api/auth/refresh",
        logoutRoute: "/api/auth/logout"
    });
    ```
  </Tab>

  <Tab title="React">
    ```tsx theme={null}
    import { CrossmintProvider, CrossmintAuthProvider } from "@crossmint/client-sdk-react-ui";

    <CrossmintProvider apiKey={process.env.NEXT_PUBLIC_CLIENT_CROSSMINT_API_KEY ?? ""}>
        <CrossmintAuthProvider
            refreshRoute="/api/auth/refresh"
            logoutRoute="/api/auth/logout"
        >
            {children}
        </CrossmintAuthProvider>
    </CrossmintProvider>
    ```
  </Tab>
</Tabs>

**Note:** Depending on the framework you're using, you might need to set the whole URL in the `refreshRoute` and `logoutRoute` options.


# Server-Side Rendering (SSR)
Source: https://docs.crossmint.com/authentication/ssr

Integrate Crossmint Auth on the server-side for user authentication and management

Crossmint Auth provides a flexible and simple authentication solution for your crypto server-side applications. This guide covers how to integrate and use Crossmint Auth across various server-side frameworks.

## Overview

Our server SDK allows you to:

* Manage user sessions
* Retrieve user profiles
* Verify JSON Web Tokens (JWTs)

## Installation

First, install the Crossmint Server SDK:

<CodeGroup>
  ```bash npm theme={null}
  npm i @crossmint/server-sdk
  ```

  ```bash yarn theme={null}
  yarn add @crossmint/server-sdk
  ```

  ```bash pnpm theme={null}
  pnpm add @crossmint/server-sdk
  ```

  ```bash bun theme={null}
  bun add @crossmint/server-sdk
  ```
</CodeGroup>

## Initialization

To use Crossmint Auth, you need to initialize it with your Server API key. This API requires the `users.read` scope.

```typescript theme={null}
import { createCrossmint, CrossmintAuth } from "@crossmint/server-sdk";

const crossmint = createCrossmint({ apiKey: process.env.SERVER_CROSSMINT_API_KEY });
const crossmintAuth = CrossmintAuth.from(crossmint);
```

## Core Functionality

### Session Management

The `getSession` method validates or refreshes a user's session based on their JWT and refresh token.

```typescript theme={null}
const { jwt, refreshToken, userId } = await crossmintAuth.getSession(req, res);
```

This method:

1. Fetches the current JWT and refresh token from the cookies with keys `crossmint-jwt` and `crossmint-refresh-token`.
2. Checks if the current JWT is valid
3. Refreshes the session if needed
4. Stores the new JWT and refresh token in cookies
5. Returns new auth materials and the user ID

<Tabs>
  <Tab title="Next.js (App Router)">
    For other frameworks that do not expose standard request and response objects, such as Next.js using the App Router, you can pass in an object with `jwt` and `refreshToken` properties instead:

    <CodeGroup>
      ```typescript middleware.ts theme={null}
      import { NextResponse } from "next/server";
      import type { NextRequest } from "next/server";
      import { createCrossmint, CrossmintAuth } from "@crossmint/server-sdk";

      export async function middleware(request: NextRequest) {
          // Skip middleware for API routes and static files
          if (request.nextUrl.pathname.startsWith("/api") || request.nextUrl.pathname.startsWith("/_next")) {
              return NextResponse.next();
          }

          const response = NextResponse.next();

          const jwt = request.cookies.get("crossmint-jwt")?.value;
          const refreshToken = request.cookies.get("crossmint-refresh-token")?.value;

          if (refreshToken == null) {
              return response;
          }

          try {
              const crossmint = createCrossmint({
                  apiKey: process.env.SERVER_CROSSMINT_API_KEY || "",
              });
              const crossmintAuth = CrossmintAuth.from(crossmint);

              const { jwt: newJwt, refreshToken: newRefreshToken } = await crossmintAuth.getSession({
                  jwt,
                  refreshToken,
              });

              // Only update response cookies if tokens have changed
              if (newJwt !== jwt || newRefreshToken.secret !== refreshToken) {
                  response.cookies.set("crossmint-jwt", newJwt);
                  response.cookies.set("crossmint-refresh-token", newRefreshToken.secret);
              }
          } catch (_) {
              // If auth fails, clear cookies and redirect to home
              response.cookies.delete("crossmint-jwt");
              response.cookies.delete("crossmint-refresh-token");
          }

          return response;
      }
      ```

      ```typescript getAuthSession.ts theme={null}
      import { cookies } from "next/headers";
      import { createCrossmint, CrossmintAuth } from "@crossmint/server-sdk";

      export async function getAuthSession() {
          const cookieStore = await cookies();
          const jwt = cookieStore.get("crossmint-jwt")?.value;
          const refreshToken = cookieStore.get("crossmint-refresh-token")?.value;

          if (refreshToken == null) {
              return;
          }

          try {
              const crossmint = createCrossmint({
                  apiKey: process.env.SERVER_CROSSMINT_API_KEY || "",
              });
              const crossmintAuth = CrossmintAuth.from(crossmint);

              const session = await crossmintAuth.getSession({
                  jwt,
                  refreshToken,
              });
              return session;
          } catch (_) {
              return;
          }
      }
      ```

      ```typescript page.tsx theme={null}
      import { getAuthSession } from "@/hooks/auth";
      import { createCrossmint, CrossmintAuth } from "@crossmint/server-sdk";

      export default async function ProtectedRoute() {
        const session = await getAuthSession();
        const userId = session?.userId;

        if (userId != null) {
          // Fetch user data or perform authorized actions
          const crossmint = createCrossmint({
              apiKey: process.env.SERVER_CROSSMINT_API_KEY || "",
          });
          const crossmintAuth = CrossmintAuth.from(crossmint);
          const userData = await crossmintAuth.getUser(userId);

          return <div>Welcome, {userData.email}!</div>;
        }

        // Handle unauthenticated state
        return <div>Please log in to access this page.</div>;
      }
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Express.js">
    For Express.js applications, you can create middleware to handle authentication:

    ```typescript theme={null}
    import express from "express";
    import { createCrossmint, CrossmintAuth } from "@crossmint/server-sdk";

    const app = express();

    const crossmint = createCrossmint({
        apiKey: process.env.SERVER_CROSSMINT_API_KEY || "",
    });
    const crossmintAuth = CrossmintAuth.from(crossmint);

    const authMiddleware = async (req, res, next) => {
      try {
        const { jwt, refreshToken, userId } = await crossmintAuth.getSession(req, res);
        req.user = { userId };
        next();
      } catch (error) {
        res.status(401).json({ error: "Authentication failed" });
      }
    };

    app.use(authMiddleware);

    app.get("/protected", (req, res) => {
      res.json({ message: "Protected route", userId: req.user.userId });
    });
    ```
  </Tab>

  <Tab title="Vanilla Node.js">
    For a basic Node.js server:

    ```typescript theme={null}
    import http from "http";
    import { createCrossmint, CrossmintAuth } from "@crossmint/server-sdk";

    const crossmint = createCrossmint({
        apiKey: process.env.SERVER_CROSSMINT_API_KEY || "",
    });
    const crossmintAuth = CrossmintAuth.from(crossmint);

    const server = http.createServer(async (req, res) => {
      if (req.url === "/protected") {
        try {
          const { userId } = await crossmintAuth.getSession(req, res);
          const userData = await crossmintAuth.getUser(userId);

          res.writeHead(200, { "Content-Type": "application/json" });
          res.end(JSON.stringify({ message: "Authenticated", user: userData }));
        } catch (error) {
          res.writeHead(401, { "Content-Type": "application/json" });
          res.end(JSON.stringify({ error: "Authentication failed" }));
        }
      } else {
        res.writeHead(404);
        res.end();
      }
    });

    server.listen(3000);
    ```
  </Tab>
</Tabs>

### User Profile Retrieval

Fetch user details using the `getUser` method:

```typescript theme={null}
const user = await crossmintAuth.getUser(userId);
```

This provides access to user information such as email, phone number, and connected accounts (e.g., Twitter, Farcaster).

### JWT Verification

Verify JWTs independently using the `verifyCrossmintJwt` method:

```typescript theme={null}
const decodedJwt = crossmintAuth.verifyCrossmintJwt(token);
```

This is useful for validating tokens in middleware or specific endpoints. We expose our public keys for this purpose at [https://www.crossmint.com/.well-known/jwks.json](https://www.crossmint.com/.well-known/jwks.json).


# User Profile
Source: https://docs.crossmint.com/authentication/user-profile

Retrieve user profile data such as email or social login metadata

Crossmint Auth provides a way to retrieve and update user profile data, such as email, social login metadata, and more.

<AccordionGroup>
  <Accordion title="Fields in the User Object">
    The user object contains the following information:

    * `id`: User's unique identifier.
    * `email`: User's email address.
    * `phoneNumber`: User's phone number.
    * `farcaster`: User's Farcaster account data.
    * `twitter`: User's Twitter (X) account data.

    Farcaster Account data contains:

    * `fid`: User's Farcaster ID.
    * `username`: User's Farcaster username.
    * `bio`: User's Farcaster bio.
    * `displayName`: User's Farcaster display name.
    * `pfpUrl`: User's Farcaster profile image URL.
    * `custody`: User's FID custody address.
    * `verifications`: List of the user's verified addresses.

    Twitter Account data contains:

    * `id`: User's Twitter ID.
    * `username`: User's Twitter username.
  </Accordion>
</AccordionGroup>

## Reading User Data

This API requires the `users.read` scope.

* **Server side**: Requires a server-side API key.
* **Client side**: Requires a client-side API key, and a logged in user.

### Server-side

For server-side operations, use the `@crossmint/server-sdk` that provides a `getUser` function to fetch user information.

```typescript theme={null}
import { createCrossmint, CrossmintAuth } from "@crossmint/server-sdk";

const crossmint = createCrossmint({ apiKey: "<YOUR_SERVER_API_KEY>" });
const crossmintAuth = CrossmintAuth.from(crossmint);

async function getUser(userId: string) {
    try {
        const user = await crossmintAuth.getUser(userId);
        console.log("User data:", user);
    } catch (error) {
        console.error("Error fetching user data:", error);
    }
}
```

### Response Format

```json theme={null}
{
    "id": "123",
    "email": "test@test.com", // Optional (if user was created with email)
    "phoneNumber": "123456789", // Optional (if user was created with phone number)
    "farcaster": {
        "fid": "123",
        "username": "johndoe",
        "bio": "Hello, I'm John Doe",
        "displayName": "John Doe",
        "pfpUrl": "https://example.com/pfp.jpg",
        "custody": "0x1234567890123456789012345678901234567890",
        "verifications": ["0x1234567890123456789012345678901234567890"]
    },
    "twitter": {
        "id": "456",
        "username": "johndoe"
    }
}
```

### Client-side

Use the `useAuth` react hook from `@crossmint/client-sdk-react-ui` to access the user object.

<Note>
  If you would like to use a different framework, [contact support](https://help.crossmint.com/hc/en-us/requests/new)
</Note>

```tsx React theme={null}
import { useAuth } from "@crossmint/client-sdk-react-ui";

function User() {
    const { user } = useAuth();

    if (!user) {
        return <div>Loading user...</div>;
    }

    return (
        <div>
            <h1>User</h1>
            <p>User ID: {user.id}</p>
            <p>Email: {user.email}</p>
            <p>Phone Number: {user.phoneNumber}</p>
            <p>Farcaster FID: {user.farcaster?.fid}</p>
            <p>Farcaster Username: {user.farcaster?.username}</p>
            <p>Farcaster Bio: {user.farcaster?.bio}</p>
            <p>Farcaster Display Name: {user.farcaster?.displayName}</p>
            <p>Farcaster PFP URL: {user.farcaster?.pfpUrl}</p>
            <p>Farcaster Custody: {user.farcaster?.custody}</p>
            <p>Farcaster Verifications: {user.farcaster?.verifications}</p>
            <p>Twitter ID: {user.twitter?.id}</p>
            <p>Twitter Username: {user.twitter?.username}</p>
        </div>
    );
}
```


# User Webhooks
Source: https://docs.crossmint.com/authentication/webhooks

Crossmint provides webhooks to notify your application about important user-related events. Below are the details of the available webhooks

### Webhook Events

#### `users.created`

This webhook is triggered when a new user is created.

##### Payload

```json theme={null}
{
    "type": "users.created",
    "status": "success",
    "data": {
        "id": "123", // User's identifier
        "email": "test@test.com", // Optional (if user was created with email)
        "phoneNumber": "123456789" // Optional (if user was created with phone number)
    }
}
```

#### `users.updated`

This webhook is triggered when a user's email or phone number is successfully updated.

##### Payload

```json theme={null}
{
    "type": "users.updated",
    "status": "success",
    "data": {
        "actionId": "1234", // Update action identifier
        "userId": "123", // User identifier
        "oldEmail": "test@test.com", // Optional (if user was created with email)
        "newEmail": "test2@test2.com", // Optional (if user was created with email)
        "oldPhoneNumber": "123456789", // Optional (if user was created with phone number)
        "newPhoneNumber": "987654321" // Optional (if user was created with phone number)
    }
}
```

### Handling Webhooks

To handle webhooks, you need to set up an endpoint in your application that can receive HTTP POST requests from Crossmint. Here is an example of how you might handle a webhook in a Node.js application:

```javascript theme={null}
import express from "express";

const app = express();
app.use(express.json());

function handleUserCreated(data) {
    console.log("User created:", data.id);
}

function handleUserUpdated(data) {
    console.log("User updated:", data.userId);
}

app.post("/webhooks", (req, res) => {
    const event = req.body;

    switch (event.type) {
        case "users.created":
            handleUserCreated(event.data);
            break;
        case "users.updated":
            handleUserUpdated(event.data);
            break;
        default:
            console.log(`Unhandled event type: ${event.type}`);
    }

    res.sendStatus(200);
});

app.listen(3000, () => {
    console.log("Webhook server listening on port 3000");
});
```


# Crossmint help
Source: https://docs.crossmint.com/cli/help

List all commands and provides the help documentation for a given command

Run the following command from your terminal to list all commands

````
crossmint help
```

## Options

```
$ crossmint --help <command>      # Display help for command, including the supported flags
$ crossmint -h <command>             # Display help for command, including the supported flags
```

## Example


```
Usage: crossmint [options] [command]

Crossmint CLI Tool

Options:
  -V, --version   output the version number
  -h, --help      display help for command

Commands:
  keys            API Keys management commands
  login [options] Login to Crossmint
  logout          Logout from Crossmint
  projects        Project management commands
  whoami          Show current user and environment
  help [command]  display help for command
```
````


# Get started with the Crossmint CLI
Source: https://docs.crossmint.com/cli/install

Manage and configure your Crossmint projects directly from the command line

### Latest CLI version - <a href="https://www.npmjs.com/package/@crossmint/cli"><img alt="npm" /></a>

The Crossmint CLI is a command-line tool that allows you to interact with Crossmint directly from your terminal. It can be installed via Homebrew or any javascript package managers and works on macOS, Linux, and Windows.

### Installation

To download and install Crossmint CLI, run the following command from your terminal:

<CodeGroup>
  ```bash pnpm theme={null}
  pnpm add -g @crossmint/cli
  ```

  ```bash yarn theme={null}
  yarn global add @crossmint/cli
  ```

  ```bash npm theme={null}
  npm install -g @crossmint/cli
  ```

  ```bash brew theme={null}
  brew tap crossmint/tap
  brew install crossmint
  ```
</CodeGroup>

### Verify installation

After installing, verify the CLI is available and check the installed version:

```bash theme={null}
crossmint --version
```

### Update

To update to the latest version, re-run the install command for your package manager, or use the following:

<CodeGroup>
  ```bash pnpm theme={null}
  pnpm add -g @crossmint/cli@latest
  ```

  ```bash yarn theme={null}
  yarn global add @crossmint/cli@latest
  ```

  ```bash npm theme={null}
  npm install -g @crossmint/cli@latest
  ```

  ```bash brew theme={null}
  brew upgrade crossmint
  ```
</CodeGroup>

## Command Reference

The Crossmint CLI provides the following commands:

| Command                                                                              | Description                                                   |
| ------------------------------------------------------------------------------------ | ------------------------------------------------------------- |
| `crossmint login [options]` <ExternalLink href="/cli/login" />                       | Login to Crossmint                                            |
| `crossmint logout` <ExternalLink href="/cli/logout" />                               | Logout from Crossmint                                         |
| `crossmint whoami` <ExternalLink href="/cli/whoami" />                               | Show current user and environment                             |
| `crossmint help` <ExternalLink href="/cli/help" />                                   | List and explains all commands                                |
| `crossmint keys create` <ExternalLink href="/cli/keys/create" />                     | Create a new API Key                                          |
| `crossmint keys list [type]`<ExternalLink href="/cli/keys/list" />                   | List all API Keys (optionally filter by type: server\|client) |
| `crossmint keys delete <key-id>` <ExternalLink href="/cli/keys/delete" />            | Delete an API Key                                             |
| `crossmint keys edit <key-id>` <ExternalLink href="/cli/keys/edit" />                | Edit the scopes of an API Key                                 |
| `crossmint projects create`<ExternalLink href="/cli/projects/create" />              | Create a new project                                          |
| `crossmint projects select [project-id]`<ExternalLink href="/cli/projects/select" /> | Select a project                                              |
| `crossmint projects list`<ExternalLink href="/cli/projects/list" />                  | List all projects                                             |
| `crossmint projects details`<ExternalLink href="/cli/projects/details" />            | Show project details                                          |

Refer to the individual command documentation for more detailed information on each command.


# Crossmint keys create
Source: https://docs.crossmint.com/cli/keys/create

Create a new API key

The keys create command allows you to create a new API key for your Crossmint project.

To use it, run the following command from your terminal

```bash theme={null}
crossmint keys create
```

<Note>
  **Server-side keys** are view-once in Production, make sure to copy your API key secret when it’s displayed, as it
  won’t be shown again.
</Note>

<Note>
  **Client-side keys** require selecting the app type and adding allowed origins—use domain URLs for web or
  package/bundle IDs for mobile.
</Note>

## Example

Start the API key creation process:

```bash theme={null}
crossmint keys create
```

Select the type of key you want to create:

```
? Select Key Usage: (Use arrow keys)
  Server side
> Client side
```

For client-side keys, select the application type:

```
? Select client platform: (Use arrow keys)
> Web
  Mobile
```

Specify the allowed origins for your key.

* For web enter the domain, eg: [https://crossmint.com](https://crossmint.com)
* For mobile enter your Android Package name or IOS Bundle ID, eg: com.company.appname

<Tip>Enter multiple domains or app identifiers separated by a comma.</Tip>

```
? Enter whitelisted domain or localhost (e.g., https://www.yourdomain.com) (separate multiple domains with a comma):
https://www.crossmint.com
```

Select the scopes you want to add to the key by pressing space. Once you are ready, press enter to create the key:

```
? Select scopes for client key:
● Read wallet (wallets.read)
● Create wallet (wallets.create)
○ Create Transaction (wallets.transactions.create)
○ Sign Transaction (wallets.transactions.sign)
○ Read Transactions (wallets.transactions.read)
○ Create Wallet Signatures (wallets.signatures.create)
```

The CLI will display the created API key information, this includes the Key ID and Client Secret:

```
 ✅ API Key created successfully!
Key ID: 67ff9c388687868382...
🔒 Key Secret: ck_production_3218u5TFZMGkK16uLbKfxDsJ4xtwSd2xtZRa9A8cbe64oRMe1J148XTGbuSvqmxB4k9TspLUAbKyt2RTqbArGBdkvARxkCg8S1tgwb4ie3gUNFw74vTuCUhSpu7ojkjGxY6epj...
```


# Crossmint keys delete
Source: https://docs.crossmint.com/cli/keys/delete

Delete an API key

The keys delete command allows you to delete an existing API key from your Crossmint project.

To use it, run the following command from your terminal

```bash theme={null}
crossmint keys delete <key-id>
```

Where `<key-id>` is the ID of the API key you want to delete.
You can get the key id by running `keys list` command

## Example

Delete an API key:

```bash theme={null}
crossmint keys delete sk_test_abcd1234
```

You will be prompted to confirm the deletion:

```
? Are you sure you want to delete this API key? This action cannot be undone. (y/N)
```

After confirming, you'll see a success message:

```
✅ API Key deleted successfully!
```

**Note:** Once an API key is deleted, any applications or services using that key will no longer be able to authenticate with the Crossmint API.


# Crossmint keys edit
Source: https://docs.crossmint.com/cli/keys/edit

Edit an API key

The keys edit command allows you to modify the scopes of an existing server API key.

To use it, run the following command from your terminal

```bash theme={null}
crossmint keys edit <key-id>
```

Where `<key-id>` is the ID of the API key you want to edit. You can get the key id by running `keys list` command.

## Example

Edit an API key:

```bash theme={null}
crossmint keys edit sk_test_abcd1234
```

For client-side keys, edit the allowed origins for your key. Press `<tab>` for editing or `<enter>` for confirming the value.

* For web enter the domain, eg: [https://crossmint.com](https://crossmint.com)
* For mobile enter your Android Package name or IOS Bundle ID, eg: com.company.appname

<Tip>Enter multiple domains or app identifiers separated by a comma.</Tip>

```
? Enter whitelisted domain or localhost (e.g., https://www.yourdomain.com) (separate multiple domains with a comma):
Press <tab> to edit or <enter> to confirm current value  (https://www.crossmint.com)
```

The CLI will display the current scopes and prompt you to select new ones:

```
Current scopes: Wallets
? Select the new scopes for this key: (Press <space> to select, <a> to toggle all, <i> to invert selection, and <enter> to proceed)
❯◉ Wallets
 ◉ Minting
 ◯ Payments
 ◯ Authentication
```

After selecting the new scopes, you'll see a confirmation message:

```
✅ API Key updated successfully!
```


# Crossmint keys list
Source: https://docs.crossmint.com/cli/keys/list

List all API keys

The keys list command displays all API keys associated with your Crossmint project.

To use it, run the following command from your terminal

```bash theme={null}
crossmint keys list [type]
```

Where `[type]` is an optional parameter to filter keys by type (server or client).

## Example

List all API keys:

```bash theme={null}
crossmint keys list
```

```
=========

1. Key ID: 67d444369323ea298a4ef9f8
   Key Secret: ******************4jTa

Type                 Server
Created By           guille.a@paella.dev
Created              3/14/2025, 3:59:02 PM
Scopes               wallets.read, wallets.create, wallets:transactions.create, wallets:transactions.sign, wallets:transactions.read, wallets:signatures.create, wallets:signatures.read, wallets:nfts.read, wallets:balance.read, wallets.fund, wallets:messages.sign

=========

2. Key ID: 679217c403723242bd87d3e75
   Key Secret: ck_production_AGUysPdnSg3rW2opefTqWAbfXRaCLtEBiYCSNL7
Jbm9L

Type                 Client
Created              1/23/2025, 11:19:48 AM
Scopes               wallets.read, wallets.create, wallets:nfts.read, wallets:transactions.create
Whitelisted App IDs  com.company.appname

=========
```

List only server API keys:

```bash theme={null}
crossmint keys list server
```

```
=========

1. Key ID: 67d444369bbbea298a4ef932
   Key Secret: ******************4jTa

Type                 Server
Created By           guille.a@paella.dev
Created              3/14/2025, 3:59:02 PM
Scopes               wallets.read, wallets.create, wallets:transactions.create, wallets:transactions.sign, wallets:transactions.read, wallets:signatures.create, wallets:signatures.read, wallets:nfts.read, wallets:balance.read, wallets.fund, wallets:messages.sign

=========
```


# Crossmint login
Source: https://docs.crossmint.com/cli/login

Authenticate to the Crossmint platform

The login command authenticates you with the Crossmint platform. It allows you to access your account and manage API keys and projects through the CLI.

To use it, run the following command from your terminal

```bash theme={null}
crossmint login [options]
```

## Options

| Option                    | Description                                         |
| ------------------------- | --------------------------------------------------- |
| `-e, --env <environment>` | Environment to login to (`staging` or `production`) |

## Example

Start the login process:

```bash theme={null}
crossmint login
```

Or specify the environment directly to skip the prompt:

```bash theme={null}
crossmint login --env production
```

Select an environment:

```
? Select environment: (Use arrow keys)
> Production
  Staging
```

The CLI will open a browser window to authorize your device. If you're not signed in to Crossmint in the browser, you'll need to login first. Once the device is authorized, you can close the browser and return to the terminal.

<img alt="Authorize Device Success" />

```
✅ Login successful! You are now authenticated in the Production environment.
```

You'll then be prompted to select a project:

```
? Select a project: (Use arrow keys)
> My Project
  Website Integration
  Mobile App
```


# Crossmint logout
Source: https://docs.crossmint.com/cli/logout

Sign out from the Crossmint platform

The logout command signs you out from the Crossmint platform by removing your session token from local storage.

To use it, run the following command from your terminal

```bash theme={null}
crossmint logout
```

## Example

Sign out from Crossmint:

```bash theme={null}
crossmint logout
```

After running the command, you'll see a confirmation message:

```
✅ Logout successful! You are no longer authenticated.
```

After logging out, you will need to use the `login` command to authenticate again before using other commands that require authentication.


# Crossmint projects create
Source: https://docs.crossmint.com/cli/projects/create

Create a new project in Crossmint

The projects create command allows you to create a new project in your Crossmint account.

To use it, run the following command from your terminal

```bash theme={null}
crossmint projects create [options]
```

## Options

| Option              | Description              |
| ------------------- | ------------------------ |
| `-n, --name <name>` | Give your project a name |

## Example

Create a new project:

```bash theme={null}
crossmint projects create
```

You'll be prompted to enter a name for the project:

```
? Enter project name: My New Project
```

After entering a name, you'll see a confirmation message:

```
✔ ✅ Project created successfully!


📌 Project Details:
Name: New Project
ID: 4b0392a3-35c3-458c-a43e-32d2cdc65eda
```

You'll be ask to confirm if you want to select the created project for subsequent commands.

````
? Do you want to select this project? (Y/n)

```

You can also specify the project name directly using the `--name` option:

```bash
crossmint projects create --name "My New Project"
```


````


# Crossmint projects details
Source: https://docs.crossmint.com/cli/projects/details

View details of a project

The projects details command displays information about the currently selected project.

To use it, run the following command from your terminal

```bash theme={null}
crossmint projects details
```

## Example

View details of the current project:

```bash theme={null}
crossmint projects details
```

You'll see the information about your project:

```
📌 Project Details:
Name: New Project
ID: f5e37bee-1a81-4df1-8081-7670eee2a629
Wallet Type: Custodial
```

This command is useful for verifying which project you're currently working with and viewing its basic information.


# Crossmint projects list
Source: https://docs.crossmint.com/cli/projects/list

List all projects in your Crossmint account

The projects list command displays all projects associated with your Crossmint account.

To use it, run the following command from your terminal

```bash theme={null}
crossmint projects list
```

## Example

List all your projects:

```bash theme={null}
crossmint projects list
```

You'll see a list of all your projects with their IDs:

```
✔ Found 3 projects:

  1. My New Project
     ID: 4b0392a3-35c3-458c-a43e-32d2cdc65eda

  2. Website Integration
     ID: f5e37bee-1a81-4df1-8081-7670eee2a629

  3. Mobile App
     ID: 9a1b2c3d-4e5f-6789-abcd-ef0123456789
```

This command is useful for viewing all available projects and retrieving project IDs, which can then be passed to `crossmint projects select` for non-interactive project selection.


# Crossmint projects select
Source: https://docs.crossmint.com/cli/projects/select

Select a project to work with

The projects select command allows you to choose which Crossmint project you want to work with for subsequent commands.

To use it, run the following command from your terminal

```bash theme={null}
crossmint projects select [project-id]
```

## Arguments

| Argument       | Description                                                         |
| -------------- | ------------------------------------------------------------------- |
| `[project-id]` | Optional. The ID of the project to select (for non-interactive use) |

## Example

### Interactive selection

Select a project interactively:

```bash theme={null}
crossmint projects select
```

You'll be presented with a list of your projects:

```
? Select a project: (Use arrow keys)
> My New Project
  Website Integration
  Mobile App
  Test Project
```

After selecting a project, you'll see a confirmation message:

```
✅ Project My New Project selected
```

### Non-interactive selection

You can also pass a project ID directly to skip the interactive prompt. This is useful for scripting and agent-based workflows:

```bash theme={null}
crossmint projects select 4b0392a3-35c3-458c-a43e-32d2cdc65eda
```

```
✅ Project My New Project selected
```

<Tip>
  Use `crossmint projects list` to view all available projects and their IDs.
</Tip>

After selecting a project, commands that require a project context (like API key management) will use the selected project.


# Crossmint whoami
Source: https://docs.crossmint.com/cli/whoami

Display current user, environment and selected project

The whoami command displays information about the currently authenticated user, the environment you're working in and the selected project.

To use it, run the following command from your terminal

```bash theme={null}
crossmint whoami
```

## Example

Check your current authentication status:

```bash theme={null}
crossmint whoami
```

You'll see output showing your email and environment:

```
You are logged in to 🍀Crossmint as: user@example.com - Environment: Production - Selected Project: My New Project
```

This command is useful for verifying your authentication status, checking which environment and project you're working in.


# Using AI Assistants
Source: https://docs.crossmint.com/introduction/ai-assistants



Integrate faster with Crossmint by ingesting the docs into your AI-based code helpers (like Cursor, GitHub Copilot, etc.).

<Card title="Markdown docs" icon="book" href="https://docs.crossmint.com/llms-full.txt">
  AI assistant ready docs
</Card>

## Integrate with Cursor

1. Navigate to Cursor Settings > Features > Docs

2. Select "Add new doc" and paste the following URL:

```
https://docs.crossmint.com/llms-full.txt
```

3. Use `@docs -> Crossmint` to reference Crossmint's docs in your code.

***

> To find navigation and other pages in this documentation, fetch the llms.txt file at: [https://docs.crossmint.com/llms.txt](https://docs.crossmint.com/llms.txt)

## Crossmint Docs MCP Server

### Overview

Model Context Protocol (MCP) is a standard that enables AI agents to connect quickly and efficiently to external tools or data sources.

### Server Details

Instead of loading the entire documentation with every interaction, the server receives your query and returns only the most relevant sections.

* **Name:** Crossmint Docs
* **URL:** [https://docs.crossmint.com/mcp](https://docs.crossmint.com/mcp)
* **Transport:** Streamable HTTP

### Installation

<Tabs>
  <Tab title="Claude Code">
    Run the following command in your terminal:

    ```bash theme={null}
    claude mcp add --transport http crossmint-docs https://docs.crossmint.com/mcp
    ```
  </Tab>

  <Tab title="Cursor">
    Add it globally by opening the command palette (`Cmd/Ctrl + Shift + P`) and selecting `> Cursor Settings > Tools & MCP > Add Custom MCP`:

    ```json theme={null}
    {
        "mcpServers": {
            "Crossmint Docs": {
                "type": "http",
                "url": "https://docs.crossmint.com/mcp"
            }
        }
    }
    ```
  </Tab>

  <Tab title="VS Code">
    Add it globally by opening the command palette (`Cmd/Ctrl + Shift + P`) and selecting `MCP: Open User Configuration`:

    ```json theme={null}
    {
        "servers": {
            "Crossmint Docs": {
                "type": "http",
                "url": "https://docs.crossmint.com/mcp"
            }
        }
    }
    ```
  </Tab>
</Tabs>

### Usage

Once you have configured and connected the MCP Server, your agent will have access to a single tool called `SearchCrossmintDocs`. This tool allows it to search through the Crossmint documentation to find relevant information, code examples, API references, and guides.

**Example queries (input):**

* "How to create non-custodial wallets for my users"
* "How to get a staging API key"
* "Does Crossmint support Solana?"
* "How to implement transfer webhooks?"

**Example output:**

A list of results that includes the following fields: Title, Link, and Content, along with code examples when available.

```json theme={null}
{
    "results": [
        {
            "title": "Server Wallets Quickstart",
            "link": "https://docs.crossmint.com/solutions/story-protocol/wallets/server-side-wallets",
            "content": "In this quickstart, you will create new user wallets on Story...",
            "codeExample": "const response = await fetch('https://staging.crossmint.com/api/2022-06-09/wallets', {\n  method: 'POST',\n  headers: {\n    'X-API-KEY': '<YOUR_API_KEY>',\n    'Content-Type': 'application/json'\n  },\n  body: JSON.stringify({\n    type: '<WALLET_TYPE>',\n    linkedUser: 'email:user@example.com'\n  })\n});"
        },
        {
            "title": "Amazon Integration Steps",
            "link": "https://docs.crossmint.com/solutions/ai-agents/agentic-commerce/inventory",
            "content": "Create a project in the Crossmint Console...",
            "codeExample": "const crossmintOrder = await fetch(`https://${baseUrl}.crossmint.com/api/2022-06-09/orders`, {\n  method: 'POST',\n  headers: {\n    'X-API-KEY': `${API_KEY}`,\n    'Content-Type': 'application/json'\n  },\n  body: JSON.stringify({\n    recipient: {\n      email: 'john@example.com'\n    },\n    lineItems: [{ productLocator: 'amazon:B00O79SKV6' }]\n  })\n});"
        }
    ]
}
```


# Getting Started
Source: https://docs.crossmint.com/introduction/getting-started



Before you can start integrating Crossmint into your application, you need to create a Crossmint account and set up a new project in the Staging Console. This guide will walk you through those steps.

<Steps>
  <Step title="Create an account in staging">
    Open Crossmint's [staging console](https://staging.crossmint.com/console) and create an account

    <Note>
      **Ready for launch?**
      When it's time to go live, simply create an account in the [production console](https://www.crossmint.com/console) and replicate the resources you need.
    </Note>
  </Step>

  <Step title="Create your first project">
    If you've just created an account for the first time, you'll be taken directly to project creation process. Add the name to your project and continue.
  </Step>

  <Step title="Get your API keys">
    In the [overview of your project](https://staging.crossmint.com/console/overview) you will find the client and server API keys you need to integrate Crossmint into your application.
  </Step>

  <Step title="Start building">
    Now that your project is created in the Console, you can start integrating Crossmint products into your application.

    <CardGroup>
      <Card title="Wallets" icon="wallet" href="/wallets/overview">
        Create wallets for users, agents, and companies.
      </Card>

      <Card title="Authentication" icon="at" href="/authentication/introduction">
        Authenticate users with email, socials, or wallets.
      </Card>

      <Card title="Checkout" icon="cart-shopping" href="/payments/introduction">
        Sell tokens and 1 billion physical products.
      </Card>

      <Card title="Onramps" icon="credit-card" href="https://www.crossmint.com/products/onramps-and-offramps">
        Fund wallets with stablecoins or crypto.
      </Card>

      <Card title="Tokenization" icon="cube" href="/minting/introduction">
        Mint, distribute, and manage tokens at scale.
      </Card>

      <Card title="Verifiable Credentials" icon="id-card" href="/minting/quickstarts/credentials">
        Issue and verify W3C credentials.
      </Card>
    </CardGroup>
  </Step>
</Steps>


# Glossary
Source: https://docs.crossmint.com/introduction/glossary

Key terms and definitions used across the Crossmint documentation.

A reference of key terms used throughout the Crossmint documentation. If you encounter an unfamiliar term in any guide or concept page, check here first.

| Term                                    | Definition                                                                                                                                                                                                                                                                                                                                                                               |
| --------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Smart contract wallet**               | A wallet deployed as a smart contract on a public blockchain. It lives onchain — not inside Crossmint's servers — and its behavior is governed by auditable code. On EVM chains, Crossmint wallets implement [ERC-4337](https://eips.ethereum.org/EIPS/eip-4337) with [ERC-7579](https://eips.ethereum.org/EIPS/eip-7579) modular extensions. See [Architecture](/wallets/architecture). |
| **Signer**                              | A cryptographic identity authorized to approve actions on a wallet. Signers are separate from the wallet itself and can be added, removed, or rotated without changing the wallet's address. See [Wallet Signers](/wallets/concepts/wallet-signers).                                                                                                                                     |
| **Operational signer**                  | A signer added to a wallet for day-to-day transaction authorization. Operational signers are registered by the recovery signer and can be scoped with specific permissions. Examples: a device key for user wallets, a server key for company wallets. See [Wallet Signers](/wallets/concepts/wallet-signers#operational-signers).                                                       |
| **Delegated signer**                    | The previous term for **operational signer**. Still used in current SDK method names (`addDelegatedSigner`, `delegatedSigners`) but being renamed in the next breaking release.                                                                                                                                                                                                          |
| **Recovery signer**                     | A signer used to regain access to a wallet when the operational signer is lost — for example, when a user gets a new phone. Recovery signers authorize the enrollment of a new operational signer without changing the wallet address. See [Wallet Signers](/wallets/concepts/wallet-signers#recovery-signers).                                                                          |
| **Admin signer**                        | The previous term for **recovery signer**. You may still encounter this term in older SDK versions and API responses.                                                                                                                                                                                                                                                                    |
| **Custody**                             | An entity has custody of a wallet if it can **unilaterally execute transactions** on the wallet or **unilaterally block transactions** on the wallet. See [Custody Modalities](/wallets/concepts/custody-modalities) for full details.                                                                                                                                                   |
| **Non-custodial**                       | A wallet configuration where your company cannot unilaterally move or block funds. Users control their own signers. See [Custody Modalities](/wallets/concepts/custody-modalities).                                                                                                                                                                                                      |
| **Wallet locator**                      | A human-readable identifier for a wallet, following the format `email:user@example.com:evm` or `userId:abc123:solana`. Used in API calls instead of raw wallet addresses.                                                                                                                                                                                                                |
| **Signer locator**                      | A human-readable identifier for a signer, such as `external-wallet:0x1234...` or `email:user@example.com`. Used when registering or referencing signers in API calls.                                                                                                                                                                                                                    |
| **TEE (Trusted Execution Environment)** | A hardware-attested secure enclave (e.g., Intel TDX) where sensitive cryptographic operations occur. Crossmint uses TEEs for email and SMS recovery signers — master secrets are derived inside the TEE and never exposed to Crossmint or the host application.                                                                                                                          |
| **Onchain**                             | Deployed to or enforced by the blockchain. In Crossmint wallets, signer permissions and wallet logic are onchain and publicly auditable.                                                                                                                                                                                                                                                 |


# Platform Overview
Source: https://docs.crossmint.com/introduction/platform-overview



Crossmint is an all-in-one platform to integrate [wallets](/wallets/overview), [stablecoins](/stablecoin-orchestration/overview), and other blockchain primitives into your product. Trusted by the world's largest financial institutions including MoneyGram and Santander Bank, and thousands of start-ups.

At its core, Crossmint abstracts the hardest parts of blockchain—wallets, keys, gas, compliance, and payments—into simple APIs, SDKs, and dashboards. This allows teams to focus on user experience and business logic while Crossmint handles the underlying complexity.

## How the platform is structured

Crossmint is designed as a modular platform composed of interoperable building blocks. You can use them independently or combine them into an end-to-end system:

| Product                                        | Description                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| :--------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Wallets](/wallets/overview)                   | Embedded wallets for user-facing applications and [treasury wallets](/stablecoin-orchestration/treasury-wallet/overview) for businesses. Wallets support flexible custody models, programmable permissions, and abstract away private keys and gas. Extensions such as [yield](/wallets/guides/wallet-extensions/generate-yield), trading, and [cards](/wallets/guides/wallet-extensions/credit-cards) can be added on top of core wallet functionality. |
| [Payments](/stablecoin-orchestration/overview) | Stablecoin-based money movement, including [onramps](/stablecoin-orchestration/onramp/overview) and offramps, [payouts and transfers](/stablecoin-orchestration/regulated-transfers/overview), and [checkout flows](/payments/introduction). These APIs enable accepting, sending, converting, and settling value across 150+ countries through a single integration.                                                                                    |
| [Tokenization](/minting/introduction)          | Issuance and distribution of tokens at scale.                                                                                                                                                                                                                                                                                                                                                                                                            |

The platform includes built-in compliance infrastructure across the regulated products, covering [KYC, AML and sanctions screening](/stablecoin-orchestration/users-compliance/overview), and travel rule compliance—so you can build compliant products without running these systems yourself.

## What you can build

Crossmint's building blocks are designed to be combined into complete, end-to-end solutions. Teams can mix and match wallets, payments, and embedded finance modules to support a wide range of products and workflows, like remittances and consumer fintech apps.

<Card title="Explore the solutions" icon="lightbulb" href="/solutions/overview">
  Browse guides tailored to your business vertical or use case
</Card>

## How teams integrate

Crossmint is API-first, with dashboards for monitoring and daily operations.

For customers building complex systems, Crossmint provides **forward-deployed engineers** and **solution architects** who partner closely with teams to design architecture, payment flows, and compliance setup, reducing implementation risk and time to launch.

## What makes Crossmint unique

* **All-in-one platform**: You don't have to orchestrate 5-10 vendors. In addition to the products above, Crossmint saves you from separate integrations with RPCs, data APIs, AML screening providers, KYC, and other ancillary providers, offering everything you need in a fully integrated platform.

* **Make the blockchain invisible to your users**: No gas fees, passphrases, transaction approval prompts, or other blockchain gimmicks.

* **Easy-to-use APIs**: Don't require blockchain experience to get you started in minutes. Crossmint optionally takes care of gas fees and bills you in fiat, so you don't have to touch crypto or set up a treasury wallet.

* **No vendor lock-in**: Change providers anytime with minimal user disruption.

* **Bank-grade security**: Battle-tested and trusted by some of the largest financial institutions in the world.

## Learn more

<CardGroup>
  <Card title="Supported blockchains" icon="link" href="/introduction/supported-chains">
    View all 50+ supported chains
  </Card>

  <Card title="Quickstarts" icon="bolt" href="/introduction/getting-started">
    Get started in minutes
  </Card>

  <Card title="Contact us" icon="message" href="https://www.crossmint.com/contact">
    Talk to our team
  </Card>
</CardGroup>


# Account Verification
Source: https://docs.crossmint.com/introduction/platform/account-verification

Learn how to get your account verified

Access to certain Crossmint products is subject to compliance review.

| Product                  | Requirement                                                                         |
| ------------------------ | ----------------------------------------------------------------------------------- |
| Wallets                  | No KYB required.                                                                    |
| Stablecoin Orchestration | KYB required.                                                                       |
| Onramps                  | KYB required.                                                                       |
| Checkout                 | KYB required. Collection whitelisting required for memecoins and primary NFT sales. |
| Tokenization             | No KYB required.                                                                    |

<Note>
  Reviews are only required in production. Staging does not require account or collection review for any product.
  Please note that each distinct project you create via the Crossmint Console will require a separate review.
</Note>

<Accordion title="For NFT Checkout">
  <Warning>
    Reviews can take up to 3 business days.
  </Warning>

  <Tabs>
    <Tab title="Verify your Account">
      ### Account Verification

      To enable credit card payments on primaries sellers are required to complete a
      <Tooltip>quick KYC</Tooltip>.

      You only have to verify a project once, and can create as many collections
      as you wish within that project. New projects require additional verification.

      <Tip>Cross-chain payments do not require account verification. Sellers on marketplaces are also not required to KYC.</Tip>

      <Accordion title="I am having trouble verifying">
        Account Verification requires a valid government ID and a selfie. Ensure all photos are well lit but without glare, and uncover your face removing eyewear and pulling long hair behind ears.
      </Accordion>

      <Accordion title="I am a launchpad or require verifying many creators">
        Crossmint offers a collection registration API and tools to verify creators and collections at scale. To learn more, [contact us](https://www.crossmint.com/contact/sales).
      </Accordion>
    </Tab>

    <Tab title="Verify your Collection">
      ### Collection Verification

      Crossmint has to review and verify all NFT collections before they can be purchased via Crossmint's checkout.

      To start the review, open your collection page in the Crossmint console, look for the "Verification
      Status" card in the left navbar, and click on "Verify now" in the collection entry. Ensure your collection
      meets Crossmint's [content policy](https://www.crossmint.com/content-policy), and that all the
      information provided is up to date and truthful. Reviews take up to 72hrs.

      <Note>Crossmint does not support the sale of securities, investment contracts, or any of the other categories specified on the content policy.</Note>

      <Accordion title="I am a launchpad or require verifying many collections">
        Crossmint offers a collection registration API and tools to verify collections at scale. To learn more, [contact us](https://www.crossmint.com/contact/sales).
      </Accordion>
    </Tab>
  </Tabs>
</Accordion>


# Client-side Keys
Source: https://docs.crossmint.com/introduction/platform/api-keys/client-side

How to create and use client-side API keys

## Create a Client-side Key

Navigate to the API Keys section of the developer console and click the "Create new key" button in the client-side keys section.

* [Staging API Keys](https://staging.crossmint.com/console/projects/apiKeys)
* [Production API Keys](https://www.crossmint.com/console/projects/apiKeys)

<Frame type="simple">
  <img alt="create client-side API key in Crossmint developer console" />
</Frame>

### Setting Authorized Origins

Client-side keys are exposed in the application and thus require additional security measures. The minimum requirement is to whitelist URLs that requests can be sent from. Client-side keys support two types of origins:

<Warning>
  You can only register either web origins or mobile app identifiers for a single API key, not both. If you need both
  types, you'll need to create separate API keys.
</Warning>

#### Web Origins

For web applications, you need to add the domains that requests will be sent from. In development, you'll need to add the local domain you test your application from. This is commonly `http://localhost` followed by a port number such as `3000`, `5173`, etc. For example, when developing with NextJS, the default origin you need to authorize is `http://localhost:3000`.

The expected format for web origins is a full URL with protocol, such as `https://www.yourdomain.com` or `http://localhost:3000`.

#### Mobile App Identifiers

For mobile applications, you need to add the bundle identifiers for iOS apps or package names for Android apps. The expected format is:

* iOS: Bundle ID (e.g., `com.company.appname`)
* Android: Package name (e.g., `com.company.appname`)

<Warning>
  Mobile app identifiers can be arbitrarily spoofed by malicious actors, as the headers sent from mobile applications can be modified. Do not rely solely on mobile app identifiers for security. Consider implementing additional authentication mechanisms such as JWT authentication for sensitive operations.
</Warning>

#### Desktop/CLI Applications

For desktop applications and CLI tools where origin headers cannot be reliably set, you can select the "Desktop/CLI" app type when creating your client-side API key. This option allows the key to be used without origin restrictions.

<Warning>
  **Security Warning**: Desktop/CLI keys have no origin-based protection. This means:

  * The key can be used from any origin or application
  * If the key is leaked, it can be used by anyone without restriction
  * Consider enabling JWT authentication for additional security
  * Only use this option when absolutely necessary (e.g., CLI tools, desktop apps, AI agents)

  For most use cases, we recommend using web origins or mobile app identifiers instead.
</Warning>

To create a Desktop/CLI key:

1. Select "Desktop/CLI" as the app type when creating or editing a client-side key
2. Consider enabling JWT authentication for additional security
3. Store the key securely and rotate it regularly

When you create a production API key you will need to authorize your production domain or app identifiers to use the API key. You can add multiple authorized domains or app identifiers for an API key to make requests from. Type in the domain or app identifier that you want to authorize and then click the "+ Add new origin" button.

<Frame type="simple">
  <img alt="add authorized origin to API key in Crossmint developer console" />
</Frame>

### Select Scopes

Within the modal that opens, toggle the required scopes you want to enable. You may need to expand an accordion for the product area you're working on to expose additional scope options.

<Frame type="simple">
  <img alt="select client-side API scopes in Crossmint developer console" />
</Frame>

For more information on API Key scopes visit the scopes page or the API Reference.

<CardGroup>
  <Card title="API Scopes" icon="bullseye" href="/introduction/platform/api-keys/scopes">
    Complete list of available API scopes
  </Card>

  <Card title="API Reference" icon="paper-plane" href="/api-reference/introduction">
    Detailed docs for all API endpoints
  </Card>
</CardGroup>

### JWT Authentication

Finally, select the option to require a JWT if your application or use case requires it. Enabing this setting will require that users are authenticated to permit API requests.

<Frame type="simple">
  <img alt="enable JWT Authentication in Crossmint developer console" />
</Frame>

<Tip>
  The [Wallets SDK](/sdk-reference/wallets/typescript/overview) requires this option to be enabled. It is optional for other
  client side APIs. For more information on the options, refer to the [JWT
  Authentication](/introduction/platform/api-keys/jwt-authentication) section.
</Tip>

If you choose to enable JWT Authentication for your client-side API key, there are additional configurations that must be made. You can choose between Crossmint authentication (ideal for staging and getting started fast), third party auth providers such as Auth0, Stytch, Firebase, Kinde, or Supabase (recommended for production), or custom solutions where you generate your own JWTs (also recommended for production).

You can find more information and guidance in the [JWT Authentication](/introduction/platform/api-keys/jwt-authentication) section.

***

## Using a Client-side Key

There are a few different approaches to using a client-side key. The most common option is passing it to the `init` function for a supported SDK. There are also some cases where you'll pass the key as a header in a raw API call from custom code, similar to how a server-side key works.

### Initializing an SDK

The most common way you'll leverage a client-side API key is by passing it to the `init` function for a supported SDK. See the examples below.

<CodeGroup>
  ```typescript crossmint-wallets-sdk.ts theme={null}
  import { CrossmintWallets, createCrossmint } from "@crossmint/wallets-sdk";

  const crossmint = createCrossmint({
  apiKey: process.env.NEXT_PUBLIC_CLIENT_SIDE_KEY ?? "",
  });

  const crossmintWallets = CrossmintWallets.from(crossmint);

  const wallet = await crossmintWallets.getOrCreateWallet({
  chain: "<your-chain>",
  signer: {
  type: "<signer-type>",
  },
  });

  ```

  ```typescript credentials-init.ts theme={null}
  import * as sdk from '@crossmint/client-sdk-verifiable-credentials';

  sdk.CrossmintAPI.init(process.env.NEXT_PUBLIC_CLIENT_SIDE_KEY);
  ```

  ```tsx auth-example.tsx theme={null}
  import { CrossmintProvider, CrossmintAuthProvider } from "@crossmint/client-sdk-react-ui";

  export default function RootLayout({
      children,
  }: Readonly<{
      children: React.ReactNode;
  }>) {
      return (
          <html lang="en">
              <body className={inter.className}>
                  <CrossmintProvider apiKey={process.env.NEXT_PUBLIC_CLIENT_SIDE_KEY ?? ""}>
                      <CrossmintAuthProvider loginMethods={["email", "google"]}>{children}</CrossmintAuthProvider>
                  </CrossmintProvider>
              </body>
          </html>
      );
  }
  ```
</CodeGroup>

### Direct API Call From Client

The Headless Checkout is one example where you may be writing custom API calls from your application to create orders. In this case, you set the client-side API key as a header named `X-API-KEY`, much like you would when making a server-side API call.

```typescript theme={null}
const createOrder = async (orderInput: any) => {
    try {
        const res = await fetch(`https://staging.crossmint.com/api/2022-06-09/orders`, {
            method: "POST",
            headers: {
                "Content-Type": "application/json",
                "x-api-key": process.env.NEXT_PUBLIC_CLIENT_SIDE_KEY,
            },
            body: JSON.stringify(orderInput),
        });

        const order = await res.json();

        setOrder(order.order);
        setClientSecret(order.clientSecret);
    } catch (e) {
        console.error(e);
        throw new Error("Failed to create order");
    }
};
```


# JWT Authentication
Source: https://docs.crossmint.com/introduction/platform/api-keys/jwt-authentication

Enable advanced security for client-side API Keys

JWT-based authentication is a mechanism in which you can authorize a call to a Crossmint API, scoping such calls to impact resources related to a single end-user on your platform. You have three options available when enabling this option.

1. **Crossmint Authentication** - A quick-to-integrate auth solution, ideal for staging environments and getting started fast. Crossmint handles the generation of JWTs and you're able to quickly create a working application with user access controls. **For production, options 2 or 3 below are recommended.**
2. **Third Party Authentication providers** *(recommended for production)* - There are several quality authentication providers in the market and you may already be using one of them. You can continue to use your existing auth tooling and enable Crossmint Wallets on top of them with minimal changes. Supported providers include Auth0, Firebase, Supabase, Stytch, and Kinde.
3. **Custom JWT** *(recommended for production)* - This option is for providers not yet included with turn-key support or custom built solutions where you issue your own JWTs. You must be able to provide a JWKS endpoint to enable Crossmint to authenticate tokens.

<Tip>Crossmint's Wallets SDK ***requires*** JWT Authentication be enabled.</Tip>

## Crossmint Authentication

This option makes the most sense if you're getting started quickly and want to prototype or test in a staging environment. Crossmint Auth is great for demos and quickstarts, but for production applications a [third-party auth provider](/wallets/guides/bring-your-own-auth) or custom JWT is recommended for full control over your user management.

To use this option, select the Crossmint Auth option within the JWT Authentication section of the API keys page in the Developer Console.

<Frame type="simple">
  <img alt="select Crossmint Auth in Crossmint developer console" />
</Frame>

## Third Party Authentication

For projects that have already implemented authentication using one of the supported providers, you can provide Crossmint with the appropriate project/environment/app ID from the settings page of the third party. Supported providers include: Dynamic, Auth0, Stytch, Privy, Firebase, Kinde, and Supabase.

To use this option, select the 3P Auth providers option, then choose your provider from the dropdown. Next, you'll need to find the appropriate ID that your provider gives you to identify your project. This can typically be found within the settings pane of their web interface.

<Frame type="simple">
  <img alt="select third party Auth in Crossmint developer console" />
</Frame>

## Custom JWT Auth

If your project is using an auth provider not listed in the 3P providers list or is a home-grown JWT solution, you can choose the Custom tokens option. You will need to be able to provide a <Tooltip>JWKS endpoint</Tooltip> that Crossmint can use to authenticate the JWTs.

<Frame type="simple">
  <img alt="select third party Auth in Crossmint developer console" />
</Frame>

For a detailed guide on implementing this approach, check out the [Custom JWT Authentication Guide](/introduction/platform/api-keys/custom-jwt-auth-guide).


# Overview
Source: https://docs.crossmint.com/introduction/platform/api-keys/overview

Get your keys in seconds and start building

API keys are required to authorize requests against the Crossmint APIs. By using an API key, Crossmint knows which project is making the call, and can deduct credits from your balance.

## Staging vs. Production Keys

First, determine if you need a staging (testing) or production API key.

<CardGroup>
  <Card title="Staging API Keys" icon="flask-gear" href="https://staging.crossmint.com/console/projects/apiKeys">
    Generate API keys for testing in the staging developer console
  </Card>

  <Card title="Production API Keys" icon="bolt" href="https://www.crossmint.com/console/projects/apiKeys">
    Generate API keys for going live in the production developer console
  </Card>
</CardGroup>

## Server-side vs. Client-side Keys

Server-side API keys are used in server-to-server communications or in code running on a server. These keys are not exposed to the end users and can have broader permissions because they are considered more secure, being stored and used in controlled environments.

<Note>
  The majority of Crossmint APIs require a server-side API key. For a comprehensive list of APIs available refer to
  the [API Reference](/api-reference/introduction).
</Note>

Client-side API keys are used in code that runs on the client-side, such as in web browsers or mobile apps. These keys are exposed to the end user and are therefore less secure. They typically have more restrictive permissions to minimize security risks. When creating a client-side API key, you also need to configure authorized origins that are allowed to make calls to the endpoint.

<Check>
  Client-side keys are required for building with the [Wallets SDK](/sdk-reference/wallets/typescript/overview), Authentication, and [Headless Checkout](/payments/headless/overview).

  You can also perform some custodial wallet actions with these key types. Finally, the [Verifiable Credentials SDK](/verifiable-credentials/introduction) also offers some features via client-side keys.
</Check>

## More information

<CardGroup>
  <Card title="Rate Limits" icon="ruler" href="/introduction/platform/api-keys/rate-limits">
    Information about standard rate limits and exceptions
  </Card>

  <Card title="API Scopes" icon="bullseye" href="/introduction/platform/api-keys/scopes">
    Complete list of available API scopes
  </Card>

  <Card title="Server-side Keys" icon="server" href="/introduction/platform/api-keys/server-side">
    How to create and use server-side API keys
  </Card>

  <Card title="Client-side Keys" icon="browser" href="/introduction/platform/api-keys/client-side">
    How to create and use client-side API keys
  </Card>
</CardGroup>


# Rate Limits
Source: https://docs.crossmint.com/introduction/platform/api-keys/rate-limits

Understand the throughput available for API calls

Rate limits prevent individual users from clogging the network. If a limit is exceeded, Crossmint will respond with HTTP 429 and require a brief waiting period before making additional requests.

The rate limits on self-serve plans are the following:

<Check>To increase the base rate limits, [contact us](https://www.crossmint.com/contact/sales).</Check>

### Base Limits

| Method(s) | Rate Limit                          |
| :-------- | :---------------------------------- |
| POST      | 120 requests per minute per project |
| PUT       | Same as above                       |
| PATCH     | Same as above                       |
| DELETE    | Same as above                       |
| GET       | 360 requests per minute per project |

### Exceptions

| API                                                                      | Route                                                       | Method | Rate Limit          |
| :----------------------------------------------------------------------- | :---------------------------------------------------------- | :----- | :------------------ |
| [Mint NFT](/api-reference/minting/nfts/mint-nft)                         | /api/2022-06-09/collections/\{collectionId}/nfts            | POST   | 600 req/min/project |
| [Mint NFT (Idempotent)](/api-reference/minting/nfts/mint-nft-idempotent) | /api/2022-06-09/collections/\{collectionId}/nfts/\{nftName} | PUT    | 600 req/min/project |
| [Collection Info](/api-reference/minting/collection/get-collection)      | /api/2022-06-09/collections/\{collectionId}                 | GET    | 600 req/min/project |
| [Mint Status](/api-reference/minting/nfts/mint-status)                   | /api/2022-06-09/collections/\{collectionId}/nfts/\{id}      | GET    | 600 req/min/project |


# Scopes
Source: https://docs.crossmint.com/introduction/platform/api-keys/scopes

Enabling required permissions for API calls

Below is a complete list of the API scopes available. You can also find the scope a specific API requires in the [API Reference](/api-reference/introduction) section.

## Wallet APIs

| Scope                         | Description                                        | Server Key | Client Key |
| ----------------------------- | -------------------------------------------------- | ---------- | ---------- |
| `wallets.read`                | Retrieve all wallets for a user.                   | ✅          | ✅          |
| `wallets.create`              | Create a wallet for a user.                        | ✅          | ✅          |
| `wallets:nfts.read`           | Fetch the NFTs owned by a specific wallet address. | ✅          | ✅          |
| `wallets:balance.read`        | Get the balance of a specific wallet address.      | ✅          | ✅          |
| `wallets:transactions.create` | Create a transaction from a user's wallet.         | ✅          | ✅          |
| `wallets:transactions.sign`   | Sign a transaction from a user's wallet.           | ✅          | ✅          |
| `wallets:transactions.read`   | Read transactions from a user's wallet.            | ✅          | ✅          |
| `wallets:signatures.create`   | Create a signature for a wallet.                   | ✅          | ✅          |
| `wallets:signatures.read`     | Read a signature for a wallet.                     | ✅          | ✅          |
| `wallets.fund`                | Send funds to a wallet.                            | ✅          | ✅          |
| `wallets:nfts.transfer`       | Transfer an NFT from a user's wallet.              | ✅          |            |
| `wallets:messages.sign`       | Sign a message from a user's wallet.               | ✅          |            |

<Note>When using the [Wallets SDK](/sdk-reference/wallets/typescript/overview) you ***must*** use a client-side API key.</Note>

## Authentication

| Scope          | Description                           | Server Key | Client Key |
| -------------- | ------------------------------------- | ---------- | ---------- |
| `users.create` | Create users / allow them to sign up. |            | ✅          |
| `users.read`   | Get profile info for user accounts.   |            | ✅          |

## Tokenization (Minting) APIs

| Scope                          | Description                                                                | Server Key | Client Key |
| ------------------------------ | -------------------------------------------------------------------------- | ---------- | ---------- |
| `nfts.create`                  | Mint your NFTs and deliver them to a wallet or to an email address.        | ✅          |            |
| `nfts.update`                  | Update a minted NFT's metadata on IPFS (image, description, name...).      | ✅          |            |
| `nfts.read`                    | Retrieve all metadata for an NFT.                                          | ✅          |            |
| `nfts.delete`                  | Burn a specific NFT within a collection.                                   | ✅          |            |
| `nfts.transfer`                | Transfer an NFT to a different wallet.                                     | ✅          |            |
| `collections.create`           | Create a collection of NFTs.                                               | ✅          |            |
| `collections.update`           | Update information for an existing collection (image, name, royalties...). | ✅          |            |
| `collections.read`             | Retrieve the information about a specific collection.                      | ✅          |            |
| `credentials.read`             | Fetch credentials, some endpoints will only work with a server side key.   | ✅          | ✅          |
| `credentials.decrypt`          | Decrypt credentials, mainly used by our client side SDK.                   | ✅          | ✅          |
| `credentials:templates.create` | Create a template for your credentials.                                    | ✅          |            |
| `credentials.create`           | Issue your credentials and create credential types                         | ✅          |            |
| `credentials.delete`           | Revoke a credential issued to a subject.                                   | ✅          |            |

## Checkout APIs

| Scope           | Description                                     | Server Key | Client Key |
| --------------- | ----------------------------------------------- | ---------- | ---------- |
| `orders.create` | Create an order for headless checkout.          | ✅          | ✅          |
| `orders.read`   | Get an existing order for headless checkout.    | ✅          | ❌          |
| `orders.update` | Update an existing order for headless checkout. | ✅          | ❌          |

<Note>
  Client-side API keys only have access to the `orders.create` scope. When reading or updating order status from the
  client-side, you must pass the `clientSecret` returned in the create-order call as an `authorization` header for
  subsequent order operations (get-order, update-order). The `clientSecret` provides the authorization and an API Key
  is not required in this use case. See [this
  guide](/payments/headless/guides/client-or-server#client-side-example-code) in the Headless Checkout docs.
</Note>

## Project Administration

| Scope                 | Description                                       | Server Key | Client Key |
| --------------------- | ------------------------------------------------- | ---------- | ---------- |
| `billing.readonly`    | Get balance in credits for a project.             | ✅          |            |
| `projects:usage.read` | Get usage for the different products in a project | ✅          |            |


# Server-side Keys
Source: https://docs.crossmint.com/introduction/platform/api-keys/server-side

How to create and use server-side API keys

<Warning>
  **Server-side API keys must be stored securely!**

  Enable only the scopes you need, and no more, and do NOT expose your keys on the frontend of your app, or your github code repository.
</Warning>

## Create a Server-side Key

Navigate to the API Keys section of the developer console and click the "Create new key" button in the server-side keys section.

* [Staging API Keys](https://staging.crossmint.com/console/projects/apiKeys)
* [Production API Keys](https://www.crossmint.com/console/projects/apiKeys)

<Frame type="simple">
  <img alt="create server-side API key in Crossmint developer console" />
</Frame>

### Select Scopes

<Info>
  **Production server-side keys follow a "view once" policy**

  When you create a server-side API key in the production environment, the key secret will only be shown once during creation. After you close the dialog or navigate away, **you will not be able to view the key secret again.**
</Info>

Within the modal that opens, toggle the required scopes on and click the "Create server key" button at the bottom. You may need to expand an accordion for the product area you're working on to expose additional scope options.

<Frame type="simple">
  <img alt="select server-side API scopes in Crossmint developer console" />
</Frame>

You can determine the scopes you need by visiting the API reference page for the API(s) you need to interact with.

<CardGroup>
  <Card title="API Scopes" icon="bullseye" href="/introduction/platform/api-keys/scopes">
    Complete list of available API scopes
  </Card>

  <Card title="API Reference" icon="paper-plane" href="/api-reference/introduction">
    Detailed docs for all API endpoints
  </Card>
</CardGroup>

## Using a Server-side Key

If you're using the [API Playground](/api-reference) you can add your API key in the Authorization section and this will set it as a header when making the request.

<Frame type="simple">
  <img alt="Set x-api-key screenshot" />

  <img alt="Set x-api-key screenshot" />
</Frame>

When calling the APIs from server-side code, you set the `X-API-KEY` header however the target language or library expects it. See some examples below:

<CodeGroup>
  ```bash cURL theme={null}
  curl --request POST \
    --url https://staging.crossmint.com/api/v1-alpha1/wallets \
    --header 'Content-Type: application/json' \
    --header 'X-API-KEY: YOUR_API_KEY' \
    --data '{
    "email": "test@test.com",
    "chain": "polygon-amoy"
  }'
  ```

  ```javascript JavaScript theme={null}
  const options = {
    method: 'POST',
    headers: {
      'X-API-KEY': 'YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: '{
      "email":"test@test.com",
      "chain":"polygon-amoy"
    }'
  };

  fetch('https://staging.crossmint.com/api/v1-alpha1/wallets', options)
    .then(response => response.json())
    .then(response => console.log(response))
    .catch(err => console.error(err));
  ```
</CodeGroup>

All of the API routes in the [API Reference](/api-reference/introduction) include code examples for many popular programming languages.


# Project and Team Management
Source: https://docs.crossmint.com/introduction/platform/projects-and-user-management

Manage your projects and their members

<Tabs>
  <Tab title="Projects">
    ## Managing Projects

    A project is a group of token collections, user wallets, API keys, billing information, and more.

    If you are working with different teams or clients, you can create different projects to seggregate sensitive information and tool access. Alternatively, you can issue different API keys within the same project, but bear in mind they will share the same billing account.

    Every developer account automatically includes a project named `Default Project`. You can create new projects and alternate between them using the selector within the console, as illustrated in the screenshot below.

    <Frame type="simple">
      <img alt="Crossmint developer console overview map" />
    </Frame>

    ## Privacy Policy

    Projects have an option to register a link to your company's privacy policy. If set, this link will be shown to your users when they're using any Crossmint-managed user interface, such as the Checkout, where user information is collected. A privacy policy is required by law if you want to later those users' personally identifiable information, such as their email address.

    If you don't already have a privacy policy, you can generate and host one using tools like [Termly](https://termly.io/).

    > **Note:** Failure to add a privacy policy will result in email addresses being hidden.

    #### Cases Requiring a Privacy Policy to Access User Data

    | Use Case                     | Privacy Policy Required |
    | ---------------------------- | ----------------------- |
    | Payments (payment button)    | Yes                     |
    | Payments (embedded checkout) | Yes                     |
    | Payments (headless checkout) | No                      |
    | Mint API or console          | No                      |
    | Wallet APIs or console       | No                      |

    ### Steps to Add a Privacy Policy Link

    1. \**Go to the General Settings tab*

       * Access the Settings page from the sidear.

    2. **Include the Privacy Policy Link**

    <Frame type="simple">
      <img alt="Include Privacy Policy link" />
    </Frame>

    * In the project settings, locate the section for adding a privacy policy.
    * Paste the URL of your privacy policy generated from Termly or any other source.

    4. **Verify Email Visibility**
       * After adding the privacy policy link, check to ensure that email addresses are now visible.
       * If the link is not included, emails will remain hidden to protect user data.

    Following these steps will ensure compliance with data protection laws and enable the visibility of email addresses in your project settings.

    ***

    ## FAQs

    <AccordionGroup>
      <Accordion title="Why does Crossmint require my project's privacy policy?">
        Crossmint requires your project's privacy policy to comply with data protection laws and ensure the privacy and
        security of user data. Without it, email addresses and other sensitive information will be hidden.
      </Accordion>

      <Accordion title="I have already configured the privacy policy URL, why can't I see the user identifier of some users?">
        Older users who joined before the privacy policy was added haven't accepted the new policy. Therefore, their
        identifiers remain hidden.
      </Accordion>

      <Accordion title="Why can't I delete the privacy policy of my project?">
        Deleting the privacy policy is restricted to ensure compliance with data protection laws and maintain user
        privacy and security.
      </Accordion>
    </AccordionGroup>
  </Tab>

  <Tab title="Team Members">
    Projects can be shared across multiple team members. You can add new members from the Members tab on the console. All members get the same permissions, except for the ability to delete other members, which only belongs to the creator of the project.

    <Note>In order to invite a member to a project, they must already have a Crossmint account within that same environment.</Note>

    <Check>If you need to remove a team member, <a href="https://help.crossmint.com/hc/en-us/requests/new">submit a ticket with Crossmint support</a>.</Check>
  </Tab>
</Tabs>


# Staging vs Production Environments
Source: https://docs.crossmint.com/introduction/platform/staging-vs-production



Crossmint's console and first-party wallet operate in two different environments:

* **Staging:** free, for testing.
* **Production:** for your live projects. Blockchain operations incur credit costs.

You may access them from [https://staging.crossmint.com](https://staging.crossmint.com), and [https://www.crossmint.com](https://www.crossmint.com).

<Tip>Staging provides free self-serve access to most functionality.</Tip>

## Differences between the Environments

|              | **Staging**                                                    | **Production**                                         |
| ------------ | -------------------------------------------------------------- | ------------------------------------------------------ |
| URL          | [https://staging.crossmint.com](https://staging.crossmint.com) | [https://www.crossmint.com](https://www.crossmint.com) |
| Payments     | Test credit cards                                              | Accepts real credit cards                              |
| API Credits  | Free to test (no API credits required)                         | API credits required for some endpoints                |
| Verification | Checkout does not require KYC or collection verification       | Checkout requires KYC and collection verification      |
| Blockchains  | Testnets like Sepolia, and Amoy                                | Mainnets                                               |

## FAQ

<AccordionGroup>
  <Accordion title="Does staging activity appear in the production account, and viceversa?">
    No, collections created in one environment will not appear in the other.

    Typically, you would start developing your project in staging, and replicate and launch in production when you feel ready.
  </Accordion>
</AccordionGroup>


# Add an Endpoint
Source: https://docs.crossmint.com/introduction/platform/webhooks/add-endpoint

Configure an endpoint to receive webhook messages.

To add an endpoint, provide a URL you control and select the event types you want to listen to.

1. Navigate to the Webhooks page in the console.
2. Click **Add Endpoint**.
3. Provide the URL where you want to receive messages.
4. Select the event types you want to listen to.
5. Click **Create**.

<img alt="Add an endpoint" />

### FAQs

<AccordionGroup>
  <Accordion title="What types of events can I subscribe to with webhooks?">
    There are many events available to subscribe to from all our products. Some examples include:

    * Collection creation
    * NFT minting
    * NFT edits
    * Transaction confirmations
    * Transaction failures

    You can see the full list of events in the Crossmint Console, under Integrate > Webhooks and the **Event Catalog** tab.
  </Accordion>

  <Accordion title="How can I verify that a webhook request is legitimate?">
    To verify a webhook request is legitimate, you need to verify the signature and timestamp. You can learn more about it in the [Verify webhooks](/introduction/platform/webhooks/verify-webhooks) section.
  </Accordion>

  <Accordion title="How do I handle webhook retries?">
    Crossmint automatically retries webhooks if your endpoint doesn't acknowledge its receipt, or throws an error. We will attempt to deliver the webhook 8 times:

    * Immediately
    * 5 seconds
    * 5 minutes
    * 30 minutes
    * 2 hours
    * 5 hours
    * 10 hours
    * 10 hours (in addition to the previous)

    If, after these attempts, we're unable to deliver the message, we will mark it as failed. Inside the Webhooks page, you can manually resend the webhook.

    <img alt="Resend a webhook" />
  </Accordion>

  <Accordion title="What HTTP response code should my webhook endpoint return?">
    To indicate that a webhook has been processed, return a 2xx (status code 200-299) response to the webhook message within a 15 seconds timeframe.
  </Accordion>

  <Accordion title="Why are my webhooks failing?">
    Some typical reasons why webhooks fail are:

    * Check that the enpdpoint URL is correct and that it's expecting a POST request
    * Check that the endpoint is reachable from the public internet. Make sure that CSRF protection is disabled for this endpoint.
    * Check that the endpoint is returning a 2xx response code
    * Check that the payload signature and timestamp are verified correctly. Remember not to modify the body string of the webhook before processing it.
  </Accordion>
</AccordionGroup>


# Best Practices
Source: https://docs.crossmint.com/introduction/platform/webhooks/best-practices

Best practices for implementing reliable webhook handlers

Follow these best practices to ensure your webhook implementation is reliable, secure, and performant.

## Idempotency

Crossmint webhooks follow an at-least-once delivery guarantee. Duplicate deliveries can occur (for example, if a previous attempt didn't receive a 2xx response quickly enough). Implement idempotency by:

1. Using the webhook `id` field as a unique identifier
2. Storing processed webhook IDs in your database
3. Checking if a webhook has already been processed before taking action

> **Note:** The following code examples are pseudocode for illustration purposes.

```javascript theme={null}
async function handleWebhook(webhookId, data) {
  // Check if we've already processed this webhook
  const existing = await db.webhooks.findOne({ id: webhookId });
  if (existing) {
    console.log('Webhook already processed:', webhookId);
    return;
  }
  
  // Process the webhook
  await processWebhook(data);
  
  // Mark as processed
  await db.webhooks.create({ id: webhookId, processedAt: new Date() });
}
```

## Response Time

Your webhook endpoint must respond within 15 seconds, otherwise the webhook will be resent. For long-running operations:

<Important>
  If your endpoint doesn't return a 2xx status code within 15 seconds, the delivery attempt is marked as failed and Crossmint will automatically retry with exponential backoff. This can result in duplicate deliveries (at-least-once semantics). After repeated failures, the message is marked as undeliverable and you can manually trigger redelivery from the Console. See [Add an Endpoint](/introduction/platform/webhooks/add-endpoint) for the full retry schedule.
</Important>

1. Immediately acknowledge the webhook with a 200 response
2. Queue the processing work for asynchronous execution
3. Process the webhook data in a background job

> **Note:** The following code examples are pseudocode for illustration purposes.

```javascript theme={null}
app.post('/webhooks/your-endpoint', async (req, res) => {
  // Verify signature first
  const payload = verifyWebhook(req);
  
  // Immediately acknowledge receipt
  res.status(200).json({ received: true });
  
  // Queue for background processing
  await jobQueue.add('process-webhook', {
    webhookId: payload.id,
    type: payload.type,
    data: payload.data,
  });
});
```

## Error Handling

Implement proper error handling to ensure reliable webhook delivery:

* **Return 2xx within 15 seconds** after verifying the signature to acknowledge receipt
* **Return 400** for invalid signatures to reject the webhook
* **Return 5xx** for transient internal errors to trigger automatic retries

See [Verify Webhooks](/introduction/platform/webhooks/verify-webhooks) for more details on signature verification and error handling.

## Signature Verification

Always verify webhook signatures to ensure requests are legitimate and come from Crossmint. Never process webhooks without verifying their signatures first.

See [Verify Webhooks](/introduction/platform/webhooks/verify-webhooks) for detailed instructions on signature verification.

## Related Resources

* [Add an Endpoint](/introduction/platform/webhooks/add-endpoint) - Configure webhook endpoints
* [Verify Webhooks](/introduction/platform/webhooks/verify-webhooks) - Verify webhook signatures
* [Overview](/introduction/platform/webhooks/overview) - Learn about webhooks


# Overview
Source: https://docs.crossmint.com/introduction/platform/webhooks/overview

Listen for events across wallets, payments, minting, and credentials to automatically trigger reactions in your application

Crossmint's platform operations—including wallet transactions, payment processing, NFT minting, and credential issuance—often require blockchain interactions or other asynchronous processing. These operations can take anywhere from a few seconds to several minutes depending on network conditions. Webhooks allow you to listen for events across Crossmint's platform and automatically trigger reactions in your application when these operations complete.

Some cases where you may want to listen for event notifications include:

* **Wallet operations**: Track transfer approvals, transaction completions, or failures
* **Payment processing**: Monitor checkout lifecycle from quote creation to delivery completion
* **Minting operations**: Get notified when mints succeed, collections are created, or tokens are transferred
* **Credential issuance**: Receive updates when verifiable credentials are successfully issued
* **Database updates**: Automatically update your records with transaction IDs, token details, or user information
* **Customer notifications**: Send emails or push notifications when operations complete

Webhooks are how services notify each other of events. At their core, they are simply POST requests to a pre-determined endpoint. The endpoint can be any URL you choose, and you can [add them from the console](/introduction/platform/webhooks/add-endpoint).

<Tip>Your server must return a 2xx HTTP status quickly so the webhook is marked as delivered.</Tip>

## Next Steps

* [Add an Endpoint](/introduction/platform/webhooks/add-endpoint) - Configure your webhook endpoint
* [Verify Webhooks](/introduction/platform/webhooks/verify-webhooks) - Learn how to verify webhook signatures
* [Best Practices](/introduction/platform/webhooks/best-practices) - Implement reliable webhook handlers


# Verify Webhooks
Source: https://docs.crossmint.com/introduction/platform/webhooks/verify-webhooks

Verify the signature and timestamp when processing webhooks

Because of the way webhooks work, attackers can impersonate services by simply sending a fake webhook to an endpoint. Think about it: it’s just an HTTP POST from an unknown source. This can create a potential security vulnerability for many applications, or at the very least, a source of errors.

To prevent this, Crossmint signs every webhook and its metadata with a unique key for each endpoint. Use this signature to verify that the webhook indeed comes from Crossmint, and process it only if it does.

You can get the signing key secret from the Webhooks page in the console. To find it, go to the endpoint details and look for the Signing Secret section.

<img alt="Signing Secret" />

<Tabs>
  <Tab title="Using a library">
    We are going to use the Svix open-source library to verify webhooks. First, install the relevant libraries for your language:

    <CodeGroup>
      ```js Javascript theme={null}
      npm install svix
      // Or
      yarn add svix
      ```

      ```py Python theme={null}
      pip install svix
      ```

      ```rust Rust theme={null}
      http = "1.0.0"
      svix = "1.20.0"
      ```

      ```go Go theme={null}
      go get github.com/svix/svix-webhooks/go
      ```

      ```java Java theme={null}
      // Gradle: Add this dependency to your project's build file:
      implementation "com.svix:svix:0.x.y"

      // Maven: Add this dependency to your project's POM file:
      <dependency>
      <groupId>com.svix</groupId>
      <artifactId>svix</artifactId>
      <version>0.x.y</version>
      </dependency>
      ```

      ```kotlin Kotlin theme={null}
      // Gradle: Add this dependency to your project's build file:
      implementation "com.svix.kotlin:svix-kotlin:0.x.y"

      // Maven: Add this dependency to your project's POM file:
      <dependency>
      <groupId>com.svix.kotlin</groupId>
      <artifactId>svix-kotlin</artifactId>
      <version>0.x.y</version>
      </dependency>
      ```

      ```ruby Ruby theme={null}
      gem install svix
      ```

      ```csharp C# theme={null}
      dotnet add package Svix
      ```

      ```php PHP theme={null}
      composer require svix/svix
      ```

      ```bash CLI theme={null}
      # On macOS install via Homebrew:
      brew install svix/svix/svix

      # On Linux install via Scoop:
      scoop bucket add svix https://github.com/svix/scoop-svix.git
      scoop install svix
      ```
    </CodeGroup>

    Next, verify webhooks using the code below. The payload is the raw (string) body of the request, and the headers are the headers passed in the request.

    <Warning>
      You need to use the **raw request body** when verifying webhooks, as the cryptographic signature is sensitive to even the slightest changes. Watch out for frameworks that parse the request as JSON and then stringify it, as this will break the signature verification.

      See examples below for how to get the raw request body with different frameworks.
    </Warning>

    Remember to get the signature secret from the endpoint details in the console.

    <CodeGroup>
      ```js Javascript theme={null}
      import { Webhook } from "svix";

      const secret = "whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw";

      // These were all sent from the server
      const headers = {
      "svix-id": "msg_p5jXN8AQM9LWM0D4loKWxJek",
      "svix-timestamp": "1614265330",
      "svix-signature": "v1,g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE=",
      };
      const payload = '{"test": 2432232314}';

      const wh = new Webhook(secret);
      // Throws on error, returns the verified content on success
      const payload = wh.verify(payload, headers);
      ```

      ```py Python theme={null}
      from svix.webhooks import Webhook

      secret = "whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw"

      # These were all sent from the server
      headers = {
      "svix-id": "msg_p5jXN8AQM9LWM0D4loKWxJek",
      "svix-timestamp": "1614265330",
      "svix-signature": "v1,g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE=",
      }
      payload = '{"test": 2432232314}'

      wh = Webhook(secret)
      # Throws on error, returns the verified content on success
      payload = wh.verify(payload, headers)
      ```

      ```rust Rust theme={null}
      use svix::webhooks::Webhook;

      let secret = "whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw".to_string();

      let mut headers = http::HeaderMap::new();
      headers.insert("svix-id", "msg_p5jXN8AQM9LWM0D4loKWxJek");
      headers.insert("svix-timestamp", "1614265330");
      headers.insert(
          "svix-signature",
          "v1,g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE=",
      );

      let payload = b"{\"test\": 2432232314}";

      let wh = Webhook::new(&secret)?;
      wh.verify(&payload, &headers)?;
      // returns Ok on success, Err otherwise
      ```

      ```go Go theme={null}
      import (
          svix "github.com/svix/svix-webhooks/go"
      )

      secret := "whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw"

      // These were all sent from the server
      headers := http.Header{}
      headers.Set("svix-id", "msg_p5jXN8AQM9LWM0D4loKWxJek")
      headers.Set("svix-timestamp", "1614265330")
      headers.Set("svix-signature", "v1,g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE=")

      payload := []byte(`{"test": 2432232314}`)

      wh, err := svix.NewWebhook(secret)
      err := wh.Verify(payload, headers)
      // returns nil on success, error otherwise
      ```

      ```java Java theme={null}
      import com.svix.Webhook;

      String secret = "whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw";

      // These were all sent from the server
      HashMap<String, List<String>> headerMap = new HashMap<String, List<String>>();
      headerMap.put("svix-id", Arrays.asList("msg_p5jXN8AQM9LWM0D4loKWxJek"));
      headerMap.put("svix-timestamp", Arrays.asList("1614265330"));
      headerMap.put("svix-signature", Arrays.asList("v1,g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE="));
      HttpHeaders headers = HttpHeaders.of(headerMap, BiPredicate<String, String>)

      String payload = "{\"test\": 2432232314}";

      Webhook webhook = new Webhook(secret);

      webhook.verify(payload, headers)
      // throws WebhookVerificationError exception on failure.
      ```

      ```kotlin Kotlin theme={null}
      import com.svix.kotlin.Webhook

      val secret = "whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw";

      // These were all sent from the server
      val headersMap = mapOf(
          "svix-id" to listOf("msg_p5jXN8AQM9LWM0D4loKWxJek"),
          "svix-timestamp" to listOf("1614265330"),
          "svix-signature" to listOf("v1,g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE=")
      )
      val headers = HttpHeaders.of(headersMap) { _, _ -> true }

      val payload = "{\"test\": 2432232314}";

      val webhook = Webhook(secret);

      webhook.verify(payload, headers)
      // throws WebhookVerificationError exception on failure.
      ```

      ```ruby Ruby theme={null}
      require 'svix'


      # These were all sent from the server
      headers = {
      "svix-id" => "msg_p5jXN8AQM9LWM0D4loKWxJek",
      "svix-timestamp" => "1614265330",
      "svix-signature" => "v1,g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE="
      }
      payload = '{"test": 2432232314}'

      wh = Svix::Webhook.new("whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw")
      # Raises on error, returns the verified content on success
      json = wh.verify(payload, headers)
      ```

      ```csharp C# theme={null}
      using Svix;
      using System.Net;

      // These were all sent from the server
      var headers = new WebHeaderCollection();
      headers.Set("svix-id", "msg_p5jXN8AQM9LWM0D4loKWxJek");
      headers.Set("svix-timestamp", "1614265330");
      headers.Set("svix-signature", "v1,g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE=");
      var payload = "{\"test\": 2432232314}";

      var wh = new Webhook("whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw/Je4ZJEGP1QFb");

      // Throws on error
      wh.Verify(payload, headers);
      ```

      ```php PHP theme={null}
      // import using composers autoload
      require_once('vendor/autoload.php');
      // or manually
      require_once('/path/to/svix/php/init.php');

      // These were all sent from the server
      $payload = '{"test": 2432232314}';
      $header = array(
              'svix-id'  => 'msg_p5jXN8AQM9LWM0D4loKWxJek',
              'svix-timestamp' => '1614265330',
              'svix-signature' => 'v1,g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE=',
          );

      // Throws on error, returns the verified content on success
      $wh = new \Svix\Webhook('whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw');
      $json = $wh->verify($payload, $header);
      ```

      ```bash CLI theme={null}
      export SVIX_AUTH_TOKEN="AUTH_TOKEN"
      svix verify --secret whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw --msg-id msg_p5jXN8AQM9LWM0D4loKWxJek --timestamp 1614265330 --signature v1,g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE= '{"test": 2432232314}'
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Manual verification">
    <Note>
      This is a manual verification process. We recommend using a library to verify webhooks automatically.
    </Note>

    If you need to verify manually, follow these instructions.

    Each webhook call includes three headers with additional information that are used for verification:

    * `svix-id`: The unique message identifier for the webhook message. This identifier is unique across all messages, but will be the same when the same webhook is resent (e.g., due to a previous failure).
    * `svix-timestamp`: Timestamp in seconds since epoch.
    * `svix-signature`: The Base64 encoded list of signatures (space delimited).

    ### Constructing the Signed Content

    The content to sign is composed by concatenating the ID, timestamp, and payload, separated by the full-stop character (`.`). In code, it will look something like this:

    ```js theme={null}
    const signedContent = `${svix_id}.${svix_timestamp}.${body}`;
    ```

    Where `body` is the raw body of the request. The signature is sensitive to any changes, so even a small change in the body will cause the signature to be completely different. This means that you should not change the body in any way before verifying.

    <Warning>
      Ensure you use the **raw request body** for verification. Parsing and re-stringifying JSON will alter the content and cause verification failure.
    </Warning>

    ### Determining the Expected Signature

    We use HMAC with SHA-256 to sign webhooks.

    To calculate the expected signature, HMAC the `signedContent` from above using the base64 portion of your signing secret (this is the part after the `whsec_` prefix) as the key. For example, if your secret is `whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw`, use `MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw`.

    For example, this is how you can calculate the signature in Node.js:

    ```js theme={null}
    const crypto = require('crypto');

    const signedContent = `${svix_id}.${svix_timestamp}.${body}`;
    const secret = "whsec_5WbX5kEWLlfzsGNjH64I8lOOqUB6e8FH";

    // Need to base64 decode the secret
    const secretBytes = Buffer.from(secret.split('_')[1], "base64");
    const signature = crypto
    .createHmac('sha256', secretBytes)
    .update(signedContent)
    .digest('base64');

    console.log(signature);
    ```

    This generated signature should match one of the ones sent in the `svix-signature` header.

    The `svix-signature` header is a list of space-delimited signatures with version identifiers. The list is typically one item but can contain multiple signatures, like this:

    ```
    v1,g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE= v1,bm9ldHUjKzFob2VudXRob2VodWUzMjRvdWVvdW9ldQo= v2,MzJsNDk4MzI0K2VvdSMjMTEjQEBAQDEyMzMzMzEyMwo=
    ```

    Make sure to remove the version prefix and delimiter (e.g. `v1,`) before verifying the signature.

    Please note that to compare the signatures it's recommended to use a constant-time string comparison method in order to prevent timing attacks.

    ### Verify timestamp

    We include the timestamp of the attempt in the `svix-timestamp` header. Compare this timestamp against your system timestamp to ensure it’s within an acceptable tolerance to prevent replay attacks.
  </Tab>
</Tabs>


# Supported Chains
Source: https://docs.crossmint.com/introduction/supported-chains

Tap into 50+ blockchains in one single integration

Refer to the table below to see which chains are supported for which product categories.

| Blockchain        | Wallets | Checkout | Onramp | Tokenization |    Mainnet Label   |        Testnet Label       |
| :---------------- | :-----: | :------: | :----: | :----------: | :----------------: | :------------------------: |
| Apex              |    -    |     ✅    |    ✅   |       -      |       `apex`       |              -             |
| Abstract          |    ✱    |     ✅    |    ✱   |       ✱      |     `abstract`     |     `abstract-testnet`     |
| Atleta            |    ✱    |     ✅    |    ✅   |       ✅      |      `atleta`      |      `atleta-testnet`      |
| ApeChain          |    ✅    |     ✅    |    ✅   |       ✅      |     `apechain`     |          `curtis`          |
| Arc               |    ✅    |     ✱    |    ✱   |       ✱      |        `arc`       |        `arc-testnet`       |
| Aptos             |    ✱    |     ✱    |    ✱   |       ✅      |       `aptos`      |           `aptos`          |
| Arbitrum One      |    ✅    |     ✅    |    ✅   |       ✅      |     `arbitrum`     |     `arbitrum-sepolia`     |
| Arbitrum Nova     |    ✅    |     ✅    |    ✅   |       ✅      |   `arbitrumnova`   |     `arbitrum-sepolia`     |
| Astar             |    ✱    |     ✅    |    ✅   |       ✅      |    `astar-zkevm`   |          `zkyoto`          |
| Avalanche         |    ✱    |     ✅    |    ✅   |       ✅      |     `avalanche`    |      `avalanche-fuji`      |
| Avalanche Subnets |    ✱    |     ✱    |    ✱   |       ✱      | `avalanche-subnet` | `avalanche-subnet-testnet` |
| Base              |    ✅    |     ✅    |    ✅   |       ✅      |       `base`       |       `base-sepolia`       |
| BSC               |    ✅    |     ✱    |    ✱   |       ✱      |        `bsc`       |        `bsc-testnet`       |
| Chiliz            |    ✱    |     ✅    |    ✅   |       ✅      |      `chiliz`      |   `chiliz-spicy-testnet`   |
| Coti              |    ✱    |     ✅    |    ✅   |       ✅      |       `coti`       |       `coti-testnet`       |
| Ethereum          |    ✱    |     ✅    |    ✅   |       ✱      |     `ethereum`     |     `ethereum-sepolia`     |
| Flow              |    ✱    |     ✅    |    ✱   |       ✅      |       `flow`       |       `flow-testnet`       |
| Hedera EVM        |    ✱    |     ✅    |    ✅   |       ✅      |      `hedera`      |      `hedera-testnet`      |
| Mantle            |    ✅    |     ✅    |    ✅   |       ✅      |      `mantle`      |      `mantle-testnet`      |
| Mode              |    ✅    |     ✅    |    ✅   |       ✅      |       `mode`       |       `mode-sepolia`       |
| Monad             |    ✱    |     ✱    |    ✱   |       ✱      |       `monad`      |       `monad-testnet`      |
| Optimism          |    ✅    |     ✅    |    ✅   |       ✅      |     `optimism`     |     `optimism-sepolia`     |
| Polygon           |    ✅    |     ✅    |    ✅   |       ✅      |      `polygon`     |       `polygon-amoy`       |
| Rari              |    ✱    |     ✅    |    ✅   |       ✅      |       `rari`       |       `rari-testnet`       |
| Sei               |    ✅    |     ✅    |    ✅   |       ✅      |   `sei-pacific-1`  |  `sei-atlantic-2-testnet`  |
| Scroll            |    ✅    |     ✅    |    ✅   |       ✅      |      `scroll`      |      `scroll-sepolia`      |
| Solana            |    ✅    |     ✅    |    ✅   |       ✅      |      `solana`      |          `solana`          |
| Stellar           |    ✅    |     ✱    |    ✅   |       ✱      |      `stellar`     |      `stellar-testnet`     |
| Shape             |    ✅    |     ✅    |    ✅   |       ✅      |       `shape`      |       `shape-sepolia`      |
| SKALE             |    ✱    |     ✅    |    ✅   |       ✅      |   `skale-nebula`   |   `skale-nebula-testnet`   |
| Soneium           |    ✱    |     ✅    |    ✅   |       ✅      |      `soneium`     |  `soneium-minato-testnet`  |
| Story             |    ✅    |     ✱    |    ✱   |       ✅      |   `story-mainnet`  |       `story-testnet`      |
| Sui               |    ✱    |     ✱    |    ✱   |       ✅      |        `sui`       |              -             |
| Tempo             |    ✅    |     ✱    |    ✱   |       ✱      |          -         |       `tempo-testnet`      |
| U2U               |    ✱    |     ✅    |    ✅   |       ✅      |    `u2u-solaris`   |        `u2u-nebulas`       |
| Xion              |    ✱    |     ✅    |    ✅   |       ✅      |       `xion`       |       `xion-testnet`       |
| Xai               |    ✱    |     ✅    |    ✅   |       ✅      |        `xai`       |    `xai-sepolia-testnet`   |
| Zenchain          |    ✱    |     ✅    |    ✅   |       ✅      |     `zenchain`     |     `zenchain-testnet`     |
| Zora              |    ✅    |     ✅    |    ✅   |       ✅      |       `zora`       |       `zora-sepolia`       |
| Other EVM chains  |    ✱    |     ✱    |    ✱   |       ✱      |                    |                            |

**Legend:**

* `✅` Supported
* `✱` Available, but not self-serve. [Contact us](https://www.crossmint.com/contact/sales) to request it for your project.
* `-` Not supported

Notes:

* Fungible token checkout available self service only in Solana. [Contact us](https://www.crossmint.com/contact/sales) for other chains.

<Card title="Building on a different chain?" icon="comment" href="https://www.crossmint.com/contact/sales">
  Contact us. We launch new chains regularly and yours is likely in the pipeline.
</Card>

## Testnets

You can access testnets by using the [staging console](https://staging.crossmint.com/console). Read more about the different environments [here](/introduction/platform/staging-vs-production).

Please refer to the supported chains table above for details about which testnet the staging environment targets. If there is not a specific testnet listed for a chain it is not supported in staging.


# Overview
Source: https://docs.crossmint.com/minting/introduction

Mint and distribute tokens at scale, reliably

**It takes months to build secure and reliable minting infrastructure:**

1. Write and maintain token smart contracts
2. Build a backend for orchestrating all blockchain transactions
3. Securely administer keys and crypto balances to pay for gas fees
4. Add queueing, batching, RPC redundancy, priority gas fee estimations, and e2e observability

**Crossmint manages all of this for you via a suite of APIs to create, update, delete and manage tokens of any type through REST APIs, available on any chain.**

## Key Characteristics

<CardGroup>
  <Card title="Get started in 5 minutes" icon="bolt">
    Simple APIs to help you launch faster.
  </Card>

  <Card title="No blockchain experience required" icon="lightbulb">
    Forget about smart contracts, IPFS, wallets, and admin key management.
  </Card>

  <Card title="Modular platform" icon="unlock-keyhole">
    Let Crossmint handle all the infrastructure, or combine it with your own.
  </Card>
</CardGroup>

<CardGroup>
  <Card title="Best-in-class security" icon="shield">
    SOC-II certified with audited smart contracts.
  </Card>

  <Card title="Ready to scale" icon="gauge-high">
    Handle millions of tokens an hour and save on customer support.
  </Card>

  <Card title="Multi-chain" icon="wand-magic-sparkles">
    Tap into 50+ chains with one single integration.
  </Card>
</CardGroup>

## Quickstarts

<CardGroup>
  <Card title="Non-Fungible Tokens (NFTs)" icon="bolt" href="/minting/quickstarts/nfts">
    Mint and verify unique digital assets you can own, transfer, and verify in under minutes.
  </Card>

  <Card title="Semi-Fungible Tokens (SFTs)" icon="bolt" href="/minting/quickstarts/sfts">
    Mint limited sets of identical digital assets in under 5 minutes.
  </Card>
</CardGroup>

<CardGroup>
  <Card title="Verifiable Credentials (VCs)" icon="bolt" href="/minting/quickstarts/credentials">
    Mint credentials that users control, share, and verify anywhere in under 5 minutes.
  </Card>

  <Card title="Intellectual Property (IP)" icon="bolt" href="/minting/quickstarts/ip">
    Mint IP credentials for creators to secure their work, in under 5 minutes.
  </Card>
</CardGroup>

## Get Started

<CardGroup>
  <Card title="Console" icon="table-columns" href="https://www.crossmint.com/console">
    Get API keys and manage collections.
  </Card>

  <Card title="API Reference" icon="terminal" href="/api-reference/minting/nfts/mint-nft">
    Test any API in seconds directly from the docs.
  </Card>

  <Card title="Talk to an expert" icon="message" href="https://www.crossmint.com/contact/sales">
    Contact our sales team for advanced support.
  </Card>
</CardGroup>

## FAQs

<AccordionGroup>
  <Accordion title="Is there vendor lock-in?">
    No, you can migrate providers anytime, transfering ownership of the smart contracts to an external wallet.
  </Accordion>

  <Accordion title="Can I transfer ownership of the smart contract to an external wallet?">
    Yes, you can transfer ownership at any time. However, note that Crossmint APIs (eg. minting, editing NFTs) may
    stop working on that contract unless you whitelist Crossmint on the contract to continue executing those
    actions. If you transfer ownership of the contract to your own wallet, you are responsible for ensuring the
    security of that wallet.
  </Accordion>

  <Accordion title="How does Crossmint manage billing?">
    When you create an account, Crossmint automatically creates a gas station to manage network fees on your behalf. You will be billed in fiat and Crossmint will ensure you never run out of funds to support customer operations. This eliminates the need to build a cryptoaccounting system, execute recurring and expensive crypto purchases, holding the FX risk, and automating treasury operations.
  </Accordion>

  <Accordion title="How does Crossmint manage minting keys?">
    When you create an account, Crossmint will automatically create a dedicated MPC vault to secure your token contracts which you can manage via API. You get one vault per <Tooltip>project</Tooltip>, in case you are working with multiple teams. You can <Tooltip>transfer ownership</Tooltip> of the contracts to an external wallet at any time.
  </Accordion>
</AccordionGroup>


# Bring Your Own Contract
Source: https://docs.crossmint.com/minting/nfts/integrate/bring-your-own-contract

Use Crossmint's infrastructure with your own smart contract

Crossmint allows you to use your own smart contract while leveraging our infrastructure for minting NFTs. This guide will walk you through the process of integrating your custom smart contract with Crossmint.

## Prerequisites

Before you can use your own smart contract with Crossmint, ensure that:

1. Your smart contract has a **free minting function** that allows Crossmint to mint NFTs without paying any fees.
2. Your smart contract complies with the **ERC721 standard** (for NFTs) or **ERC1155 standard** (for SFTs).

<Warning>
  Currently, this feature is only available for EVM chains. Support for Solana and other chains is coming soon.
</Warning>

## Integration Guide

### 1. Register Your Smart Contract

First, you need to register your smart contract at the Crossmint Console:

1. Navigate to **Token collections** > **New Collection**
2. Enter the required collection information
3. Select **Import an existing contract**
4. Pick the chain, provide the contract address, and fill in the necessary information (i.e. ABI, mint function)
5. Keep track of the Crossmint collection ID generated for future mint calls

### 2. Contract Review

After registering your contract, the Crossmint team will review it to ensure compatibility with our infrastructure. This typically takes 1-2 business days.

<Note>
  During the review process, we'll verify that your contract has the necessary free minting function and complies with
  the required standards.
</Note>

### 3. Mint NFTs

Once your contract is approved, you can start minting NFTs using Crossmint's [Mint API](/api-reference/minting/nfts/mint-nft) and passing the following:

1. `recipient`, which is the recipient's wallet/email/X account user locators
2. `contractArguments`, which is an object where the keys are the argument names from the mint function, and the values are their values. Omit the recipient argument from this object

```bash cURL theme={null}
curl --request POST \
  --url https://staging.crossmint.com/api/2022-06-09/collections/{collectionId}/nfts \
  --header 'Content-Type: application/json' \
  --header 'X-API-KEY: <api-key>' \
  --data '{
  "recipient": "polygon-amoy:0x123...",
  "contractArguments": {
    "tokenId": "42"
  }
}'
```

## Best Practices

When using your own smart contract with Crossmint:

1. **Test Thoroughly**: Test your contract integration in the staging environment before moving to production.
2. **Function Visibility**: Ensure your minting function has the appropriate visibility and access controls.
3. **Gas Optimization**: Optimize your contract to minimize gas costs for minting operations.
4. **Error Handling**: Implement proper error handling in your contract to provide meaningful error messages.

## FAQs

<AccordionGroup>
  <Accordion title="Can I use an existing deployed contract?">
    Yes, you can use an existing deployed contract as long as it meets the prerequisites mentioned above.
  </Accordion>

  <Accordion title="What if my contract doesn't have a free minting function?">
    Your contract must have a function that allows Crossmint to mint NFTs without paying any fees. If your contract
    doesn't have this, you'll need to modify it or deploy a new version.
  </Accordion>

  <Accordion title="Can I use Crossmint's email delivery with my own contract?">
    Yes, you can still use Crossmint's email delivery system with your own contract. Just specify an email recipient
    in the mint request.
  </Accordion>

  <Accordion title="How do I handle token IDs with my custom contract?">
    Token ID management depends on your contract implementation. You can either pass a specific token ID as a
    parameter or let your contract handle token ID assignment internally.
  </Accordion>
</AccordionGroup>


# Configure Admin Functions
Source: https://docs.crossmint.com/minting/nfts/integrate/configure-admin-functions

Manage token controls including admin burn and admin transfer

Crossmint provides admin functions that allow you to control your NFTs throughout their lifecycle.

## Admin Transfer

The NFT Admin Transfer API allows collection owners to transfer NFTs between user wallets.

<Note>
  Admin transfers only work for Solana cNFTs. [Contact us](https://www.crossmint.com/contact/sales) if you want to
  access to this API.
</Note>

## Admin Burn

The [Burn NFT API](/api-reference/minting/nfts/burn-nft) allows collection owners to permanently remove NFTs from circulation.

<Warning>Once an NFT is burned, this action cannot be reversed.</Warning>

## Requirements

To use admin functions:

1. Your collection must be of a supported type (Solana cNFTs for transfers, Solana cNFTs or EVM for burns)
2. Your API key must have the appropriate scopes (`nfts.transfer` for transfers, `nfts.delete` for burns)
3. You must be the collection owner or have admin privileges


# Create Collections
Source: https://docs.crossmint.com/minting/nfts/integrate/create-collections

Deploy smart contracts and NFT collections

A collection is a container of NFTs, used by applications like marketplaces and wallets to group NFTs together.

Crossmint allows you to create managed collections via API or directly from the console. Crossmint has a library of pre-audited smart contracts which work for most major use cases. However, you can also [bring your own contract](/minting/nfts/integrate/bring-your-own-contract) if you already have one.

Crossmint supports non-fungible and semi-fungible tokens (editions), free and paid mints, and builds on open ERC and Metaplex standards. On EVM chains, ERC-721 and ERC-1155 contracts are supported, while on Solana, Metaplex standard programs and compressed NFT programs are supported.

<Note>See the list of supported blockchains [here](/introduction/supported-chains)</Note>

## 1. Create and Deploy an NFT collection

The first time you mint an NFT on a specific blockchain, Crossmint will assign it, and any subsequent mints, to a default collection for that chain. You can create additional collections from the console or in a single API call (requires the API key scope `collections.create`):

```bash cURL theme={null}
curl --request POST \
     --url https://staging.crossmint.com/api/2022-06-09/collections/ \
     --header 'content-type: application/json' \
     --header 'x-api-key: <X_API_KEY>' \
     --data '
{
  "chain": "polygon",
  "metadata": {
    "name": "A new collection",
    "imageUrl": "https://www.crossmint.com/assets/crossmint/logo.png",
    "description": "A new collection with its own dedicated smart contract"
  }
}
'
```

<Note>
  The collection details you provide will be displayed to your customers on marketplaces and other interfaces.
</Note>

<Accordion title="Sell your collection items">
  If you intend to sell the NFTs in your collection, read the guide on [how to enable
  payments](/minting/nfts/integrate/list-for-sale) first.
</Accordion>

## 2. Check the status of your collection

It takes a few seconds (up to a minute, depending on the blockchain and how congested it is) to deploy a collection.

You can use the following API to check what the status of a collection is. For example:

<CodeGroup>
  ```bash cURL theme={null}
  # Set your variables
  API_KEY="<YOUR_API_KEY>"
  ENV="staging" # or "www" for production
  ACTION_ID="<ACTION_ID>"

  curl --request GET \
    --url "https://${ENV}.crossmint.com/api/2022-06-09/actions/${ACTION_ID}" \
    --header "X-API-KEY: ${API_KEY}"
  ```

  ```javascript checkStatus.js theme={null}
  const apiKey = "<YOUR_API_KEY>";
  const env = "staging"; // or "www" for production
  const actionId = "<ACTION_ID>";

  const url = `https://${env}.crossmint.com/api/2022-06-09/actions/${actionId}`;
  const options = {
      method: "GET",
      headers: { "X-API-KEY": apiKey },
  };

  fetch(url, options)
      .then((response) => response.json())
      .then((response) => console.log(response))
      .catch((err) => console.error(err));
  ```
</CodeGroup>

## 3. List all collections under your project

```bash cURL theme={null}
curl --request GET \
     --url https://staging.crossmint.com/api/2022-06-09/collections/ \
     --header 'x-client-secret: <CLIENT_SECRET>' \
     --header 'x-project-id: <PROJECT_ID>'
```

<CardGroup>
  <Card title="API Reference" icon="terminal" href="/api-reference/minting/collection/create-collection">
    Test any API in seconds directly from the docs.
  </Card>

  <Card title="Talk to an expert" icon="message" href="https://www.crossmint.com/contact/sales">
    Contact our sales team for support.
  </Card>
</CardGroup>


# Define Metadata
Source: https://docs.crossmint.com/minting/nfts/integrate/define-metadata

Understand NFT metadata standards & storage options

Metadata in the context of NFTs includes essential information such as the name, description, and media (e.g., images, videos) associated with the asset.

### Metadata Standards

Collection and NFT metadata (e.g. title, description, image) must be specified in JSON format and follow industry conventions to ensure it renders appropriately across wallets and marketplaces.

Crossmint supports rich metadata like audio, video, and HTML. To include rich metadata, simply populate `animation_url` as specified in the links below.

<Card title="File size limits" icon="file">
  Crossmint's standard plan has a **10mb** file size limit. For larger uploads, you must upgrade to a [premium
  plan](https://www.crossmint.com/contact/sales) or handle the upload yourself.
</Card>

Metadata standards differ slightly across blockchains:

<Tabs>
  <Tab title="EVM chains">
    EVM chains follow the OpenSea standard. Refer to their <a href="https://docs.opensea.io/docs/metadata-standards#metadata-structure">official documentation</a> to see what attributes can be included and how. Note that `name` and `image` are mandatory fields.

    ```json EVM Metadata Example theme={null}
    {
      "name": "Crossmint Test NFT",
      "description": "Created with the Crossmint minting API",
      "image": "https://bafkreiexjl6kw4khdxkrt6dojgacscnzvrys47t472l2t7d6r2ss65kifq.ipfs.nftstorage.link/",
      "external_url": "https://docs.crossmint.com",
      "attributes":  [
        {
          "trait_type": "background",
          "value": "black"
        },
        {
          "trait_type": "flavor",
          "value": "minty"
        }
      ]
    }
    ```
  </Tab>

  <Tab title="Solana">
    Solana follows the Metaplex Metadata Standard. For more information, refer to the <a href="https://docs.metaplex.com/programs/token-metadata/changelog/v1.0#json-structure">official Metaplex documentation</a> - see the JSON structure section.

    ```json Solana Metadata Example theme={null}
    {
      "name": "Crossmint Test NFT",
      "symbol": "XMINT",
      "description": "Created with the Crossmint minting API",
      "seller_fee_basis_points": 5000,
      "image": "https://bafkreiexjl6kw4khdxkrt6dojgacscnzvrys47t472l2t7d6r2ss65kifq.ipfs.nftstorage.link/",
      "attributes": [
        {
          "trait_type": "background",
          "value": "black"
        },
        {
          "trait_type": "flavor",
          "value": "minty"
        }
      ],
      "properties": {
        "files": [
          {
            "uri": "https://bafkreiexjl6kw4khdxkrt6dojgacscnzvrys47t472l2t7d6r2ss65kifq.ipfs.nftstorage.link/",
            "type": "image/png"
          }
        ],
        "category": "image",
        "creators": [
          {
            "address": "xm2Mc3HEd2bGJXeqJEBrek4bj79gxzYkBaEobnpFraH",
            "share": 100
          }
        ]
      }
    }
    ```
  </Tab>

  <Tab title="Aptos">
    Aptos follows the Aptos Legacy Token Standard. For more information, refer to the <a href="https://aptos.dev/standards/aptos-token/">official Aptos Documentation</a> - see the JSON structure section.

    ```json Aptos Metadata Example theme={null}
    {
      "name": "Crossmint Test NFT",
      "description": "Aptos Attributes Test",
      "image": "https://www.arweave.net/abcd5678?ext=png",
      "animation_url": "https://www.arweave.net/efgh1234?ext=mp4",
      "external_url": "https://petra.app/",
      "attributes": [
        {
          "trait_type": "web",
          "value": "yes"
        },
        {
          "trait_type": "mobile",
          "value": "yes"
        },
        {
          "trait_type": "extension",
          "value": "yes"
        }
      ],
      "properties": {
        "files": [
          {
            "uri": "https://www.arweave.net/abcd5678?ext=png",
            "type": "image/png"
          },
          {
            "uri": "https://watch.videodelivery.net/9876jkl",
            "type": "unknown",
            "cdn": true
          },
          {
            "uri": "https://www.arweave.net/efgh1234?ext=mp4",
            "type": "video/mp4"
          }
        ],
        "category": "video"
      }
    }
    ```
  </Tab>
</Tabs>

## Crossmint Metadata Storage

Metadata must be stored somewhere to be accessible and verifiable on the blockchain. Crossmint automatically uploads and validates metadata for you on decentralized storage solutions, ensuring a seamless minting experience.

### Supported Storage Providers

Crossmint supports two primary storage providers:

* **IPFS (InterPlanetary File System)** (Default): A widely adopted decentralized storage standard ensuring compatibility across blockchain ecosystems by enabling peer-to-peer file storage and retrieval.
* **Walrus Network**: A new decentralized storage solution designed for efficient and scalable metadata hosting. Walrus is currently not supported for EVM NFT templates.

<Note>If you are interested in using **Arweave** for metadata storage, please contact us for further information.</Note>

### Configuring Storage

By default, Crossmint uses IPFS to store metadata and media. However, if you prefer to use Walrus, you can configure this in the [Crossmint Console](https://staging.crossmint.com/console) under **Settings > General**.

<img alt="Storage Providers" />

<Note>
  If you prefer to upload and manage media files independently, you can pass a direct URL to the [Mint API](/api-reference/minting/nfts/mint-nft)
  and set the `reuploadLinkedFiles` flag to `false`. This prevents Crossmint from automatically reuploading media files
  to decentralized storage.
</Note>

***

## FAQs

<AccordionGroup>
  <Accordion title="What type of files can I store?">
    You may store any text and image file. Additionally, you may include multi-media files such as GLTF, GLB, WEBM, MP4, M4V, OGV, and OGG, along with the audio-only extensions MP3, WAV, and OGA. Please stored them as `animation_url`.

    In addition, `animation_url` also supports HTML pages, allowing you to build rich experiences and interactive NFTs using JavaScript canvas, WebGL, and more. Scripts and relative paths within the HTML page are also supported. However, access to browser extensions is not supported.
  </Accordion>

  <Accordion title="What's the maximum file size?">
    The maximum file size is 10mb. For larger files, you must upgrade to an enterprise plan or upload the metadata yourself and pass the URI to the API.
  </Accordion>

  <Accordion title="Can I store the metadata on a centralized server?">
    Yes. You must handle the upload yourself and pass the URL to the API.
  </Accordion>
</AccordionGroup>


# List for Sale
Source: https://docs.crossmint.com/minting/nfts/integrate/list-for-sale

Configure royalties and marketplace profiles for your NFT collections

When selling NFTs on secondary markets, you can configure royalties to receive a percentage of each sale and optimize your collection's marketplace profile to attract buyers.

## Sell Tokens

The [Mint Tokens guide](/minting/nfts/integrate/mint-tokens) showed you how to create different types of non-fungible assets.
In this guide you will learn how to enable Crossmint's Checkout so you
can sell them to your customers using cryptocurrency or credit card.

### How It Works

* You can set a price in crypto (ETH, MATIC, SOL or USDC).
* For imported and secondary collections, payouts arrive instantly. For managed collections, payouts arrive after a 24-hour withholding period.
* Your customers can pay with crypto or credit card.
* You pay credits for NFT gas, user pays only for the item.

### Configure a Collection for Sale

<Tabs>
  <Tab title="Using the console">
    1. [Create an NFT collection](/minting/nfts/integrate/create-collections) and navigate
       to it in the console.

    2. Upload NFT "templates" for all the NFTs you wish to list for sale. You
       can do so from the "NFTs" tab in the console, or by using
       [the API](/api-reference/minting/template/create-template).

    3. Navigate to the `Checkout` entry on the navbar in the collections page.
       Follow the wizard to enable payments.

    4. (Production only) [Verify your account and collection](/introduction/platform/account-verification). Not required in staging.

    5. Share the url or QR code with your users.
  </Tab>

  <Tab title="Using the API">
    **Enable at collection creation time**

    Pass a `payments` object to the [Collection Creation
    API](/api-reference/minting/collection/create-collection) with the<Tooltip>
    `price`</Tooltip>, <Tooltip>
    `recipientAddress`</Tooltip> and <Tooltip>`currency`</Tooltip>. You can optionally set up a <Tooltip>
    `supplyLimit`</Tooltip> to cap the collection supply.

    <Accordion title="See example">
      The following snippet creates a new sales-enabled collection:

      <CodeGroup>
        ```bash cURL theme={null}
        curl --request POST \
            --url https://staging.crossmint.com/api/2022-06-09/collections/ \
            --header 'Content-Type: application/json' \
            --header 'X-API-KEY: <api-key>' \
            --data '{
            "chain": "polygon",
            "fungibility": "non-fungible",
            "metadata": {
            "description": "This is a sample NFT collection",
            "imageUrl": "https://www.crossmint.com/assets/crossmint/logo.png",
            "name": "Sample NFT Collection",
            },
            "payments": {
            "price": "<string>",
            "recipientAddress": "<string>",
            "currency": "usdc"
            },
            "supplyLimit": 123
        }'
        ```
      </CodeGroup>
    </Accordion>

    **Enable on an existing collection**

    If you had already created a collection, use the [Update Collection API](/api-reference/minting/collection/update-collection) to enable sales on it.

    <Note>Enabling sales in production requires [verifying your account](/introduction/platform/account-verification).</Note>
  </Tab>
</Tabs>

***

### Set Up a Checkout

Now that your collection accepts payments, the next step is to integrate one of
Crossmint's [Checkout](/payments/introduction) variants into your app
or website, and start accepting sales.

There are two ways to integrate:

<CardGroup>
  <Card title="Hosted Checkout" icon="toggle-on" href="/payments/pay-button/overview">
    Add a button to your site which opens a checkout in a pop-up or new tab.
  </Card>

  <Card title="Embedded Checkout" icon="object-group" href="/payments/embedded/overview">
    Insert a checkout inside your site for maximum control over the user experience.
  </Card>
</CardGroup>

## Set Collection Royalties

With royalties, you can receive revenue when your NFTs are traded on secondary markets. Crossmint allows you to configure royalties for a collection via API and (soon) directly from the console. You just have to specify the % of royalties and where you want those funds to be sent.

Royalties are defined at the collection level, not at the NFT level. Updating the royalties of a collection will update all NFTs, including the ones which have already been minted.

This API follows royalty standards compatible with virtually all marketplaces. However, note that some marketplaces have determined to not honor royalties, so transactions occuring there may not generate additional revenue.

<Warning>
  Available self-serve for ERC-721 collections in EVM chains. Please [contact
  us](https://www.crossmint.com/contact/sales) for ERC-1155 or Solana support.
</Warning>

| Endpoint                                                                                 | Description             |    |
| :--------------------------------------------------------------------------------------- | :---------------------- | :- |
| [Add / Edit Royalties](/api-reference/minting/collection/set-royalties)                  | Add or edit royalties   |    |
| [Get Royalty Information](/minting/nfts/integrate/list-for-sale#get-royalty-information) | Get royalty information |    |
| [Disable Royalties](/minting/nfts/integrate/list-for-sale#disable-royalties)             | Disable royalties       |    |

### Add / Edit Royalties

To add or edit royalties for a collection, use the following API endpoint:

```bash cURL theme={null}
curl --request POST \
  --url https://staging.crossmint.com/api/v1-alpha1/minting/collections/{collectionId}/royalties \
  --header 'Content-Type: application/json' \
  --header 'X-API-KEY: <api-key>' \
  --data '{
  "recipients": [
    {
      "address": "0x123...",
      "basisPoints": 5
    }
  ]
}'
```

### Get Royalty Information

To retrieve the current royalty configuration for a collection:

```bash cURL theme={null}
curl --request GET \
  --url https://staging.crossmint.com/api/v1-alpha1/minting/collections/{collectionId}/royalties \
  --header 'X-API-KEY: <api-key>'
```

### Disable Royalties

To disable royalties for a collection:

```bash cURL theme={null}
curl --request DELETE \
  --url https://staging.crossmint.com/api/v1-alpha1/minting/collections/{collectionId}/royalties \
  --header 'X-API-KEY: <api-key>'
```

## Implementation Examples

<Accordion title="Setting up royalties for a new collection">
  ```javascript theme={null}
  // Example: Setting up royalties for a new collection
  const apiKey = "YOUR_API_KEY";
  const collectionId = "your-collection-id";
  const env = "staging"; // or "www" for production

  // Define royalty recipients
  const royaltyRecipients = [
    {
      address: "0x123abc...", // Creator wallet
      basisPoints: 5 // 5% royalty
    },
    {
      address: "0x456def...", // Community fund wallet
      basisPoints: 2.5 // 2.5% royalty
    }
  ];

  // Set up royalties
  const url = `https://${env}.crossmint.com/api/v1-alpha1/minting/collections/${collectionId}/royalties`;
  const options = {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-API-KEY": apiKey
    },
    body: JSON.stringify({
      recipients: royaltyRecipients
    })
  };

  fetch(url, options)
    .then(response => response.json())
    .then(data => console.log("Royalties configured:", data))
    .catch(error => console.error("Error configuring royalties:", error));
  ```
</Accordion>

## Marketplace Profile

Optimizing your collection's profile on marketplaces like OpenSea, Rarible, and others can significantly impact your NFT sales and visibility.

At this time, updating your collection profile on OpenSea, Rarible, and other marketplaces requires manual work and is limited to <a href="https://www.crossmint.com/contact/sales">enterprise</a> clients.

### Key Marketplace Profile Elements

When working with our enterprise team to configure your marketplace profile, consider these important elements:

1. **Collection Banner**: A high-quality banner image that represents your brand
2. **Collection Logo**: A distinctive logo that's recognizable at small sizes
3. **Collection Description**: A compelling description of your project and its value
4. **External Links**: Links to your website, social media, and community channels
5. **Category Tags**: Appropriate categories that help collectors discover your NFTs

## FAQs

<AccordionGroup>
  <Accordion title="How are royalties enforced on different marketplaces?">
    Royalty enforcement varies by marketplace. Some marketplaces like OpenSea have made royalties optional, while
    others still enforce them. Crossmint implements royalties according to blockchain standards, but cannot
    guarantee enforcement across all marketplaces.
  </Accordion>

  <Accordion title="Can I set different royalty percentages for different NFTs in the same collection?">
    No, royalties are set at the collection level and apply to all NFTs within that collection. If you need
    different royalty structures, consider creating separate collections.
  </Accordion>

  <Accordion title="How quickly do royalty changes take effect?">
    Royalty changes take effect immediately for new listings. For existing listings on marketplaces, the timing
    depends on how frequently each marketplace refreshes metadata.
  </Accordion>

  <Accordion title="What's the maximum royalty percentage I can set?">
    While technically there's no upper limit, most marketplaces and collectors expect royalties between 2.5% and
    10%. Setting royalties too high may discourage secondary market activity.
  </Accordion>
</AccordionGroup>


# Manage Delivery
Source: https://docs.crossmint.com/minting/nfts/integrate/manage-delivery

Configure recipient options and customize email delivery notifications

Crossmint provides flexible options for delivering NFTs to recipients and customizing the delivery experience. This guide covers how to specify different types of recipients and how to customize the email notifications they receive.

## Specify Recipients

You can deliver NFTs to three kinds of recipients when using minting APIs:

* [Wallet address](#send-nft-to-wallet-address): directly specify a wallet address, which could be a user owned wallet (e.g. MetaMask, Phantom, etc.) or a wallet you manage.
* [Email address](#send-nft-to-email-address): in this modality, Crossmint automatically generates a secure MPC backed custodial wallet for the email, and delivers the NFT inside.
* [User identifier](#send-nft-by-userid): in this modality, Crossmint automatically generates a wallet and associates it with an user ID from your application, and delivers the NFT inside. You must build the interface for users to access this wallet.

<Check>
  Check out the [create-wallet](/api-reference/wallets/create-wallet) endpoint in the API reference if you wish to
  pre-create a wallet prior to invoking the mint API.
</Check>

### Send NFT to Wallet Address

To mint an NFT directly to an existing blockchain address, the following `recipient` format is used:

```bash theme={null}
<chain>:<address>
```

<Note>For a full list of chain names, refer to the [Supported Chains](/introduction/supported-chains) page.</Note>

#### Examples

* EVM: `polygon:0x123...`
* Solana: `solana:3Q5...`
* Aptos: `aptos:0x0f07...`

### Send NFT to Email Address

To mint an NFT and send it to an email address, the following `recipient` format is used:

```bash theme={null}
email:<email_address>:<chain>
```

#### Examples

* EVM: `email:demo@test.com:polygon`
* Solana: `email:demo@test.com:solana`

<Note>Minting to an email address is not currently supported on Aptos.</Note>

The NFT can then be accessed by logging into Crossmint with the specified email address:

* for `staging/testnet` NFTs: <a href="https://staging.crossmint.com/user/collection">[https://staging.crossmint.com/user/collection](https://staging.crossmint.com/user/collection)</a>
* for `mainnet` NFTs: <a href="https://www.crossmint.com/user/collection">[https://www.crossmint.com/user/collection](https://www.crossmint.com/user/collection)</a>

### Send NFT to a Twitter/X account

To mint an NFT to a Twitter/X account, the following `recipient` format is used:

```bash theme={null}
twitter:<twitter_handle>:<chain>
```

#### Examples

* EVM: `twitter:@username:polygon`
* Solana: `twitter:@username:solana`

### Send NFT by `userId`

This method allows you to deliver NFTs by directly specifying the user identifier of the recipient in your system. Crossmint will fetch a custodial wallet linked to that user identifier inside your project or, if none exists, create one on the fly. Then the NFT will be delivered there. This way, you don't need to keep a mapping between your user identifiers and their wallets, just pass your user id and crossmint takes care of the rest.

<Snippet />

<Note>Wallets created with the `userId` option cannot be accessed by logging into Crossmint.com.</Note>

To mint an NFT to this type of recipient, follow this format:

```bash theme={null}
userId:<userIdentifier>:<chain>
```

#### Examples

* EVM: `userId:user1234:polygon`
* Solana: `userId:user1234:solana`

## Customize Delivery Emails

Email delivery notifications can be customized to align with your branding and communication needs. This section will walk you through how to configure your email template.

### Edit the email template

To adjust the visual presentation and branding of your email notifications:

1. In the Crossmint Console, click on Settings, and navigate to the **Branding** tab.
2. Select **Deliver NFT via email** from the dropdown options.
3. Here, you can customize:
   * The **logo** displayed in the email with your logo. This will default to Crossmint's logo, unless specified otherwise.
   * The main **button's color** . This will default to #04AA6D (Crossmint's green).
   * The **display name** textbox to include your brand's name. This will be empty, by default.

As you make adjustments, you can preview the changes. Once satisfied, save your changes and now they will apply to all future minting email notifications, related to this project. Emails now reflect your project's brand identity while providing essential delivery information to recipients.

<img alt="Customize email template" />

### Enable email delivery

You should make sure email delivery notifications are enabled for the customized email to reach your users. For new projects created after Sep 16, 2024, the "sendNotification" parameter is set to `true` by default, meaning mint recipients will automatically receive email notifications.

For legacy projects, created before Sep 16 2024, "sendNotification" is set to `false` until March 14, 2025. If you choose so, you can enable email notifications for legacy projects by explicitly turning the feature on via API or via the Console.

#### Console

To send email notifications to NFT recipients:

1. Navigate to an **unminted NFT** part of a Collection in the Crossmint Console.
2. Click on the **more options** button and select **Mint & send NFT**.
3. Ensure the **Notify recipient via email** option is selected.
4. Enter the **recipient's email address** and press Mint.

The recipient will receive an email delivery notification for their newly minted NFT.

#### API

To do the same programmatically, you can configure two new parameters:

1. **sendNotification** (boolean): Determines whether the recipient will receive an email notification.
   * Default value: `true` for new projects created after Sep 16, 2024.
   * For legacy projects (created before Sep 16, 2024), this feature will default to `false` until March 14, 2025, unless explicitly set to `true`.
2. **locale** (string): Specifies the language for the email content. Default is `en-US` for English. We support all locales (i.e. "es-ES" for Spanish).

## FAQs

<AccordionGroup>
  <Accordion title="Can recipients change their email preferences?">
    Yes, recipients can manage their email preferences through their Crossmint account settings.
  </Accordion>

  <Accordion title="What happens if an email address is invalid?">
    If an email address is invalid, the NFT will still be minted but the notification will fail to deliver. The NFT
    will be associated with the email address in Crossmint's system, but the recipient won't receive a notification.
  </Accordion>

  <Accordion title="Can I send NFTs to multiple recipients at once?">
    Currently, each API call mints to a single recipient. For bulk operations, you'll need to make multiple API
    calls. See the [Mint In Bulk](/minting/nfts/integrate/mint-in-bulk) guide for more information.
  </Accordion>

  <Accordion title="How do I track if an email notification was delivered?">
    Crossmint doesn't currently provide delivery tracking for email notifications. For critical notifications,
    consider implementing your own email delivery system alongside Crossmint's.
  </Accordion>
</AccordionGroup>


# Mint In Bulk
Source: https://docs.crossmint.com/minting/nfts/integrate/mint-in-bulk

Scale your NFT operations with bulk minting capabilities

Crossmint's infrastructure is designed to handle high-volume minting operations efficiently, allowing you to scale your NFT projects to serve thousands or even millions of users.

## Enterprise Solutions

For enterprise customers with very high volume requirements, Crossmint offers additional capabilities:

<Warning>
  Enterprise bulk minting features are available for high-volume projects. Please [contact
  us](https://www.crossmint.com/contact/sales) to discuss your specific requirements.
</Warning>

## Bulk Minting Capabilities

Crossmint's platform offers several advantages for bulk minting operations:

* **High Throughput**: Mint thousands of NFTs per hour with optimized transaction batching
* **Cost Efficiency**: Reduce gas costs through intelligent transaction scheduling
* **Queue Management**: Automatic handling of transaction queues and retries
* **Observability**: Track the status of all minting operations in real-time
* **Gas Optimization**: Automatic gas price adjustments based on network conditions

## Bulk Minting via Crossmint Console

The Crossmint Console provides an easy-to-use interface for uploading and minting NFTs in bulk. Here's how to use it:

### Step 1: Access the Batch Upload Feature

In the Crossmint Console, navigate to your collection and select the "Batch upload" option.

<img alt="Batch Upload Option" />

### Step 2: Prepare Your Metadata

Before uploading your assets, you need to prepare them properly:

1. You can upload up to 1,000 NFT collectibles at once
2. Download the example CSV file provided by Crossmint to use as a template
3. Prepare your metadata according to the template format

<img alt="Batch Upload Interface" />

### Step 3: Upload Your Metadata CSV

1. Add a CSV file named `metadata.csv` with your NFT metadata
2. Click the "Upload CSV" button to upload your prepared file

<img alt="Batch Upload Interface" />

### Step 4: Upload Media Files

1. Prepare your NFT media files (images, animations, videos)
2. Crossmint supports various formats (PNG, JPEG, GIF etc.)
3. Each file must be under 10MB in size
4. All media files should be in the same folder, not in subfolders
5. Click "Upload media files" to upload your prepared media

<img alt="Batch Upload Interface" />

### Step 5: Complete the Upload

After uploading both your metadata CSV and media files, click the "Upload" button to start the batch minting process.

<img alt="Batch Upload Interface" />

## Monitoring Bulk Operations

When minting in bulk, it's essential to track the status of your operations:

1. **Webhooks**: Set up [webhooks](/minting/nfts/integrate/webhooks-and-status-apis) to receive real-time notifications about mint completions and failures
2. **Status API**: Use the [action status API](/minting/nfts/integrate/webhooks-and-status-apis) to check the status of individual minting operations
3. **Console Dashboard**: Monitor your minting operations through the Crossmint Console


# Mint Tokens
Source: https://docs.crossmint.com/minting/nfts/integrate/mint-tokens

Create and distribute tokens at scale

<Tabs>
  <Tab title="Unique Assets (ERC-721)">
    To mint and airdrop unique digital assets, you can follow the guide on the [Quickstart](/minting/quickstarts/nfts). For more detail, please check the [API reference](/api-reference/minting/nfts/mint-nft). You can watch a quick video tutorial for this [here](https://youtu.be/yYJRW35zqUQ?si=b6PQTbZ7zqYVGwXw).
  </Tab>

  <Tab title="Editions (ERC-1155)">
    SFTs (semifungible tokens) follow the ERC-1155 standard. Each token is a replica of a predefined template. Each collection (smart contract) can contain multiple templates, which can contain many tokens.

    To get started, it's recommended to read the [Introduction](/minting/introduction) for general information on how the minting product works.

    <Warning>This API only supports EVM chains self-serve. Contact us if you need support for another chain.</Warning>

    ## 1. Create an SFT collection to hold your templates

    ```bash cURL theme={null}
      curl --request POST \
        --url https://staging.crossmint.com/api/2022-06-09/collections \
        --header 'accept: application/json' \
        --header 'content-type: application/json' \
        --header 'x-api-key: YOUR_API_KEY' \
        --data '
    {
        "chain": "polygon-amoy",
        "fungibility": "semi-fungible",
        "metadata": {
          "name": "My New Collection",
          "imageUrl": "https://www.crossmint.com/assets/crossmint/logo.png",
          "description": "A new collection with its own dedicated smart contract"
        }
    }'
    ```

    <Accordion title="See example response">
      ```json JSON theme={null}
        {
          "id": "5263650e-6d43-4ed3-9e31-0cf593d076a4",
          "metadata": {
            "name": "Test Collection",
            "description": "Test",
            "imageUrl": "https://cdn.io/metadata.json",
            "symbol": "XMINT"
          },
          "fungibility": "semi-fungible",
          "onChain": {
            "chain": "polygon-amoy",
            "type": "erc-1155"
          },
          "actionId": "5263650e-6d43-4ed3-9e31-0cf593d076a4"
        }
      ```
    </Accordion>

    ## 2. Create a template within that collection

    ```bash cURL theme={null}
    curl --request POST \
      --url https://staging.crossmint.com/api/2022-06-09/collections/{collectionId}/templates \
      --header 'accept: application/json' \
      --header 'content-type: application/json' \
      --header 'x-api-key: YOUR_API_KEY' \
      --data '
      {
        "onChain": {
          "tokenId": "2"
        },
        "supply": {
          "limit": 10
        },
        "metadata": {
          "name": "My template",
          "image": "https://www.crossmint.com/assets/crossmint/logo.png",
          "description": "A new token template for my ERC1155 collection"
        }
      }'
    ```

    <Accordion title="See example response">
      ```json JSON theme={null}
      {
        "templateId": "58b0c1aa-e457-48dd-bb55-5a27e6a92f74",
        "metadata": {
          "name": "My template",
          "image": "ipfs://bafkreigbqsmxzkbjgbwtj6exfdt5z3t3swgoysf7hr6vjzddqnmykj6x2u",
          "description": "A new token template for my ERC1155 collection"
        },
        "onChain": {
          "tokenId": "1"
        },
        "supply": {
          "limit": "10",
          "minted": "0"
        }
      }
      ```
    </Accordion>

    ## 3. Mint an SFT from a template

    Mint SFTs from the template and send them to wallets or email addresses.

    ```bash cURL theme={null}
      curl --request POST \
        --url https://staging.crossmint.com/api/2022-06-09/collections/{collectionId}/sfts \
        --header 'accept: application/json' \
        --header 'content-type: application/json' \
        --header 'x-api-key: YOUR_API_KEY' \
        --data '
        {
          "templateId": "58b0c1aa-e457-48dd-bb55-5a27e6a92f74",
          "recipient": "email:user@example.com:polygon-amoy",
          "amount": 1
        }'
    ```

    <Accordion title="See example response">
      ```json JSON theme={null}
      {
        "actionId": "a91c15e3-60f2-4a45-bf1a-cee508981667",
        "action": "nfts.create",
        "status": "pending",
        "data":
        {
          "chain": "polygon-amoy",
          "collection":
          {
            "id": "84e3d617-9c1b-4e7a-9686-522a9ea7c520",
            "contractAddress": "0x9b8ab8949bd7E73E61945b88F7fe12151f98ad3C"
          },
          "recipient":
          {
            "walletAddress": "0xcFDc00Cf926A5053f9Cdf004e6DF17e6dEB2E146",
            "email": "testy@crossmint.com"
          },
          "token":
          {
            "id": "a91c15e3-60f2-4a45-bf1a-cee508981667"
          }
        },
        "startedAt": "2024-01-02T22:05:01.000Z",
        "resource": "https://staging.crossmint.com/api/2022-06-09/actions/a91c15e3-60f2-4a45-bf1a-cee508981667"
      }
      ```
    </Accordion>

    **All set!**

    To confirm delivery, use the [transaction status API](/minting/nfts/integrate/webhooks-and-status-apis) or set up a [webhook](/minting/nfts/integrate/webhooks-and-status-apis).
  </Tab>

  <Tab title="Compressed NFTs">
    ## What are Compressed NFTs?

    Compressed NFTs are a new standard on the Solana blockchain, for minting NFTs with the lowest cost amongst L1 and L2 blockchains, and the highest throughput (thousands of NFTs per second). Read more details about how it works [here](https://www.metaplex.com/posts/expanding-digital-assets-with-compression-for-nfts).

    Using this standard to mint NFTs is extremely complicated if you manage everything on your own. On top of the intrinsic complexity usually required to mint a regular NFT, compressed NFTs require deploying and managing Merkle trees, batching, and dealing with nascent infrastructure. Crossmint also supports updating the NFT metadata after minting. Please refer to this [doc page](/minting/nfts/integrate/update-nfts).

    Here's where Crossmint can help: we've done all the hard work so that minting compressed NFTs is no harder than minting regular ones: all it takes is a single API call, and you can even use one of Crossmint's no-code tools to do so.

    ## Current Protocol Limitations

    * There's a 10-30 second delay between when an NFT is minted and it shows in wallets.

    ## How to use the Minting API with Compressed NFTs

    The Minting API for Compressed NFTs is exactly the same as for regular NFTs, but it only works on the Solana blockchain.

    POST `https://staging.crossmint.com/api/2022-06-09/collections/<collection-id>/nfts`

    <Note>You can mint both compressed and non-compressed NFTs on the same collection.</Note>

    ```bash cURL theme={null}
    curl --request POST \
      --url https://staging.crossmint.com/api/2022-06-09/collections/default-solana/nfts \
      --header 'Content-Type: application/json' \
      --header 'X-API-KEY: <x-api-key>' \
      --data '{
        "recipient": "email:john.doe@example.com:solana",
        "metadata": {
          "name": "Crossmint Example NFT",
          "image": "https://www.crossmint.com/assets/crossmint/logo.png",
          "description": "My NFT created via the mint API!"
        },
        "compressed": true,
        "reuploadLinkedFiles": false
      }'
    ```

    The above will return an NFT ID. Use it in the next call to retrieve the mint status.

    ```bash cURL theme={null}
    curl --request GET \
      --url https://staging.crossmint.com/api/2022-06-09/collections/{collectionId}/nfts/{nftId} \
      --header 'X-API-KEY: X_API_KEY'
    ```

    Be sure to replace:

    * `X_API_KEY`, `{collectionId}` and `{nftId}`
    * Recipient: change `VALID_WALLET_ADDRESS` with the wallet you want to send the NFT to
    * Metadata: add the name, image, and description.

    <Card title="To explore compressed NFTs on the blockchain, you must use Orb, powered by Helius" icon="magnifying-glass" href="https://xray.helius.xyz/">
      Other explorers, like Solscan, still have not added support.
    </Card>
  </Tab>

  <Tab title="Non-transferrable NFTs">
    There are two ways to set the transferrability of NFTs:

    1. Defining it at the smart contract level
    2. If you are using custodial wallets, enabling or disabling transfers from the frontend

    If you want to configure it at the smart contract level, see the following endpoints:

    | Endpoint                                                                     | Chain         | Description                       |
    | ---------------------------------------------------------------------------- | ------------- | --------------------------------- |
    | [Set Transferability](/api-reference/minting/collection/set-transferability) | EVM and Aptos | Set transferability to on or off  |
    | [Get Transferability](/api-reference/minting/collection/get-transferability) | EVM and Aptos | Get transferability configuration |

    <Note>For Solana or other non-EVM chain support, [contact us](https://www.crossmint.com/contact/sales)</Note>
  </Tab>
</Tabs>

***

<Note>
  The API also has an idempotent version which prevents you from calling the same API action multiple times and
  mitigates the risk of unwanted NFT duplicates.
</Note>

## Advanced Guides

<CardGroup>
  <Card title="Dynamic NFTs" icon="pencil" href="/minting/nfts/integrate/update-nfts" />

  <Card title="List for Sale" icon="money-bill" href="/minting/nfts/integrate/list-for-sale" />

  <Card title="Webhooks & Status APIs" icon="atom" href="/minting/nfts/integrate/webhooks-and-status-apis" />

  <Card title="Bring your own Contract" icon="file-import" href="/minting/nfts/integrate/bring-your-own-contract" />
</CardGroup>


# Pricing
Source: https://docs.crossmint.com/minting/nfts/integrate/pricing

Crossmint Mint API Pricing

## Chain operations pricing

*All values shown in USD.*

| Chain           | Create Collection | Update Collection |    Mint NFTs | Update Royalty | Update Metadata |
| :-------------- | ----------------: | ----------------: | -----------: | -------------: | --------------: |
| Aptos           |            \$0.10 |     Not supported |       \$0.01 |  Not supported |   Not supported |
| Arbitrum\*      |      \$0.03 + gas |      \$0.03 + gas | \$0.03 + gas |   \$0.03 + gas |    \$0.03 + gas |
| Arbitrum Nova\* |      \$0.01 + gas |      \$0.01 + gas | \$0.01 + gas |   \$0.01 + gas |    \$0.01 + gas |
| Avalanche\*     |      \$0.10 + gas |      \$0.10 + gas | \$0.10 + gas |   \$0.10 + gas |    \$0.10 + gas |
| Base\*          |      \$0.08 + gas |      \$0.08 + gas | \$0.08 + gas |   \$0.08 + gas |    \$0.08 + gas |
| BSC\*           |      \$0.01 + gas |      \$0.01 + gas | \$0.01 + gas |   \$0.01 + gas |    \$0.01 + gas |
| Chiliz          |               \$1 |            \$0.20 |       \$0.50 |         \$0.20 |          \$0.20 |
| Mode            |            \$0.05 |            \$0.05 |       \$0.05 |         \$0.05 |          \$0.05 |
| Optimism\*      |      \$0.06 + gas |      \$0.06 + gas | \$0.06 + gas |   \$0.06 + gas |    \$0.06 + gas |
| Polygon         |            \$0.50 |            \$0.50 |       \$0.10 |         \$0.50 |          \$0.05 |
| Rari            |            \$0.20 |            \$0.20 |       \$0.20 |         \$0.20 |          \$0.20 |
| Sei             |            \$0.05 |            \$0.01 |       \$0.01 |         \$0.01 |          \$0.01 |
| Shape           |               \$2 |               \$2 |          \$2 |            \$2 |             \$2 |
| Solana          |               \$8 |     Not supported |       \$0.02 |  Not supported |          \$0.02 |
| Skale Nebula    |            \$0.01 |            \$0.01 |       \$0.01 |         \$0.01 |          \$0.01 |
| Viction         |            \$0.01 |            \$0.01 |       \$0.01 |         \$0.01 |          \$0.01 |
| Xai             |            \$0.01 |            \$0.01 |       \$0.01 |         \$0.01 |          \$0.01 |
| Zora\*          |      \$0.08 + gas |      \$0.08 + gas | \$0.08 + gas |   \$0.08 + gas |    \$0.08 + gas |

\*For some chains (Arbitrum, Arbitrum Nova, Avalanche, Base, BSC, Optimism, and Zora), gas fees are added to the base price. Gas fees are determined at the time the operation is submitted and depend on blockchain network congestion.

For more details, or to discuss custom pricing for large operations volumes, [contact our sales team](https://www.crossmint.com/contact/sales).


# Update NFTs
Source: https://docs.crossmint.com/minting/nfts/integrate/update-nfts

Make your NFTs change over time

Dynamic NFTs are tokens whose content changes over time. There are two ways to achieve this with Crossmint:

1. Using Crossmint's [Edit NFT API](/api-reference/minting/nfts/edit-nft)
2. Storing the metadata offchain and updating it on your database. To use this option, set the property `reuploadLinkedFiles` to `false` when minting an NFT.

## Using the Edit NFT API

The [Edit NFT API](/api-reference/minting/nfts/edit-nft) allows you to update the metadata of an existing NFT, including its name, description, image, and attributes. This is useful for creating NFTs that evolve over time or need to be updated based on external events.

### Prerequisites

* Ensure your API key is a server-side key with the `nfts.update` scope
* You need the collection ID and NFT ID from the minting process

### Implementation

```bash cURL theme={null}
curl --request PATCH \
  --url https://staging.crossmint.com/api/2022-06-09/collections/{collectionId}/nfts/{nftId} \
  --header 'Content-Type: application/json' \
  --header 'X-API-KEY: <api-key>' \
  --data '{
  "metadata": {
    "description": "My updated NFT description!",
    "image": "https://www.crossmint.com/assets/crossmint/updated-image.png",
    "name": "Evolved NFT",
    "attributes": [
      {
        "trait_type": "level",
        "value": "2"
      }
    ]
  },
  "reuploadLinkedFiles": true
}'
```

## Using Off-chain Metadata

You can also store the metadata off-chain and update it directly:

1. When minting the NFT, set `reuploadLinkedFiles` to `false`
2. Use your own server to host the metadata
3. Update the metadata on your server as needed

```javascript theme={null}
// Example: Minting with off-chain metadata
const apiKey = "YOUR_API_KEY";
const chain = "polygon-amoy"; // or "ethereum-sepolia", "base-sepolia", etc.
const env = "staging"; // or "www" for production
const recipientEmail = "TEST_EMAIL_ADDRESS";
const recipientAddress = `email:${recipientEmail}:${chain}`;

// The URL to your metadata server
const metadataImgUrl = "https://your-server.com/metadata/token123.png";

const url = `https://${env}.crossmint.com/api/2022-06-09/collections/default/nfts`;
const options = {
    method: "POST",
    headers: {
        accept: "application/json",
        "content-type": "application/json",
        "x-api-key": apiKey,
    },
    body: JSON.stringify({
        recipient: recipientAddress,
        metadata: {
            name: "Dynamic NFT",
            description: "This NFT will update over time",
            image: metadataImgUrl,
        },
        reuploadLinkedFiles: false,
    }),
};

fetch(url, options)
    .then((response) => response.json())
    .then((data) => console.log(data))
    .catch((error) => console.error("Error:", error));
```

## Use Cases for Dynamic NFTs

Dynamic NFTs enable a wide range of applications:

* **Game Assets**: NFTs that evolve as players progress
* **Membership Passes**: NFTs that update based on membership status
* **Event Tickets**: NFTs that change before, during, and after events
* **Digital Collectibles**: NFTs that evolve based on real-world events
* **Loyalty Programs**: NFTs that update based on customer activity

## Best Practices

When implementing dynamic NFTs:

1. **Plan for Updates**: Design your NFT with future updates in mind
2. **Versioning**: Consider including version information in your metadata
3. **Event Triggers**: Define clear conditions for when updates should occur
4. **User Communication**: Inform users about how and when their NFTs might change
5. **Testing**: Thoroughly test update mechanisms before implementation

## FAQs

<AccordionGroup>
  <Accordion title="How often can I update an NFT?">
    With Crossmint's Edit API, you can update NFTs as needed, but consider blockchain transaction costs and network
    congestion. For very frequent updates, consider using off-chain metadata.
  </Accordion>

  <Accordion title="Will updates to an NFT affect its provenance or value?">
    Updates don't change the token ID or ownership history, but the perceived value may change based on the nature
    of the updates. It's important to communicate your update policy to collectors.
  </Accordion>

  <Accordion title="Can I schedule updates to happen automatically?">
    Crossmint doesn't provide native scheduling, but you can implement scheduled updates using your own backend
    services that call the Edit API at specified times.
  </Accordion>

  <Accordion title="Do all marketplaces support dynamic NFTs?">
    Most marketplaces will display the current state of your NFT's metadata, but the frequency of metadata refreshes
    may vary by marketplace.
  </Accordion>
</AccordionGroup>


# Webhooks and Status APIs
Source: https://docs.crossmint.com/minting/nfts/integrate/webhooks-and-status-apis

Listen for updates in mints, edits, collection creations and other async events

Creating NFT collections and minting or [editing NFTs](/minting/nfts/integrate/update-nfts) are operations that must be sent to a blockchain. Transaction confirmation on the blockchain can take a few seconds, but during network congestion, it may take several minutes. Webhooks and the action status API allow you to stay up to date on the status of these asynchronous operations.

Some cases where you may want to listen to when transactions are confirmed include:

* Notifying your customers via email that their NFT is ready to access
* Updating your database with the NFT id for the user
* Showing in your website that that the mint has been successful

### Ways to check the status of an action

| Model                    | Best for                    | Mechanism         |
| ------------------------ | --------------------------- | ----------------- |
| Pull (query for updates) | Quick testing               | Action Status API |
| Push (get notified)      | Scalable apps in production | Webhooks          |

<Tabs>
  <Tab title="Action Status APIs">
    ## Action Status APIs

    Call the following API to check the status of an action:

    ```bash cURL theme={null}
    # Set your variables
    env=staging  # or "www" for production
    YOUR_API_KEY=<ENTER_YOUR_API_KEY>
    actionId=<ENTER_YOUR_actionId>

    # Execute the curl command
    curl --request GET \
    --url "https://${env}.crossmint.com/api/2022-06-09/actions/${actionId}" \
    --header 'accept: application/json' \
    --header "x-api-key: ${YOUR_API_KEY}"
    ```

    <Card title="API Reference" icon="terminal" href="/api-reference/common/get-action-status" />

    <Accordion title="Where can I find the actionId and API_KEY?">
      * `actionID` is returned from any async API calls you perform.
      * `YOUR_API_KEY` can be found in the `Developers -> API Keys` tab of the [Production](https://www.crossmint.com/console/projects/apiKeys) or [Staging](https://staging.crossmint.com/console/projects/apiKeys) consoles.
    </Accordion>
  </Tab>

  <Tab title="Webhooks">
    ## Webhooks

    In this guide, we will use nodejs to create an API endpoint to listen for and parse webhook events:

    ### 1. Create an endpoint route

    Using a standard nodejs API server, create an endpoint.

    <Accordion title="I don't have a webserver or want to test locally">
      You can test locally by installing [ngrok](https://ngrok.com/docs/getting-started/) and creating a routed endpoint to a specified port.
    </Accordion>

    ### 2. Configure the endpoint to read and parse webhook events

    On this endpoint, modify the code to handle POST requests only. When a POST request comes through, parse the webhook event of the request body. Ensure your webhook listener responds with a `200` status code. Otherwise the webhook may be sent until you acknowledge it.

    The snippet below is an example handler that parses webhook events:

    ```javascript theme={null}
    // endpoint.js

    // listen to webhook ingestion
    export default function handler(req, res) {
      if (req.method === "POST") {
        console.log(`[webhook] Successfully minted ${req.body.id}`);
      }
      res.status(200).json({});
    }
    ```

    <Warning>
      Don't be strict with payload validations as Crossmint may add new fields to
      the webhooks as products evolve.
    </Warning>

    Here are some examples of the webhook results (with dummy data):

    <AccordionGroup>
      <Accordion title="collections.create.succeeded">
        <CodeGroup>
          ```json EVM theme={null}
          {
            "actionId": "897eadae-ee2d-43f9-a97b-1a9d9c682d6f",
            "startedAt": "2023-10-04T15:48:20.000Z",
            "completedAt": "2023-10-04T15:48:42.000Z",
            "type": "collections.create.succeeded",
            "data": {
              "chain": "polygon",
              "txId": "0x919ec33c1ceffd292d1d0cdd9675ffcc0af31a1f34622edd4865a9ca9fa82aa1",
              "collection": {
                "id": "897eadae-ee2d-43f9-a97b-1a9d9c682d6f",
                "contractAddress": "0x59195995f248450267AD40CAc1d79fAAba290467"
              }
            },
            "resource": "https://crossmint.com/api/2022-06-09/collections/897eadae-ee2d-43f9-a97b-1a9d9c682d6f"
          }
          ```

          ```json Solana theme={null}
          {
            "actionId": "01ac4b77-9bc9-42d3-a110-b0572ec299fd",
            "startedAt": "2023-10-04T15:50:12.000Z",
            "completedAt": "2023-10-04T15:50:23.000Z",
            "type": "collections.create.succeeded",
            "data": {
              "chain": "solana",
              "txId": "2M4tFbGWFPWAjHmZdssoTiTRjxx43nRd3vt9RpQ3wLWsW69duUhvEQrDvsyfafnQNoh6LmDQg4KPLvffgCskkwoV",
              "collection": {
                "id": "01ac4b77-9bc9-42d3-a110-b0572ec299fd",
                "mintAddress": "JCpAQcjqWCwTpRPsMumsXtg3A4SGMXbxVbowu8qrntqt"
              }
            },
            "resource": "https://a5b6-181-167-232-117.ngrok-free.app/api/2022-06-09/collections/01ac4b77-9bc9-42d3-a110-b0572ec299fd"
          }
          ```
        </CodeGroup>
      </Accordion>

      <Accordion title="collections.update.succeeded">
        <CodeGroup>
          ```json EVM theme={null}
          {
            "actionId": "e0926e73-8212-4074-b934-4d6ac68cfcff",
            "startedAt": "2023-10-04T15:57:14.000Z",
            "completedAt": "2023-10-04T15:57:36.000Z",
            "type": "collections.update.succeeded",
            "data": {
              "chain": "polygon",
              "txId": "0x919ec33c1ceffd292d1d0cdd9675ffcc0af31a1f34622edd4865a9ca9fa82aa1",
              "collection": {
                "id": "897eadae-ee2d-43f9-a97b-1a9d9c682d6f",
                "contractAddress": "0x59195995f248450267AD40CAc1d79fAAba290467"
              },
              "changes": ["supplyLimit"]
            },
            "resource": "https://crossmint.com/api/2022-06-09/collections/e0926e73-8212-4074-b934-4d6ac68cfcff",
            "timestamp": 1696424259573
          }
          ```
        </CodeGroup>
      </Accordion>

      <Accordion title="nfts.create.succeeded">
        <CodeGroup>
          ```json EVM theme={null}
          {
            "type": "nfts.create.succeeded",
            "actionId": "771d7e38-2890-47d7-b733-a1462736b528",
            "startedAt": "2023-10-04T19:59:47.000Z",
            "completedAt": "2023-10-04T20:00:00.000Z",
            "data": {
              "chain": "polygon",
              "txId": "0x919ec33c1ceffd292d1d0cdd9675ffcc0af31a1f34622edd4865a9ca9fa82aa1",
              "collection": {
                "id": "default-polygon",
                "contractAddress": "0x2DdDDEe8dad8b2ec123F5ceEc3E8dA4E57C0ed29"
              },
              "recipient": {
                "walletAddress": "0x10324e5B8879CA6662ff83617F74b0AaD251b819",
                "email": "recipient@crossmint.com"
              },
              "token": {
                "id": "771d7e38-2890-47d7-b733-a1462736b528",
                "owner": {
                  "walletAddress": "0x10324e5B8879CA6662ff83617F74b0AaD251b819"
                },
                "tokenId": "15"
              }
            },
            "resource": "https://crossmint.com/api/2022-06-09/collections/default-polygon/nfts/771d7e38-2890-47d7-b733-a1462736b528"
          }
          ```

          ```json Solana theme={null}
          {
            "type": "nfts.create.succeeded",
            "actionId": "2c5f9ec6-ae68-4e17-a671-db4af2208a2d",
            "startedAt": "2023-10-04T20:01:21.000Z",
            "completedAt": "2023-10-04T20:01:27.000Z",
            "data": {
              "chain": "solana",
              "txId": "2M4tFbGWFPWAjHmZdssoTiTRjxx43nRd3vt9RpQ3wLWsW69duUhvEQrDvsyfafnQNoh6LmDQg4KPLvffgCskkwoV",
              "collection": {
                "id": "default-solana",
                "mintAddress": "qCTMcsRBYYt1YKDAkJnstjgXJU625YX5LBfwsUi1Mn4"
              },
              "recipient": {
                "walletAddress": "EjLpq6RAxzPuwjcwJ2C6ZjwrFZuqhu2CiVTDzkSSCE5B",
                "email": "recipient@crossmint.com"
              },
              "token": {
                "id": "2c5f9ec6-ae68-4e17-a671-db4af2208a2d",
                "owner": {
                  "walletAddress": "EjLpq6RAxzPuwjcwJ2C6ZjwrFZuqhu2CiVTDzkSSCE5B"
                },
                "mintHash": "Gec66rG8Rj6Q2nqaFpGRvggiAfriMb93o28qGSeeY1gJ"
              }
            },
            "resource": "https://staging.crossmint.com/api/2022-06-09/collections/default-solana/nfts/2c5f9ec6-ae68-4e17-a671-db4af2208a2d",
            "timestamp": 1696449687501
          }
          ```
        </CodeGroup>
      </Accordion>

      <Accordion title="nfts.create.failed">
        <CodeGroup>
          ```json EVM theme={null}
          {
            "actionId":"cf9985d3-3341-4fd6-bd0e-548ef97a3486",
            "startedAt":"2024-02-05T21:48:17.000Z",
            "type":"nfts.create.failed",
            "data":{
              "chain":"polygon",
              "collection":{
                "id":"297199ba-c763-4464-b592-26c2ca2dbe5d",
                "contractAddress":"0x2ADBeb5e1976615883D3c5F07234E38b50e09edB"
            },
            "contractArguments":{
              "key":28
            },
            "recipient":{
              "walletAddress":"0x78359E7dF948834caFEcBE0494B010C6f7f7fA74"
            },
            "token":{
              "id":"cf9985d3-3341-4fd6-bd0e-548ef97a3486"
            },
            "error":{
              "reason":"execution_reverted",
              "message":"Minting smart contract reverted. Check 'revertReason' for details",
              "revertReason":"execution reverted: Wrong value for key",
              "callInfo":{
                  "functionName":"mintTo",
                  "arguments":{
                    "key":28,
                    "recipient":"0x78359E7dF948834caFEcBE0494B010C6f7f7fA74"
                  },
                  "calldata":"0x449a52f800000000000000000000000078359e7df948834cafecbe0494b010c6f7f7fa74000000000000000000000000000000000000000000000000000000000000001c"
              }
            }
            },
            "resource":"https://1a7a-181-110-64-58.ngrok-free.app/api/2022-06-09/collections/297199ba-c763-4464-b592-26c2ca2dbe5d/nfts/cf9985d3-3341-4fd6-bd0e-548ef97a3486",
            "timestamp":1707158908733
          }
          ```
        </CodeGroup>
      </Accordion>

      <Accordion title="nfts.update.succeeded">
        <CodeGroup>
          ```json EVM theme={null}
          {
            "type": "nfts.update.succeeded",
            "actionId": "f7fedd17-2feb-4bc9-88fa-8890ea8f99e8",
            "startedAt": "2023-10-04T20:09:27.000Z",
            "completedAt": "2023-10-04T20:09:35.000Z",
            "data": {
              "chain": "polygon",
              "txId": "0x919ec33c1ceffd292d1d0cdd9675ffcc0af31a1f34622edd4865a9ca9fa82aa1",
              "collection": {
                "id": "default-polygon",
                "contractAddress": "0x2DdDDEe8dad8b2ec123F5ceEc3E8dA4E57C0ed29"
              },
              "token": {
                "id": "210a95ab-d59c-41ef-9f60-8e41550a753e",
                "owner": {
                  "walletAddress": "0x10324e5B8879CA6662ff83617F74b0AaD251b819"
                },
                "tokenId": "16"
              },
              "changes": ["metadata"]
            },
            "resource": "https://crossmint.com/api/2022-06-09/collections/default-polygon/nfts/f7fedd17-2feb-4bc9-88fa-8890ea8f99e8",
            "timestamp": 1696450175660
          }
          ```

          ```json Solana theme={null}
          {
            "type": "nfts.update.succeeded",
            "actionId": "57d3cedd-e8e8-4509-88bc-97d6baea478f",
            "startedAt": "2023-10-04T20:07:55.000Z",
            "completedAt": "2023-10-04T20:08:01.000Z",
            "data": {
              "chain": "solana",
              "txId": "2M4tFbGWFPWAjHmZdssoTiTRjxx43nRd3vt9RpQ3wLWsW69duUhvEQrDvsyfafnQNoh6LmDQg4KPLvffgCskkwoV",
              "collection": {
                "id": "default-solana",
                "mintAddress": "qCTMcsRBYYt1YKDAkJnstjgXJU625YX5LBfwsUi1Mn4"
              },
              "token": {
                "id": "1f3f0959-417d-43a7-95f8-39e6f22d5573",
                "owner": {
                  "walletAddress": "EjLpq6RAxzPuwjcwJ2C6ZjwrFZuqhu2CiVTDzkSSCE5B"
                },
                "mintHash": "BnyGQcmU4mXMi5NMUuKTjFdYkg79RZoBX3qCWdXZVcyb"
              },
              "changes": ["metadata"]
            },
            "resource": "https://crossmint.com/api/2022-06-09/collections/default-solana/nfts/57d3cedd-e8e8-4509-88bc-97d6baea478f",
            "timestamp": 1696450081841
          }
          ```
        </CodeGroup>
      </Accordion>
    </AccordionGroup>

    ### 3. Pre & post processing

    Add your pre and post processing logic when setting up your webhook listener. For example, you can call back to your database when a certain id has succeeded or even use <a href="https://sendgrid.com/">Sendgrid</a> or <a href="https://www.emailjs.com/">EmailJS</a> to send an email to a recipient when a mint completes.

    ### 4. Setting Up Webhooks on the Crossmint Console

    Add an endpoint for the event `mint.succeeded` by following [this guide](/introduction/platform/webhooks/add-endpoint).

    Once completed, you'll be redirected to the endpoint details page. Here, you can find the signing secret for [verifying webhooks](/introduction/platform/webhooks/verify-webhooks) and view a table of all triggered webhook events.

    <Frame type="simple">
      <img alt="Screenshot of webhooks status UI" />
    </Frame>

    The final step is to test the endpoint. To do so, mint one or two NFTs with the API and observe the responses to verify setup success.

    ## Webhook video walkthrough

    <Frame type="simple">
      <iframe />
    </Frame>
  </Tab>
</Tabs>


# Quickstart ⚡
Source: https://docs.crossmint.com/minting/quickstarts/credentials

Mint credentials that users control, share, and verify anywhere in under 5 minutes

In this quickstart you will learn how to create, issue, and verify credentials.

## What are credentials?

A digital credential is an electronic record issued by a trusted source that certifies specific information about a person or entity. Crossmint makes it easy to issue, manage, and verify credentials onchain, following the [W3C VC standard](https://www.w3.org/TR/vc-data-model-2.0/).

<Frame type="simple">
  <img alt="Verifiable Credentials API" />
</Frame>

<Note>
  Verifiable Credentials is an Enterprise feature. <a href="https://www.crossmint.com/contact/sales">Contact Sales</a>
  for access.
</Note>

## Integration steps

### 1. Create a Developer Account

<Snippet />

### 2. Get an API Key

<Snippet />

Within the "Server-side keys" section, click the "Create new key" button in the top right.
Then, check the scopes `credentials.create`, `credentials.read`, and `credentials:templates.create` under the "Verifiable Credentials"
category and create your key. Save this key for the next step.

### 3. Create a Credential Template

Every Verifiable Credential must belong to a template. Verifiable Credentials within a template share the same schema (referred to as "type" in the template definition), default-metadata, encryption, storage, and chain configurations. A credential template is equivalent to an NFT collection.

For the purpose of this quickstart, we will create a template with the following parameters:

* Type: `crossmint:bedea4c5-4cea-425b-99c7-797ecbc8bc13:CourseCompletionCertificate`. Types allow you to specify the attributes you are interested in certifying. They also act as a protective measure, preventing the addition of unauthorized fields and, as a result, the tampering of the Verifiable Credential. You can [define your own](/minting/verifiable-credentials/integrate/create-credential-types).

* Encryption: `none`. This means the Verifiable Credential data will be stored in plain text. To encrypt the data, read about the supported [encryption modalities](/minting/verifiable-credentials/integrate/encrypt-credentials).

* Storage: `crossmint`. This means the Verifiable Credential data will be stored by Crossmint. To store the data at the location of your choice, or in decentralized storage, read about the supported [storage modalities](/minting/verifiable-credentials/integrate/store-credentials).

The credential’s revocation state is stored in the chain provided (`polygon-amoy`), along with public (non-confidential) metadata related to your credential’s template.

```javascript createTemplate.js theme={null}
const apiKey = "YOUR_API_KEY";
const env = "staging"; // or "www"

const url = `https://${env}.crossmint.com/api/v1-alpha1/credentials/templates`;
const options = {
    method: "POST",
    headers: {
        accept: "application/json",
        "content-type": "application/json",
        "x-api-key": apiKey,
    },
    body: JSON.stringify({
        credentials: {
            type: "crossmint:bedea4c5-4cea-425b-99c7-797ecbc8bc13:CourseCompletionCertificate",
            encryption: "none",
            storage: "crossmint",
            subject: {
                properties: {
                    course: {
                        type: "string",
                        title: "Course",
                        description: "Course name",
                    },
                    grade: {
                        type: "string",
                        title: "Grade",
                        description: "Grade received",
                    },
                },
                required: ["course", "grade"],
            },
        },
        metadata: {
            name: "Certificate of Completion",
            description: "A certificate issued upon completion of a course",
            imageUrl: "https://www.crossmint.com/assets/crossmint/logo.png",
        },
        chain: "polygon-amoy",
    }),
};

fetch(url, options)
    .then((res) => res.json())
    .then((json) => console.log(json))
    .catch((err) => console.error("error:" + err));
```

<Accordion title="Example response">
  ```json JSON theme={null}
  {
    "id": "a9e3016b-66f0-40ab-8d72-6546fddc7b72",
    "metadata": {
      "description": "A certificate issued upon completion of a course",
      "name": "Certificate of Completion",
      "imageUrl": "ipfs://QmaToZn4VEjF7q4CAudPaNka6AD484xuuEZSXmTLJPDLVE"
    },
    "fungibility": "non-fungible",
    "onChain": { "chain": "polygon-amoy", "type": "erc-721" },
    "subscription": { "enabled": false },
    "actionId": "a9e3016b-66f0-40ab-8d72-6546fddc7b72"
  }
  ```
</Accordion>

Save the `id` from the response as your `TEMPLATE_ID` for the next step.

### 4. Issue a Credential

With a template created, we can start issuing credentials. To do this, we need to enter the subject’s email address, or wallet address, if they have one.

Then, we need to specify the exact data required by the Verifiable Credential type, i.e. course name and grade. The credential’s contents are identified by the “subject” key within the credential.

<Note>
  If you don't include an expiration date, the credential will not expire. You can always revoke the credential in the
  future, if necessary.
</Note>

```javascript issueCredential.js theme={null}
const apiKey = "YOUR_API_KEY";
const env = "staging"; // or "www"
const templateId = "YOUR_TEMPLATE_ID";
const recipientEmail = "TEST_EMAIL_ADDRESS";

const url = `https://${env}.crossmint.com/api/v1-alpha1/credentials/templates/${templateId}/vcs`;
const options = {
    method: "POST",
    headers: {
        accept: "application/json",
        "content-type": "application/json",
        "x-api-key": apiKey,
    },
    body: JSON.stringify({
        recipient: `email:${recipientEmail}:polygon-amoy`,
        credential: {
            // The CourseCompletionCertificate credential type requires course and grade declarations
            subject: {
                course: "Blockchain 101",
                grade: "A",
            },
            expiresAt: "2034-02-02",
        },
    }),
};

fetch(url, options)
    .then((res) => res.json())
    .then((json) => console.log(json))
    .catch((err) => console.error("error:" + err));
```

<Accordion title="Example response">
  ```json JSON theme={null}
  {
    "id": "6728f773-61af-4732-a34f-b5a50d8b9872",
    "onChain": {
      "status": "pending",
      "chain": "polygon-amoy",
      "contractAddress": "0x45c9597b5441289C134E554990cdb647f65df5FB"
    },
    "credentialId": "urn:uuid:e6b3dc76-a337-437b-ac1b-3d330e66e1a6",
    "actionId": "6728f773-61af-4732-a34f-b5a50d8b9872"
  }
  ```
</Accordion>

Save the credential `id` from the response for the next step.

### 5. Retrieve a Credential

​​You can retrieve a Verifiable Credential using different identifiers associated with the credential itself or the NFT associated with the credential.

* [Get Verifiable Credential by ID](/api-reference/verifiable-credentials/credentials/retrieve-credential-by-id) uses the format: `urn:uuid:<UUID>`
* [Get Verifiable Credential by NFT Locator](/api-reference/verifiable-credentials/credentials/retrieve-credential-by-nft-locator) uses the format: `<chain>:<contractAddress>:<tokenId>`
* [Get Verifiable Credential by NFT ID](/api-reference/verifiable-credentials/credentials/retrieve-credential-by-nft) uses crossmint's internal NFT ID

```javascript getCredential.js theme={null}
const apiKey = "YOUR_API_KEY";
const env = "staging"; // or "www"
const credentialId = "YOUR_CREDENTIAL_ID";

const url = `https://${env}.crossmint.com/api/v1-alpha1/credentials/${credentialId}`;
const options = {
    method: "GET",
    headers: {
        accept: "application/json",
        "x-api-key": apiKey,
    },
};

fetch(url, options)
    .then((res) => res.json())
    .then((json) => console.log(json))
    .catch((err) => console.error("error:" + err));
```

<Accordion title="Example response">
  ```json JSON theme={null}
  {
    "unencryptedCredential": {
      "id": "urn:uuid:e6b3dc76-a337-437b-ac1b-3d330e66e1a6",
      "credentialSubject": {
        "course": "Blockchain 101",
        "grade": "A",
        "id": "did:polygon-amoy:0x2da3151C266185c4861b45277dbbe56Cb613963e"
      },
      "validUntil": "2034-02-02",
      "nft": {
        "tokenId": "1",
        "chain": "polygon-amoy",
        "contractAddress": "0x45c9597b5441289C134E554990cdb647f65df5FB"
      },
      "issuer": {
        "id": "did:polygon-amoy:0x1785A5DE9e0F06791393739De496a0a2c9ACA855"
      },
      "type": ["VerifiableCredential", "Course completion"],
      "validFrom": "2025-05-28T14:31:03.514Z",
      "@context": ["https://www.w3.org/ns/credentials/v2"],
      "proof": {
        "verificationMethod": "did:polygon-amoy:0x1785A5DE9e0F06791393739De496a0a2c9ACA855#evmAddress",
        "created": "2025-05-28T14:31:03.514Z",
        "proofPurpose": "assertionMethod",
        "type": "EthereumEip712Signature2021",
        "proofValue": "0x17f624a23b620de2867dbefbeb5214e5693a4b470897302f91f870383d4f5ee7754600d1fb72b73c926fed56aac20724ce87d49e0078e0b13f02734a199ceaa61b",
        "eip712": [Object]
      }
    }
  }
  ```
</Accordion>

### 6. Verify a Credential

<Note>
  Verifying a credential can be done in different ways, the easiest one is to call the verify API route. You can also accomplish
  this with the [SDK](/sdk-reference/credentials/introduction).
</Note>

To verify a credential's validity via API use the following script:

```javascript verifyCredential.js theme={null}
const apiKey = "YOUR_API_KEY";
const env = "staging"; // or "www"
const credentialId = "YOUR_CREDENTIAL_ID";

const url = `https://${env}.crossmint.com/api/v1-alpha1/credentials/verification/verify`;
const options = {
    method: "POST",
    headers: {
        "accept": "application/json",
        "content-type": "application/json",
        "x-api-key": apiKey,
    },
    body: JSON.stringify({
        // paste credential object here
        credential : {
            id: "urn:uuid:e6b3dc76-a337-437b-ac1b-3d330e66e1a6",
            ...
        }
    })
};

fetch(url, options)
    .then((res) => res.json())
    .then((json) => console.log(json))
    .catch((err) => console.error("error:" + err));
```

<Accordion title="Example response">
  ```json JSON theme={null}
  { isValid: true }
  ```
</Accordion>

### 7. Revoke a Credential (Optional)

To revoke a credential, you can directly use the [revoke credential API](/api-reference/verifiable-credentials/credentials/revoke-credential):

```javascript revokeCredential.js theme={null}
const apiKey = "YOUR_API_KEY";
const env = "staging"; // or "www"
const credentialId = "YOUR_CREDENTIAL_ID";

const url = `https://${env}.crossmint.com/api/v1-alpha1/credentials/${credentialId}`;
const options = {
    method: "DELETE",
    headers: {
        accept: "application/json",
        "x-api-key": apiKey,
    },
};

fetch(url, options)
    .then((res) => res.json())
    .then((json) => console.log(json))
    .catch((err) => console.error("error:" + err));
```

<Accordion title="Example response">
  ```json JSON theme={null}
  {
    "actionId": "15bfe43c-3d5d-4d03-9e20-6dbaf01f038f",
    "action": "nfts.delete",
    "status": "pending",
    "data": {
      "chain": "polygon-amoy",
      "collection": {
        "id": "a9e3016b-66f0-40ab-8d72-6546fddc7b72",
        "contractAddress": "0x45c9597b5441289C134E554990cdb647f65df5FB"
      },
      "token": { 
        "id": "6728f773-61af-4732-a34f-b5a50d8b9872", 
        "tokenId": "1" 
      }
    },
    "startedAt": "2025-05-28T16:53:11.000Z",
    "resource": "https://staging.crossmint.com/api/2022-06-09/collections/a9e3016b-66f0-40ab-8d72-6546fddc7b72/nfts/15bfe43c-3d5d-4d03-9e20-6dbaf01f038f"
  }
  ```
</Accordion>

## Learn More

For more detailed information about Verifiable Credentials, please visit the dedicated [Verifiable Credentials section](/verifiable-credentials/introduction) which includes comprehensive guides on:

<CardGroup>
  <Card title="Create Credential Types" icon="file" href="/minting/verifiable-credentials/integrate/create-credential-types">
    Learn how to define the structure of your credentials.
  </Card>

  <Card title="Create Credential Templates" icon="cloud" href="/minting/verifiable-credentials/integrate/create-credential-templates">
    Create reusable templates for your credentials.
  </Card>

  <Card title="Issue Credentials" icon="file-pen" href="/minting/verifiable-credentials/integrate/issue-credentials">
    Issue credentials to users.
  </Card>

  <Card title="Verify Credentials" icon="shield-check" href="/minting/verifiable-credentials/integrate/verify-credentials">
    Verify the authenticity of credentials.
  </Card>
</CardGroup>


# Quickstart ⚡
Source: https://docs.crossmint.com/minting/quickstarts/ip

Mint IP credentials for creators to secure their work in under 5 minutes

In this quickstart you will learn how to create and manage intellectual property (IP) assets.

<Note>Contact [sales](https://www.crossmint.com/contact/sales) to enable this API on your project.</Note>

## What are IP credentials?

IP credentials are onchain records of intellectual property rights and authorship, enabled by Story Protocol's infrastructure and issued using Crossmint's APIs.

## Integration steps

### 1. Create a Developer Account

<Snippet />

### 2. Get an API Key

<Snippet />

Within the "Server-side keys" section, click the "Create new key" button in the top right.
Then, check the necessary scopes under the "Minting API" category: `nfts.create`, `nfts.read`, `collections.create`, `nfts.update` and create your key. Save this key for the next step.

### 3. Create an IP Collection

First, let's create an IP collection to hold our IP assets:

```javascript createIPCollection.js theme={null}
const apiKey = "YOUR_API_KEY";
const env = "staging"; // or "www"

const url = `https://${env}.crossmint.com/api/v1/ip/collections`;
const options = {
    method: "POST",
    headers: {
        accept: "application/json",
        "content-type": "application/json",
        "x-api-key": apiKey,
    },
    body: JSON.stringify({
        metadata: {
            description: "A collection of intellectual property assets",
            name: "My IP Collection",
            symbol: "MPA",
        },
        chain: "story-testnet",
    }),
};

fetch(url, options)
    .then((res) => res.json())
    .then((json) => console.log(json))
    .catch((err) => console.error("error:" + err));
```

<Accordion title="Example response">
  Here is an example response returned from the API call above:

  ```json JSON theme={null}
  {
      "id": "7f5e653d-2c9d-4025-98c8-8245c128ad10",
      "actionId": "7f5e653d-2c9d-4025-98c8-8245c128ad10",
      "metadata": {
          "name": "My IP Collection",
          "symbol": "MPA",
          "description": "A collection of intellectual property assets"
      },
      "onChain": {
          "chain": "story-testnet"
      }
  }
  ```
</Accordion>

Save the collection `id` from the response for the next step.

### 4. Create an IP Asset

Now, let's create an IP asset within our collection:

```javascript createIPAsset.js theme={null}
const apiKey = "YOUR_API_KEY";
const env = "staging"; // or "www"
const collectionId = "YOUR_COLLECTION_ID";

const url = `https://${env}.crossmint.com/api/v1/ip/collections/${collectionId}/ipassets`;
const options = {
    method: "POST",
    headers: {
        accept: "application/json",
        "content-type": "application/json",
        "x-api-key": apiKey,
    },
    body: JSON.stringify({
        owner: "email:creator@example.com:story-testnet",
        nftMetadata: {
            name: "Snowflake Funk",
            description: "A disco song for the winter holidays",
            image: "https://cdn2.suno.ai/image_large_c001fd6e-d6cd-474f-a7b6-6e6a9b3e2515.jpeg",
        },
        ipAssetMetadata: {
            title: "Snowflake Funk",
            createdAt: "2025-02-11T11:13:00",
            ipType: "music",
            image: "https://cdn2.suno.ai/image_large_example.jpeg",
            imageHash: "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
            mediaUrl: "https://cdn1.suno.ai/c001fd6e-d6cd-474f-a7b6-6e6a9b3e2515.mp3",
            mediaHash: "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
            mediaType: "audio/mpeg",
            creators: [
                {
                    name: "John Doe",
                    email: "john.doe@example.com",
                    crossmintUserLocator: "email:john.doe@example.com:story-testnet",
                    contributionPercent: 100,
                },
            ],
            media: [
                {
                    name: "Snowflake Funk",
                    url: "https://cdn1.suno.ai/c001fd6e-d6cd-474f-a7b6-6e6a9b3e2515.mp3",
                    mimeType: "audio/mpeg",
                },
            ],
            attributes: [
                {
                    key: "Suno Artist",
                    value: "InfluentialCoda427",
                },
                {
                    key: "Source",
                    value: "Suno.com",
                },
            ],
        },
    }),
};

fetch(url, options)
    .then((res) => res.json())
    .then((json) => console.log(json))
    .catch((err) => console.error("error:" + err));
```

<Accordion title="Example response">
  Here is an example response returned from the API call above:

  ```json JSON theme={null}
  {
      "id": "49b9e141-8fd8-45dc-9646-13a3439c6f20",
      "actionId": "49b9e141-8fd8-45dc-9646-13a3439c6f20",
      "nftMetadata": {
          "name": "Snowflake Funk",
          "image": "https://cdn2.suno.ai/image_large_c001fd6e-d6cd-474f-a7b6-6e6a9b3e2515.jpeg",
          "description": "A disco song for the winter holidays"
      },
      "ipAssetMetadata": {
          "title": "Snowflake Funk",
          "createdAt": "2025-02-11T11:13:00",
          "creators": [
              {
                  "name": "John Doe",
                  "email": "john.doe@example.com",
                  "crossmintUserLocator": "email:john.doe@example.com:story-testnet",
                  "contributionPercent": 100
              }
          ],
          "media": [
              {
                  "name": "Snowflake Funk",
                  "url": "https://cdn1.suno.ai/c001fd6e-d6cd-474f-a7b6-6e6a9b3e2515.mp3",
                  "mimeType": "audio/mpeg"
              }
          ],
          "attributes": [
              {
                  "key": "Suno Artist",
                  "value": "InfluentialCoda427"
              },
              {
                  "key": "Source",
                  "value": "Suno.com"
              }
          ],
          "ipType": "music"
      },
      "licenseTerms": [
          {
              "type": "non-commercial-social-remixing"
          }
      ],
      "onChain": {
          "chain": "story-testnet",
          "contractAddress": "0x82a72DfFb175DF8AB6d3C2E3888D5314a50C30D0",
          "status": "pending"
      }
  }
  ```
</Accordion>

Save the IP asset `id` from the response for the next steps.

### 5. Retrieve an IP Asset

To retrieve an IP asset:

```javascript getIPAsset.js theme={null}
const apiKey = "YOUR_API_KEY";
const env = "staging"; // or "www"
const collectionId = "YOUR_COLLECTION_ID";
const ipAssetId = "YOUR_IP_ASSET_ID";

const url = `https://${env}.crossmint.com/api/v1/ip/collections/${collectionId}/ipassets/${ipAssetId}`;
const options = {
    method: "GET",
    headers: {
        accept: "application/json",
        "x-api-key": apiKey,
    },
};

fetch(url, options)
    .then((res) => res.json())
    .then((json) => console.log(json))
    .catch((err) => console.error("error:" + err));
```

<Accordion title="Example response">
  Here is an example response returned from the API call above:

  ```json JSON theme={null}
  {
      "id": "49b9e141-8fd8-45dc-9646-13a3439c6f20",
      "actionId": "49b9e141-8fd8-45dc-9646-13a3439c6f20",
      "nftMetadata": {
          "name": "Snowflake Funk",
          "image": "ipfs://QmYA9HyvoPmxvsMx216MFkoydtrA1sSxX5A5ixeu5S9VKF",
          "description": "A disco song for the winter holidays"
      },
      "ipAssetMetadata": {
          "title": "Snowflake Funk",
          "createdAt": "2025-02-11T11:13:00",
          "creators": [
              {
                  "name": "John Doe",
                  "email": "john.doe@example.com",
                  "crossmintUserLocator": "email:john.doe@example.com:story-testnet",
                  "contributionPercent": 100
              }
          ],
          "media": [
              {
                  "name": "Snowflake Funk",
                  "url": "https://cdn1.suno.ai/c001fd6e-d6cd-474f-a7b6-6e6a9b3e2515.mp3",
                  "mimeType": "audio/mpeg"
              }
          ],
          "attributes": [
              {
                  "key": "Suno Artist",
                  "value": "InfluentialCoda427"
              },
              {
                  "key": "Source",
                  "value": "Suno.com"
              }
          ],
          "ipType": "music"
      },
      "licenseTerms": [
          {
              "type": "non-commercial-social-remixing",
              "uri": ""
          }
      ],
      "onChain": {
          "chain": "story-testnet",
          "contractAddress": "0x82a72DfFb175DF8AB6d3C2E3888D5314a50C30D0",
          "status": "success",
          "ipAssetId": "0xe20936B1C974E7C550b483243719A1B1886D2c6c",
          "tokenId": "1",
          "txId": "0x4e505bcd429960d3031bd8d1f27bb7ffd2cfa251498c12c16cf2375a14d2bd51",
          "owner": "0x1a042BBEFb116072E6AEF8304f9B7D15aA2b4BCF",
          "explorerLink": "https://aeneid.explorer.story.foundation/ipa/0xe20936B1C974E7C550b483243719A1B1886D2c6c"
      }
  }
  ```
</Accordion>

### 6. Update an IP Asset

If needed, you can update an IP asset:

```javascript updateIPAsset.js theme={null}
const apiKey = "YOUR_API_KEY";
const env = "staging"; // or "www"
const collectionId = "YOUR_COLLECTION_ID";
const ipAssetId = "YOUR_IP_ASSET_ID";

const url = `https://${env}.crossmint.com/api/v1/ip/collections/${collectionId}/ipassets/${ipAssetId}`;
const options = {
    method: "PATCH",
    headers: {
        accept: "application/json",
        "content-type": "application/json",
        "x-api-key": apiKey,
    },
    body: JSON.stringify({
        ipAssetMetadata: {
            title: "Snowflake Funk",
            createdAt: "2025-02-11T11:13:00",
            ipType: "music",
            creators: [
                {
                    name: "John Doe",
                    email: "john.doe@example.com",
                    crossmintUserLocator: "email:john.doe@example.com:story-testnet",
                    contributionPercent: 90,
                },
                {
                    name: "Frank L",
                    crossmintUserLocator: "email:frank.l@example.com:story-testnet",
                    contributionPercent: 10,
                },
            ],
        },
    }),
};

fetch(url, options)
    .then((res) => res.json())
    .then((json) => console.log(json))
    .catch((err) => console.error("error:" + err));
```

<Accordion title="Example response">
  Here is an example response returned from the API call above:

  ```json JSON theme={null}
  {
      "id": "75a45061-febb-4344-84d6-959276a5696a",
      "actionId": "75a45061-febb-4344-84d6-959276a5696a",
      "nftMetadata": {
          "name": "Snowflake Funk",
          "image": "ipfs://QmYA9HyvoPmxvsMx216MFkoydtrA1sSxX5A5ixeu5S9VKF",
          "description": "A disco song for the winter holidays"
      },
      "ipAssetMetadata": {
          "title": "Snowflake Funk",
          "createdAt": "2025-02-11T11:13:00",
          "creators": [ ... ],
          "ipType": "music"
      },
      "licenseTerms": [ { "type": "non-commercial-social-remixing", "uri": "" } ],
      "onChain": {
          "chain": "story-testnet",
          "contractAddress": "0x82a72DfFb175DF8AB6d3C2E3888D5314a50C30D0",
          "status": "pending"
      }
  }
  ```
</Accordion>

## Learn More

For more detailed information about IP assets, please refer to the API reference:

<CardGroup>
  <Card title="Create IP Collection" icon="file" href="/api-reference/ip/create-ip-collection">
    Learn how to create IP collections.
  </Card>

  <Card title="Create IP Asset" icon="cloud" href="/api-reference/ip/create-ip-asset">
    Create IP assets within collections.
  </Card>

  <Card title="Update IP Asset" icon="file-pen" href="/api-reference/ip/update-ip-asset">
    Update existing IP assets.
  </Card>

  <Card title="Get IP Assets" icon="magnifying-glass" href="/api-reference/ip/get-ip-assets">
    Retrieve IP assets from collections.
  </Card>
</CardGroup>


# Non-Fungible Tokens (NFTs)
Source: https://docs.crossmint.com/minting/quickstarts/nfts

Mint an NFT in under 5 minutes

In this quickstart you will learn how to create a unique NFT and deliver it to a wallet or email address.

<Frame type="simple">
  <img alt="Minting API" />
</Frame>

## Integration steps

<Tabs>
  <Tab title="EVM Chains">
    ### 1. Create a Developer Account

    <Snippet />

    ### 2. Get an API Key

    <Snippet />

    Within the "Server-side keys" section, click the "Create new key" button in the top right.
    Then, check the scopes `nfts.create` and `nfts.read` under the "Minting API"
    category and create your key. Save this key for the next step.

    ### 3. Mint an NFT

    We're almost there! With our key created, we're now going to write a small
    function that creates an NFT and delivers it to a user.

    Create a file (e.g. `mintNFT.js`) and enter this code into it:

    ```javascript mintNFT.js theme={null}
    const apiKey = "YOUR_API_KEY";
    const chain = "polygon-amoy"; // or "ethereum-sepolia", "base-sepolia", etc.
    const env = "staging"; // or "www"
    const recipientEmail = "TEST_EMAIL_ADDRESS";
    const recipientAddress = `email:${recipientEmail}:${chain}`;

    const url = `https://${env}.crossmint.com/api/2022-06-09/collections/default/nfts`;
    const options = {
        method: "POST",
        headers: {
            "accept": "application/json",
            "content-type": "application/json",
            "x-api-key": apiKey,
        },
        body: JSON.stringify({
            recipient: recipientAddress,
            metadata: {
                name: "Crossmint Test NFT",
                image: "https://picsum.photos/400",
                description: "My first NFT using Crossmint",
            },
        }),
    };

    fetch(url, options)
        .then((res) => res.json())
        .then((json) => console.log(json))
        .catch((err) => console.error("error:" + err));
    ```

    This code creates an NFT, uploads it to the blockchain, and delivers it to a <Tooltip>user wallet</Tooltip>, attached to the email address provided. Before running it, be sure to fill in values for:

    * `YOUR_API_KEY` with the key obtained in the prior step.
    * `TEST_EMAIL_ADDRESS` with an email address you control, for testing.

    Now, run the `mintNFT.js` script.

    ```bash theme={null}
    node mintNFT.js
    ```

    After a few seconds, it should return a response indicating the mint has
    started processing. Check the full response and save its <Tooltip>`actionId` property</Tooltip>, as you'll use it later.

    <Accordion title="Example response">
      Here is an example response returned from the API call above:

      ```json JSON theme={null}
      {
          "id": "b3f61f22-c30e-424d-a5ab-d0cbc5c41aab",
          "onChain": {
              "status": "pending",
              "chain": "polygon-amoy",
              "contractAddress": "0x921Bc21bf3Fd6568cdC2C904F75b83556062c3d0"
          },
          "actionId": "b3f61f22-c30e-424d-a5ab-d0cbc5c41aab"
      }
      ```
    </Accordion>

    ### 4. Confirm Delivery of the NFT

    The mint has started processing. However, blockchains can take a few seconds (or,
    at times of extreme network congestion, even minutes) to confirm the operation.

    Before showing the user a success screen, the next step is checking the
    status of the mint.

    To do this, grab the `actionId` received at the end of step 3 and use it
    alongside your API key in one of the snippets below.

    <CodeGroup>
      ```javascript mintStatus.js theme={null}
      const apiKey = "<YOUR_API_KEY>";
      const env = "staging"; // or "www"
      const actionId = "<MINT_ACTION_ID>";

      const url = `https://${env}.crossmint.com/api/2022-06-09/actions/${actionId}`;
      const options = {
          method: "GET",
          headers: { "X-API-KEY": apiKey },
      };

      fetch(url, options)
          .then((response) => response.json())
          .then((response) => console.log(response))
          .catch((err) => console.error(err));
      ```

      ```bash cURL theme={null}
      # Replace "staging" with "www" for production, and fill in your api key and mint action id
      ENV="staging"
      API_KEY="<YOUR_API_KEY>"
      MINT_ACTION_ID="<MINT_ACTION_ID>"
      curl --header "x-api-key: $API_KEY" \
        -X GET \
        https://${ENV}.crossmint.com/api/2022-06-09/actions/${MINT_ACTION_ID}
      ```
    </CodeGroup>

    <br />

    <Accordion title="Example response">
      Here is an example response from calling the status API:

      ```json JSON theme={null}
      {
        "actionId": "b3f61f22-c30e-424d-a5ab-d0cbc5c41aab",
        "action": "nfts.create",
        "status": "success",
        "data": {
          "collection": {...},
          "recipient": {...},
          "token": {...}
        },
        "startedAt": "2025-05-27T02:41:08.000Z",
        "completedAt": "2025-05-27T02:41:40.000Z",
        "resource": "https://staging.crossmint.com/api/2022-06-09/collections/default-polygon-amoy/nfts/b3f61f22-c30e-424d-a5ab-d0cbc5c41aab"
      }
      ```
    </Accordion>

    Pay attention to the "status" field. Once it says "success": <br /><br />
    **Congratulations. You have minted your first NFT** 🥷 🎉

    <Note>
      For scalable production applications, consider using [webhooks](/minting/nfts/integrate/webhooks-and-status-apis) to
      determine when your NFT has been minted, instead of periodically polling for its status via the API.
    </Note>
  </Tab>

  <Tab title="Solana">
    ### 1. Create a Developer Account

    <Snippet />

    ### 2. Get an API Key

    <Snippet />

    Within the "Server-side keys" section, click the "Create new key" button in the top right.
    Then, check the scopes `nfts.create` and `nfts.read` under the "Minting API"
    category and create your key. Save this key for the next step.

    ### 3. Mint an NFT

    We're almost there! With our key created, we're now going to write a small
    function that creates an NFT and delivers it to a user.

    Create a file (e.g. `mintNFT.js`) and enter this code into it:

    ```javascript mintNFT.js theme={null}
    const apiKey = "YOUR_API_KEY";
    const chain = "solana";
    const env = "staging"; // or "www"
    const recipientEmail = "TEST_EMAIL_ADDRESS";
    const recipientAddress = `email:${recipientEmail}:${chain}`;

    const url = `https://${env}.crossmint.com/api/2022-06-09/collections/default-solana/nfts`;
    const options = {
        method: "POST",
        headers: {
            "accept": "application/json",
            "content-type": "application/json",
            "x-api-key": apiKey,
        },
        body: JSON.stringify({
            recipient: recipientAddress,
            metadata: {
                name: "Crossmint Test NFT",
                image: "https://picsum.photos/400",
                description: "My first NFT using Crossmint",
            },
        }),
    };

    fetch(url, options)
        .then((res) => res.json())
        .then((json) => console.log(json))
        .catch((err) => console.error("error:" + err));
    ```

    This code creates an NFT, uploads it to the Solana blockchain, and delivers it to a <Tooltip>user wallet</Tooltip>, attached to the email address provided. Before running it, be sure to fill in values for:

    * `YOUR_API_KEY` with the key obtained in the prior step.
    * `TEST_EMAIL_ADDRESS` with an email address you control, for testing.

    Now, run the `mintNFT.js` script.

    ```bash theme={null}
    node mintNFT.js
    ```

    After a few seconds, it should return a response indicating the mint has
    started processing. Check the full response and save its <Tooltip>`actionId` property</Tooltip>, as you'll use it later.

    <Accordion title="Example response">
      Here is an example response returned from the API call above:

      ```json JSON theme={null}
      {
          "id": "cace8d7d-e4dd-483d-a780-faf6aa9f761a",
          "onChain": {
              "status": "pending",
              "chain": "solana"
          },
          "actionId": "cace8d7d-e4dd-483d-a780-faf6aa9f761a"
      }
      ```
    </Accordion>

    ### 4. Confirm Delivery of the NFT

    The mint has started processing. However, blockchains can take a few seconds (or,
    at times of extreme network congestion, even minutes) to confirm the operation.

    Before showing the user a success screen, the next step is checking the
    status of the mint.

    To do this, grab the `actionId` received at the end of step 3 and use it
    alongside your API key in one of the snippets below.

    <CodeGroup>
      ```javascript mintStatus.js theme={null}
      const apiKey = "<YOUR_API_KEY>";
      const env = "staging"; // or "www"
      const actionId = "<MINT_ACTION_ID>";

      const url = `https://${env}.crossmint.com/api/2022-06-09/actions/${actionId}`;
      const options = {
          method: "GET",
          headers: { "X-API-KEY": apiKey },
      };

      fetch(url, options)
          .then((response) => response.json())
          .then((response) => console.log(response))
          .catch((err) => console.error(err));
      ```

      ```bash cURL theme={null}
      # Replace "staging" with "www" for production, and fill in your api key and mint action id
      ENV="staging"
      API_KEY="<YOUR_API_KEY>"
      MINT_ACTION_ID="<MINT_ACTION_ID>"
      curl --header "x-api-key: $API_KEY" \
        -X GET \
        https://${ENV}.crossmint.com/api/2022-06-09/actions/${MINT_ACTION_ID}
      ```
    </CodeGroup>

    <br />

    <Accordion title="Example response">
      Here is an example response from calling the status API:

      ```json JSON theme={null}
      {
        "actionId": "cace8d7d-e4dd-483d-a780-faf6aa9f761a",
        "action": "nfts.create",
        "status": "success",
        "data": {
          "chain": "solana",
          "txId": "5KQHjcEq7DWnD1Rzo7RW7rknY3NFeKsJ9Lxkrd1DBPPwxbv9k4JAgxELWW5rqWMd5sXrHDwYzsRMeUok3tqYvTLa",
          "collection": {...},
          "recipient": {...},
          "token": {...}
        },
        "startedAt": "2025-05-27T03:04:23.000Z",
        "completedAt": "2025-05-27T03:04:49.000Z",
        "resource": "https://staging.crossmint.com/api/2022-06-09/actions/cace8d7d-e4dd-483d-a780-faf6aa9f761a"
      }
      ```
    </Accordion>

    Pay attention to the "status" field. Once it says "success": <br /><br />
    **Congratulations. You have minted your first NFT** 🥷 🎉

    <Note>
      For scalable production applications, consider using [webhooks](/minting/nfts/integrate/webhooks-and-status-apis) to
      determine when your NFT has been minted, instead of periodically polling for its status via the API.
    </Note>
  </Tab>

  <Tab title="Compressed NFTs (Solana)">
    ### 1. Create a Developer Account

    <Snippet />

    ### 2. Get an API Key

    <Snippet />

    Within the "Server-side keys" section, click the "Create new key" button in the top right.
    Then, check the scopes `nfts.create` and `nfts.read` under the "Minting API"
    category and create your key. Save this key for the next step.

    ### 3. Mint a Compressed NFT

    We're almost there! With our key created, we're now going to write a small
    function that creates a compressed NFT and delivers it to a user.

    <Note>
      Compressed NFTs are a new standard on the Solana blockchain, for minting NFTs with the lowest cost amongst L1 and L2 blockchains, and the highest throughput (thousands of NFTs per second).
    </Note>

    Create a file (e.g. `mintCompressedNFT.js`) and enter this code into it:

    ```javascript mintCompressedNFT.js theme={null}
    const apiKey = "YOUR_API_KEY";
    const chain = "solana";
    const env = "staging"; // or "www"
    const recipientEmail = "TEST_EMAIL_ADDRESS";
    const recipientAddress = `email:${recipientEmail}:${chain}`;

    const url = `https://${env}.crossmint.com/api/2022-06-09/collections/default-solana/nfts`;
    const options = {
        method: "POST",
        headers: {
            "accept": "application/json",
            "content-type": "application/json",
            "x-api-key": apiKey,
        },
        body: JSON.stringify({
            recipient: recipientAddress,
            metadata: {
                name: "Crossmint Compressed NFT",
                image: "https://picsum.photos/400",
                description: "My first compressed NFT using Crossmint",
            },
            compressed: true,
            reuploadLinkedFiles: false
        }),
    };

    fetch(url, options)
        .then((res) => res.json())
        .then((json) => console.log(json))
        .catch((err) => console.error("error:" + err));
    ```

    This code creates a compressed NFT, uploads it to the Solana blockchain, and delivers it to a <Tooltip>user wallet</Tooltip>, attached to the email address provided. Before running it, be sure to fill in values for:

    * `YOUR_API_KEY` with the key obtained in the prior step.
    * `TEST_EMAIL_ADDRESS` with an email address you control, for testing.

    Now, run the `mintCompressedNFT.js` script.

    ```bash theme={null}
    node mintCompressedNFT.js
    ```

    <Warning>
      Current Protocol Limitations:

      * There's a 10-30 second delay between when a compressed NFT is minted and it shows in wallets.
    </Warning>

    After a few seconds, it should return a response indicating the mint has
    started processing. Check the full response and save its <Tooltip>`actionId` property</Tooltip>, as you'll use it later.

    <Accordion title="Example response">
      Here is an example response returned from the API call above:

      ```json JSON theme={null}
      {
          "actionId": "de26f73e-b0ae-4ac6-8784-39f20527d39d",
          "onChain": {
              "status": "pending",
              "chain": "solana"
          },
          "id": "de26f73e-b0ae-4ac6-8784-39f20527d39d"
      }
      ```
    </Accordion>

    ### 4. Confirm Delivery of the NFT

    The mint has started processing. However, blockchains can take a few seconds (or,
    at times of extreme network congestion, even minutes) to confirm the operation.

    Before showing the user a success screen, the next step is checking the
    status of the mint.

    To do this, grab the `actionId` received at the end of step 3 and use it
    alongside your API key in one of the snippets below.

    <CodeGroup>
      ```bash cURL theme={null}
      # Replace "staging" with "www" for production, and fill in your api key and mint action id
      ENV="staging"
      API_KEY="<YOUR_API_KEY>"
      MINT_ACTION_ID="<MINT_ACTION_ID>"
      curl --header "x-api-key: $API_KEY" \
        -X GET \
        https://${ENV}.crossmint.com/api/2022-06-09/actions/${MINT_ACTION_ID}
      ```

      ```javascript mintStatus.js theme={null}
      const apiKey = "<YOUR_API_KEY>";
      const env = "staging"; // or "www"
      const actionId = "<MINT_ACTION_ID>";

      const url = `https://${env}.crossmint.com/api/2022-06-09/actions/${actionId}`;
      const options = {
          method: "GET",
          headers: { "X-API-KEY": apiKey },
      };

      fetch(url, options)
          .then((response) => response.json())
          .then((response) => console.log(response))
          .catch((err) => console.error(err));
      ```
    </CodeGroup>

    <br />

    <Accordion title="Example response">
      Here is an example response from calling the status API:

      ```json JSON theme={null}
      {
        "actionId": "de26f73e-b0ae-4ac6-8784-39f20527d39d",
        "action": "nfts.create",
        "status": "success",
        "data": {
          "chain": "solana",
          "txId": "dLFcyYtgFrrX7VkXh8U8JUmECNykH7VASzovNzM67NPRypCzMkTnx1ffv7dB99N4YrAT2mDRqszGofKunnazbXX",
          "collection": {...},
          "recipient": {...},
          "token": {...}
        },
        "startedAt": "2025-05-27T03:09:47.000Z",
        "completedAt": "2025-05-27T03:09:52.000Z",
        "resource": "https://staging.crossmint.com/api/2022-06-09/actions/de26f73e-b0ae-4ac6-8784-39f20527d39d"
      }
      ```
    </Accordion>

    Pay attention to the "status" field. Once it says "success": <br /><br />
    **Congratulations. You have minted your first compressed NFT** 🥷 🎉

    <Card title="To explore compressed NFTs on the blockchain, you must use X-Ray" icon="magnifying-glass" href="https://xray.helius.xyz/">
      Other explorers, like Solscan, still have not added support.
    </Card>

    <Note>
      For scalable production applications, consider using [webhooks](/minting/nfts/integrate/webhooks-and-status-apis) to
      determine when your NFT has been minted, instead of periodically polling for its status via the API.
    </Note>
  </Tab>
</Tabs>

## View your NFTs

1. If the NFTs were delivered to an <Tooltip>**email address**</Tooltip>, the recipient can see them by:

   * Logging into their wallet from Crossmint's [website](https://www.crossmint.com). For staging, they must use [https://staging.crossmint.com](https://staging.crossmint.com).
   * From your website if you use [embedded wallets](/wallets/overview). See the API for [getting the NFTs](/api-reference/wallets/get-nfts-from-wallet) in a wallet.

2. If the NFTs were delivered to a **wallet address**, the user will be able to see them there directly, connecting to testnet if needed, or on the testnet blockchain explorer.

And voilá, there's your NFT! Now think of all the cool things you can build
with this, at scale :)

## Launching in Production

For production, the steps are almost identical, but some changes are required:

1. Create a developer account on the [production console](https://www.crossmint.com/console).
2. Add credits to your account from [Billing & Usage](https://www.crossmint.com/console/billing).
3. Then, create a production key on the [API Keys](https://www.crossmint.com/console/projects/apiKeys) page with the
   same API scopes.
4. Modify all code snippets with `const env = "www"`, so they use the production APIs. You may also need to change the
   `chain` variable to match your production blockchain.
5. Check the guide with [best practices](/minting/advanced/best-practices)

## Learn More

<CardGroup>
  <Card title="Create collections" icon="FILE" href="/minting/nfts/integrate/create-collections">
    Learn how to create and manage NFT collections.
  </Card>

  <Card title="Mint NFTs and other tokens" icon="cloud" href="/minting/nfts/integrate/mint-tokens">
    Check out more advanced options for minting digital assets.
  </Card>

  <Card title="Edit NFTs" icon="file-pen" href="/minting/nfts/integrate/update-nfts">
    Update and delete tokens after minting.
  </Card>
</CardGroup>


# Semi-Fungible Tokens (SFTs)
Source: https://docs.crossmint.com/minting/quickstarts/sfts

Mint and send limited sets of identical digital assets in under 5 minutes

In this quickstart you will learn how to create semi-fungible tokens (SFTs) and deliver them to a wallet or email address.

## What are SFTs?

SFTs (semi-fungible tokens) follow the ERC-1155 standard. Each token is a replica of a predefined template. Each collection (smart contract) can contain multiple templates, which can contain many tokens.

<Warning>This API only supports EVM chains self-serve. Contact us if you need support for another chain.</Warning>

## Integration steps

### 1. Create a Developer Account

<Snippet />

### 2. Get an API Key

<Snippet />

Within the "Server-side keys" section, click the "Create new key" button in the top right.
Then, check the scopes `nfts.create`, `nfts.read`, and `collections.create` under the "Minting API"
category and create your key. Save this key for the next step.

### 3. Create an SFT collection

With our key created, we're now going to create an SFT collection to hold our templates.

```javascript createCollection.js theme={null}
const apiKey = "YOUR_API_KEY";
const env = "staging"; // or "www"

const url = `https://${env}.crossmint.com/api/2022-06-09/collections`;
const options = {
    method: "POST",
    headers: {
        accept: "application/json",
        "content-type": "application/json",
        "x-api-key": apiKey,
    },
    body: JSON.stringify({
        chain: "polygon-amoy",
        fungibility: "semi-fungible",
        metadata: {
            name: "My SFT Collection",
            imageUrl: "https://www.crossmint.com/assets/crossmint/logo.png",
            description: "A new collection with its own dedicated smart contract",
        },
    }),
};

fetch(url, options)
    .then((res) => res.json())
    .then((json) => console.log(json))
    .catch((err) => console.error("error:" + err));
```

<Accordion title="Example response">
  ```json JSON theme={null}
  {
    "id": "5263650e-6d43-4ed3-9e31-0cf593d076a4",
    "metadata": {
      "name": "My SFT Collection",
      "description": "A new collection with its own dedicated smart contract",
      "imageUrl": "https://www.crossmint.com/assets/crossmint/logo.png",
      "symbol": "XMINT"
    },
    "fungibility": "semi-fungible",
    "onChain": {
      "chain": "polygon-amoy",
      "type": "erc-1155"
    },
    "actionId": "5263650e-6d43-4ed3-9e31-0cf593d076a4"
  }
  ```
</Accordion>

Save the `id` from the response as your `COLLECTION_ID` for the next steps.

### 4. Create a template within that collection

Now, let's create a template within our collection:

```javascript createTemplate.js theme={null}
const apiKey = "YOUR_API_KEY";
const env = "staging"; // or "www"
const collectionId = "YOUR_COLLECTION_ID";

const url = `https://${env}.crossmint.com/api/2022-06-09/collections/${collectionId}/templates`;
const options = {
    method: "POST",
    headers: {
        accept: "application/json",
        "content-type": "application/json",
        "x-api-key": apiKey,
    },
    body: JSON.stringify({
        onChain: {
            tokenId: "1",
        },
        supply: {
            limit: 10,
        },
        metadata: {
            name: "My template",
            image: "https://www.crossmint.com/assets/crossmint/logo.png",
            description: "A new token template for my ERC1155 collection",
        },
    }),
};

fetch(url, options)
    .then((res) => res.json())
    .then((json) => console.log(json))
    .catch((err) => console.error("error:" + err));
```

<Accordion title="Example response">
  ```json JSON theme={null}
  {
    "templateId": "58b0c1aa-e457-48dd-bb55-5a27e6a92f74",
    "metadata": {
      "name": "My template",
      "image": "ipfs://bafkreigbqsmxzkbjgbwtj6exfdt5z3t3swgoysf7hr6vjzddqnmykj6x2u",
      "description": "A new token template for my ERC1155 collection"
    },
    "onChain": {
      "tokenId": "1"
    },
    "supply": {
      "limit": "10",
      "minted": "0"
    }
  }
  ```
</Accordion>

Save the `templateId` from the response for the next step.

### 5. Mint an SFT from a template

Now, let's mint an SFT from our template and send it to a wallet or email address:

```javascript mintSFT.js theme={null}
const apiKey = "YOUR_API_KEY";
const env = "staging"; // or "www"
const collectionId = "YOUR_COLLECTION_ID";
const templateId = "YOUR_TEMPLATE_ID";
const recipientEmail = "TEST_EMAIL_ADDRESS";

const url = `https://${env}.crossmint.com/api/2022-06-09/collections/${collectionId}/sfts`;
const options = {
    method: "POST",
    headers: {
        accept: "application/json",
        "content-type": "application/json",
        "x-api-key": apiKey,
    },
    body: JSON.stringify({
        templateId: templateId,
        recipient: `email:${recipientEmail}:polygon-amoy`,
        amount: 1,
    }),
};

fetch(url, options)
    .then((res) => res.json())
    .then((json) => console.log(json))
    .catch((err) => console.error("error:" + err));
```

<Accordion title="Example response">
  ```json JSON theme={null}
  {
    "actionId": "a91c15e3-60f2-4a45-bf1a-cee508981667",
    "action": "nfts.create",
    "status": "pending",
    "data":
    {
      "chain": "polygon-amoy",
      "collection":
      {
        "id": "84e3d617-9c1b-4e7a-9686-522a9ea7c520",
        "contractAddress": "0x9b8ab8949bd7E73E61945b88F7fe12151f98ad3C"
      },
      "recipient":
      {
        "walletAddress": "0xcFDc00Cf926A5053f9Cdf004e6DF17e6dEB2E146",
        "email": "test@example.com"
      },
      "token":
      {
        "id": "a91c15e3-60f2-4a45-bf1a-cee508981667"
      }
    },
    "startedAt": "2024-01-02T22:05:01.000Z",
    "resource": "https://staging.crossmint.com/api/2022-06-09/actions/a91c15e3-60f2-4a45-bf1a-cee508981667"
  }
  ```
</Accordion>

### 6. Confirm Delivery of the SFT

The mint has started processing. However, blockchains can take a few seconds (or,
at times of extreme network congestion, even minutes) to confirm the operation.

Before showing the user a success screen, the next step is checking the
status of the mint.

To do this, grab the `actionId` received at the end of step 5 and use it
alongside your API key in one of the snippets below.

<CodeGroup>
  ```javascript mintStatus.js theme={null}
  const apiKey = "<YOUR_API_KEY>";
  const env = "staging"; // or "www"
  const actionId = "<MINT_ACTION_ID>";

  const url = `https://${env}.crossmint.com/api/2022-06-09/actions/${actionId}`;
  const options = {
      method: "GET",
      headers: { "X-API-KEY": apiKey },
  };

  fetch(url, options)
      .then((response) => response.json())
      .then((response) => console.log(response))
      .catch((err) => console.error(err));
  ```

  ```bash cURL theme={null}
  # Replace "staging" with "www" for production, and fill in your api key and mint action id
  ENV="staging"
  API_KEY="<YOUR_API_KEY>"
  MINT_ACTION_ID="<MINT_ACTION_ID>"
  curl --header "x-api-key: $API_KEY" \
    -X GET \
    https://${ENV}.crossmint.com/api/2022-06-09/actions/${MINT_ACTION_ID}
  ```
</CodeGroup>

<br />

<Accordion title="Example response">
  Here is an example response from calling the status API:

  ```json JSON theme={null}
  {
    "actionId": "a91c15e3-60f2-4a45-bf1a-cee508981667",
    "action": "nfts.create",
    "status": "success",
    "data": {
      "collection": {},
      "recipient": {},
      "token": {}
    },
    "startedAt": "2024-01-02T22:05:01.000Z",
    "completedAt": "2024-01-02T22:06:04.000Z", 
    "resource": "https://staging.crossmint.com/api/2022-06-09/actions/a91c15e3-60f2-4a45-bf1a-cee508981667"
  }
  ```
</Accordion>

Pay attention to the "status" field. Once it says "success": <br /><br />
**Congratulations. You have minted your first SFT** 🥷 🎉

<Note>
  For scalable production applications, consider using [webhooks](/minting/nfts/integrate/webhooks-and-status-apis) to
  determine when your SFT has been minted, instead of periodically polling for its status via the API.
</Note>

## View your SFTs

1. If the SFTs were delivered to an <Tooltip>**email address**</Tooltip>, the recipient can see them by:

   * Logging into their wallet from Crossmint's [website](https://www.crossmint.com). For staging, they must use [https://staging.crossmint.com](https://staging.crossmint.com).
   * From your website if you use [embedded wallets](/wallets/overview). See the API for [getting the NFTs](/api-reference/wallets/get-nfts-from-wallet) in a wallet.

2. If the SFTs were delivered to a **wallet address**, the user will be able to see them there directly, connecting to testnet if needed, or on the testnet blockchain explorer.

And voilá, there's your SFT! Now think of all the cool things you can build
with this, at scale :)

## Launching in Production

For production, the steps are almost identical, but some changes are required:

1. Create a developer account on the [production console](https://www.crossmint.com/console).
2. Add credits to your account from [Billing & Usage](https://www.crossmint.com/console/billing).
3. Then, create a production key on the [API Keys](https://www.crossmint.com/console/projects/apiKeys) page with the
   same API scopes.
4. Modify all code snippets with `const env = "www"`, so they use the production APIs. You may also need to change the
   `chain` variable to match your production blockchain.
5. Check the guide with [best practices](/minting/advanced/best-practices)

## Learn More

<CardGroup>
  <Card title="Create collections" icon="FILE" href="/minting/nfts/integrate/create-collections">
    Learn how to create and manage SFT collections.
  </Card>

  <Card title="Mint NFTs and other tokens" icon="cloud" href="/minting/nfts/integrate/mint-tokens">
    Check out more advanced options for minting.
  </Card>

  <Card title="Edit & Burn NFTs" icon="file-pen" href="/minting/guides/edit-and-burn-nfts">
    Update and delete tokens after minting.
  </Card>
</CardGroup>


# Create Credential Templates
Source: https://docs.crossmint.com/minting/verifiable-credentials/integrate/create-credential-templates

Create Verifiable Credential templates with a single API call

A Verifiable Credential template is equivalent to an NFT collection. Similar to how a NFT collection groups NFTs together, a Verifiable Credential template references the credential type and additional credential configurations that credentials adhere to. Every Verifiable Credential must belong to a template.

When defining a template, the issuer initially specifies a **credentials** object. Within that the following needs to be provided:

* **type** (required): A credential's private data schema is referred to as "type". Types act as a protective measure, preventing the addition of unauthorized fields and, as a result, the tampering of the Verifiable Credential. You can [define your own](/minting/verifiable-credentials/integrate/create-credential-types).

* **encryption** (required): The method chosen to protect the credential's private data. If set to `none` the credential's private data will be stored in plain text. To encrypt and protect the credential's private data, read about the supported [encryption modalities](/minting/verifiable-credentials/integrate/encrypt-credentials).

* **storage** (required): The location where credentials defined by this template will be stored. Such storage can be on Crossmint, another company's database, or decentralized storage. Read about the supported [storage modalities](/minting/verifiable-credentials/integrate/store-credentials).

The template issuer must then specify the template's public metadata:

* **metadata** (required): A template's public name, description and imageUrl. Name is required, while the other attributes are optional.

Finally, the issuer provides information on:

* **chain** (required): The blockchain where the credential's contract and associated NFTs will be registered. Verifiable Credentials supports all EVM chains. Interested in launching your verifiable credentials on a specific blockchain? [Get in touch](https://www.crossmint.com/contact/sales).

* **delegatedSignature** (optional): A non-custodial wallet of choice to be used for signing credential issuance. By default, the issuer's Crossmint-managed custodial wallet will be used. Read more about delegated signatures [here](/minting/verifiable-credentials/integrate/delegated-signatures).

## 1. Create a Credential Template

To issue a Verifiable Credential you have to first create the template that this credential will adhere to. You can do so via a single API call (requires the API key scope `templates.create`):

```javascript createTemplate.js theme={null}
const myApiKey = "<YOUR_API_KEY>"; // Replace with key from step 2

const templateParams = {
    credentials: {
        type: "crossmint:5fe6040e-07a1-48bb-97a3-b588a7e927d2:CourseCompletionCertificate",
        encryption: "none",
        storage: "crossmint",
    },
    metadata: {
        name: "Satoshi University Credentials",
        description: "Credentials accredited by Satoshi University",
        imageUrl: "https://picsum.photos/400",
    },
    chain: "polygon-amoy",
};

const options = {
    method: "POST",
    headers: {
        "X-API-KEY": myApiKey,
        "Content-Type": "application/json",
    },
    body: JSON.stringify(templateParams),
};

fetch("https://staging.crossmint.com/api/v1-alpha1/credentials/templates/", options)
    .then((response) => response.json())
    .then((response) => console.log(JSON.stringify(response)))
    .catch((err) => console.error(err));
```

The template's metadata will be used by default for the NFT metadata, unless explicitly set when issuing a new credential.

## 2. Check the status of your template

It takes a few seconds (up to a minute, depending on the blockchain and how congested it is) to deploy a template.

To check the template's status, you will need the `nfts.create` API scope and run the following code.

```typescript checkTemplateStatus.js theme={null}
const templateId = "<YOUR_TEMPLATE_ID>";
const options = { method: "GET", headers: { "X-API-KEY": "<YOUR_API_KEY>" } };

fetch(`https://staging.crossmint.com/api/2022-06-09/actions/${templateId}`, options)
    .then((response) => response.json())
    .then((response) => console.log(response))
    .catch((err) => console.error(err));
```

<CardGroup>
  <Card title="API Reference" icon="terminal" href="/api-reference/verifiable-credentials/templates/create-template">
    Test any API in seconds directly from the docs.
  </Card>

  <Card title="Talk to an expert" icon="message" href="https://www.crossmint.com/contact/sales">
    Contact our sales team for support.
  </Card>
</CardGroup>


# Create Credential Types
Source: https://docs.crossmint.com/minting/verifiable-credentials/integrate/create-credential-types

Specify the schema that the Verifiable Credential adheres to

In the realm of Verifiable Credentials, each credential must be associated with a schema. The credential's schema is referred to as "type".

Credential types outline the attributes and their respective data types that the credential contains. The purpose of types is to ensure the credential's authenticity. Types allow you to specify the attributes you are interested in certifying and act as a protective measure, preventing the addition of unauthorized attributes and, as a result, the tampering of the Verifiable Credential.

It's important to note that all credentials within a single template will share the same type. Trying to issue or verify a credential with different field names or types will result in an error.

By adhering to this structure, we maintain the integrity and verifiability of the credentials, ensuring they serve their purpose effectively.

## Example Types

Credentials play a crucial role in verifying and validating various aspects of identity, achievement, and authorization. Below are some examples of credential types you can create and manage through Crossmint:

### Proof of Employment

* Purpose: Issued to individuals that want to prove their employment.
* Name: `ProofOfEmployment`

```typescript theme={null}
ProofOfEmployment {
    position: string;
    department: string;
    startDate: string;
}
```

The payload used to create this type is the following:

```json theme={null}
{
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "title": "Proof of Employment",
    "description": "Schema for verifying employment details",
    "type": "object",
    "properties": {
        "credentialSubject": {
            "type": "object",
            "properties": {
                "position": {
                    "type": "string"
                },
                "department": {
                    "type": "string"
                },
                "startDate": {
                    "type": "string"
                }
            },
            "required": ["position", "department", "startDate"],
            "additionalProperties": false
        }
    }
}
```

To reference this example type in your credential template definition, use `crossmint:bfb292e7-2700-4924-9213-478f3d71f2d8:ProofOfEmployment`.

### Course Completion Certificates

* Purpose: Issued to students upon the successful completion of a course. The certificate may indicate that the student has mastered a specific skill or knowledge.
* Type: `CourseCompletionCertificate`

```typescript theme={null}
CourseCompletionCertificate {
    course: string;
    grade: string;
}
```

If you want to use this example type in your credential template definition, you can reference it as `crossmint:bfb292e7-2700-4924-9213-478f3d71f2d8:CourseCompletionCertificate`.

### Membership Credentials

* Purpose: Provided to individuals who are members of a specific organization or club. The certificate may grant access to exclusive resources and events.
* Name: `Membership`

```typescript theme={null}
Membership {
  organizationName: string;
  membershipType: string;
  issueDate: string;
  benefits: string[];
  status: string;
}
```

If you want to use this example type in your credential template definition, you can reference it as `crossmint:bfb292e7-2700-4924-9213-478f3d71f2d8:Membership`.

### Event Participation Certificates

* Purpose: Issued to individuals who attend or participate in specific events.
* Name: `EventParticipation`

```typescript theme={null}
EventParticipation {
  eventName: string;
  eventDate: string;
  location: string;
  description: string;
}
```

If you want to use this example type in your credential template definition, you can reference it as `crossmint:bfb292e7-2700-4924-9213-478f3d71f2d8:EventParticipation`.

## Types Creation Quickstart

This example creates a custom type, `CourseCompletionCertificate`, for a credential that represents a course completion. The credential will contain two fields: `course` and `passed`.

<CodeGroup>
  ```javascript createType.js theme={null}
  const typeName = "CourseCompletionCertificate";

  const schema = {
      $schema: "https://json-schema.org/draft/2020-12/schema",
      title: "Course completion",
      description: "Describes the course completed and the assigned grade",
      type: "object",
      properties: {
          credentialSubject: {
              type: "object",
              properties: {
                  course: {
                      type: "string",
                  },
                  grade: {
                      type: "string",
                  },
                  id: {
                      // Optional, will be added automatically
                      type: "string",
                  },
              },
              required: ["course", "grade"],
              additionalProperties: false,
          },
      },
  };

  const options = {
      method: "PUT",
      headers: {
          "X-API-KEY": "YOUR_API_KEY",
          "Content-Type": "application/json",
      },
      body: JSON.stringify(schema),
  };

  fetch(`https://staging.crossmint.com/api/v1-alpha1/credentials/types/${typeName}`, options)
      .then((response) => response.json())
      .then((response) => console.log(JSON.stringify(response)))
      .catch((err) => console.error(err));
  ```
</CodeGroup>

Copy the `createType.js` file in the tab above, add your API key to the `X-API-KEY` header (or [create one](/minting/quickstarts/credentials#2-get-an-api-key) if you haven't already) and run via node.

```shell theme={null}
node createType.js
```

The response, shown below, includes the credential type name.

```json Response theme={null}
{
    "id": "crossmint:bfb292e7-2700-4924-9213-478f3d71f2d8:CourseCompletionCertificate", // Internal type id
    "typeSchema": {
        "$schema": "https://json-schema.org/draft/2020-12/schema",
        "title": "Course completion", // Veryfiable credential `type` name.
        "description": "Describes the course completed and the assigned grade",
        "type": "object",
        "properties": {
            "credentialSubject": {
                "type": "object",
                "properties": {
                    "course": {
                        "type": "string"
                    },
                    "grade": {
                        "type": "string"
                    },
                    "id": {
                        "type": "string"
                    }
                },
                "required": ["course", "grade"],
                "additionalProperties": false
            }
        },
        "$id": "https://staging.crossmint.com/api/v1-alpha1/credentials/types/crossmint:bfb292e7-2700-4924-9213-478f3d71f2d8:CourseCompletionCertificate" // External schema URI
    }
}
```

The type id defined will be used when you create your [credential template](/minting/verifiable-credentials/integrate/create-credential-templates).

You can also utilize the `POST /credentials/types/` endpoint to generate a random uuid for the new credential type.

<Warning>
  For internal use within Crossmint, reference the type using `id`. The `$id` will be included as the credentials
  schema by Crossmint but should not be used to reference the type in Crossmint APIs.
</Warning>

Example of a credentials using the type `"crossmint:bfb292e7-2700-4924-9213-478f3d71f2d8:CourseCompletionCertificate"` just created.

```json Example Credential theme={null}
 {
    "id": "urn:uuid:820b09e8-bd6d-4680-b2b1-b564169fde8a",
    "credentialSubject": {
        "course": "Math",
        "grade": "A",
        "id": "did:polygon-amoy:0x1B887669437644aA348c518844660ef8d63bd643"
    },
    "nft": {
        "tokenId": "7",
        "chain": "polygon-amoy",
        "contractAddress": "0xb14Bf8EEa68026a2746350059389Bd119CFB8E29"
    },
    "issuer": {
        "id": "did:polygon-amoy:0xd9d8BA9D5956f78E02F4506940f42ac2dAB9DABd"
    },
    "type": [
        "VerifiableCredential",
        "Course completion" // Schema.title
    ],
    "validFrom": "2024-11-19T18:41:30.503Z",
    "@context": [
        "https://www.w3.org/ns/credentials/v2"
    ],
    "credentialSchema": {
        "id": "https://staging.crossmint.com/api/v1-alpha1/credentials/types/crossmint:bfb292e7-2700-4924-9213-478f3d71f2d8:CourseCompletionCertificate", // Schema.$id
        "type": "JsonSchema"
    },
    "proof": { ... }
}
```

## Types Creation Deep Dive

In the realm of Verifiable Credentials, types are defined using the JSON schema. For more details, refer to the [W3C VC JSON Schema](https://www.w3.org/TR/vc-json-schema/).
When calling the create type API an invalid JSON schema will result in an error.

### Type schema structure

Below is an example of a JSON schema structure for defining a credential type:

```json Example Schema Payload theme={null}
{
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "title": "Example nested schema",
    "description": "A schema capturing a human name and a nested `additionalInfo` object",
    "type": "object",
    "properties": {
        "credentialSubject": {
            "type": "object",
            "properties": {
                "firstName": {
                    "type": "string"
                },
                "id": {
                    // This will be added automatically, is not necessary
                    "type": "string"
                },
                "additionalInfo": {
                    "type": "object",
                    "properties": {
                        "age": {
                            "type": "integer"
                        },
                        "isActive": {
                            "type": "boolean"
                        },
                        "tags": {
                            // Optional, therefore is not added to `required`
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        }
                    },
                    "required": ["age", "isActive"],
                    "additionalProperties": false // Needs to be repeated for each nested object
                }
            },
            "required": ["firstName", "additionalInfo"],
            "additionalProperties": false
        }
    }
}
```

#### Explanation of Each Part:

* **\$schema**: This should always be set to "[https://json-schema.org/draft/2020-12/schema](https://json-schema.org/draft/2020-12/schema)".
* **\$id**: This field should NOT be defined, will be generated by Crossmint and returned in the response.
* **title**: Represents the name of the type.
* **description**: A brief description of the schema.
* **type**: Must be set to "object".
* **properties**: Must include `credentialSubject` as an object.

#### Important Notes:

* The credential subject is the section that needs to be defined. Any field or nested field can be added, as long as it is valid JSON schema.
* The `credentialSubject.properties.id` will be automatically added with the type "string", this is used to specify the wallet and therefore the identity of the subject.
* `additionalProperties` should always be set to `false` to prevent unauthorized fields from being added.
* All specified fields should be marked as `required` unless they are optional. This ensures that missing fields will trigger an error during schema validation.
* `additionalProperties` and `required` apply only at the level they are specified. For nested objects, these need to be repeated.

### Type import

If you already have a JSON schema type, you can easily import it by calling the same endpoint with the following structure:

```javascript importType.js theme={null}
const payload = {
    $id: "https://raw.githubusercontent.com/decentralized-identity/credential-schemas/main/schemas/ExampleEntity/ExampleNameSchema.json",
};
const options = {
    method: "POST",
    headers: {
        "X-API-KEY": "YOUR_API_KEY",
        "Content-Type": "application/json",
    },
    body: JSON.stringify(schema),
};

fetch(`https://staging.crossmint.com/api/v1-alpha1/credentials/types`, options)
    .then((response) => response.json())
    .then((response) => console.log(JSON.stringify(response)))
    .catch((err) => console.error(err));
```

```json Response theme={null}
{
    "id": "crossmint:e62564a7-06eb-4f65-b389-eb3b7a4f6f98:10ede8a6",
    "typeSchema": {
        "$id": "https://raw.githubusercontent.com/decentralized-identity/credential-schemas/main/schemas/ExampleEntity/ExampleNameSchema.json",
        "$schema": "https://json-schema.org/draft/2020-12/schema",
        "title": "Example Name schema",
        "description": "A schema capturing a human name",
        "type": "object",
        "properties": {
            "credentialSubject": {
                "type": "object",
                "properties": {
                    "firstName": {
                        "type": "string"
                    },
                    "id": {
                        "type": "string"
                    }
                },
                "required": ["firstName"],
                "additionalProperties": false
            }
        }
    }
}
```

#### Important Notes for Import:

* All notes for type creation apply here as well.
* `credentialSubject.properties.id` will not be added for imported schemas. If the original schema does not include this specification, the resulting credentials will not include the user wallet in the `subject.id`. To know the subject of a credential, checking the NFT owner will be necessary.

<Note>
  To follow along and test the API calls use a tool like Postman or our [API
  playground](/api-reference/verifiable-credentials/types/create-named-type).
</Note>

<CardGroup>
  <Card title="API Reference" icon="terminal" href="/api-reference/verifiable-credentials/types/create-named-type">
    Test any API in seconds directly from the docs.
  </Card>

  <Card title="Talk to an expert" icon="message" href="https://www.crossmint.com/contact/sales">
    Contact our sales team for support.
  </Card>
</CardGroup>


# Decrypt Credentials
Source: https://docs.crossmint.com/minting/verifiable-credentials/integrate/decrypt-credentials

Decrypt credentials you care about

As a credential issuer you can use the [retrieval endpoints](/minting/verifiable-credentials/integrate/retrieve-credentials) and Crossmint will autodecrypt the credential for you.

As a verifier, however, working with [encryption modalities](/minting/verifiable-credentials/integrate/encrypt-credentials) to decrypt credentials requires deep understanding of their APIs, managing cryptographic operations securely, and handling user signature interactions.

The Verifiable Credentials SDK encapsulates all this functionality for verifiers, ensuring secure and seamless decryption.

* Upon a verifier's request, the SDK prompts the credential subject to sign a message proving they are the credential subject, and approving the credential's decryption.
* Once the subject approves, Crossmint decrypts the credential for the verifier to verify.

If the credentials are encrypted using the Lit protocol, in order to decrypt them, the SDK provides a `Lit.decrypt(encryptedCredential)` function.

If the credentials are encrypted using Crossmint, the SDK provides a `CrossmintMetamaskDecrypt().decrypt(encryptedCredential)` function that decrypts the credential, assuming the user has a Metamask wallet. For the support of additional wallets during decryption, review our SDK reference.

A Crossmint API key (`credentials.decrypt`) is needed when:

* Crossmint has encrypted the data (`crossmint-recoverable` encryption modality)
* Data is encrypted via Lit but the verifier wants to delegate Lit network billing to Crossmint

<Warning>Decryption will not work server-side when using Lit.</Warning>

In both cases, the user will be prompted to sign a message with their wallet to authenticate the decryption, then the credential will be decrypted.

<CodeGroup>
  ```typescript decrypt.ts theme={null}
  import * as sdk from '@crossmint/client-sdk-verifiable-credentials';

  sdk.CrossmintAPI.init('YOUR_API_KEY');

  const encryptedCredential = <encryptedCredentialObject>;

  if (collection.metadata.credentialMetadata.encryption.type==VerifiableCredentialEncryptionType.DECENTRALIZED_LIT){
    const decryptedData = await new sdk.Lit("staging").decrypt(encryptedCredential);
  }else if (collection.metadata.credentialMetadata.encryption.type==VerifiableCredentialEncryptionType.CROSSMINT_RECOVERABLE){
    const decryptedData = await new sdk.CrossmintMetamaskDecrypt().decrypt(encryptedCredential);
  } else {
    throw new Error("Not supported")
  }

  console.log("Decrypted credential:", decryptedData);

  ```

  ```json Response theme={null}
  {
    "unencryptedCredential": {
      "id": "urn:uuid:4c9c41af-8410-4265-9fe4-3674d74e80d9",
      "credentialSubject": {
        "course": "Blockchain 101",
        "grade": "A",
        "id": "did:polygon-amoy:0xbFB0d0F9d49d80062103199c5aD309CE7a808039"
      },
      "validUntil": "2034-02-02",
      "nft": {
        "tokenId": "1",
        "chain": "polygon-amoy",
        "contractAddress": "0x288AAbb7D72A041Ea10719d2d676B65D2E9689F5"
      },
      "issuer": { "id": "did:polygon-amoy:0xB658f974Fe3744A6F9344810BC88e021E31B4d3e" },
      "type": [
        "VerifiableCredential",
        "crossmint:5fe6040e-07a1-48bb-97a3-b588a7e927d2:courseCompletionQuickstart"
      ],
      "validFrom": "2024-09-14T13:59:34.918Z",
      "@context": [
        "https://www.w3.org/2018/credentials/v1"
      ],
      "proof": {
        "verificationMethod": "did:polygon-amoy:0xB658f974Fe3744A6F9344810BC88e021E31B4d3e#evmAddress",
        "created": "2024-09-14T13:59:34.918Z",
        "proofPurpose": "assertionMethod",
        "type": "EthereumEip712Signature2021",
        "proofValue": "0x80587c5e9a801f4eed5bca95c48083277fc2ffe2fc1254f230f1b8c11cab59f63afaaa29bf29007129068243feb0069c46a8e583a64e64ff2517a2e3babd18101b",
        "eip712": {
          "domain": {
            "name": "Crossmint",
            "version": "0.1",
            "chainId": 4,
            "verifyingContract": "0xD8393a735e8b7B6E199db9A537cf27C61Aa74954"
          },
          "types": {
            "VerifiableCredential": [
              { "name": "@context", "type": "string[]" },
              { "name": "type", "type": "string[]" },
              { "name": "id", "type": "string" },
              { "name": "issuer", "type": "Issuer" },
              { "name": "credentialSubject", "type": "CredentialSubject" },
              { "name": "validFrom", "type": "string" },
              { "name": "validUntil", "type": "string" },
              { "name": "nft", "type": "Nft" }
            ],
            "CredentialSubject": [
              { "name": "id", "type": "string" },
              { "name": "course", "type": "string" },
              { "name": "grade", "type": "string" }
            ],
            "Issuer": [
              { "name": "id", "type": "string" }
            ],
            "Nft": [
              { "name": "tokenId", "type": "string" },
              { "name": "contractAddress", "type": "string" },
              { "name": "chain", "type": "string" }
            ]
          },
          "primaryType": "VerifiableCredential"
        }
      }
    }
  }
  ```
</CodeGroup>

The decrypted credential content can now be reviewed and verified by the verifier.


# Delegated Signature
Source: https://docs.crossmint.com/minting/verifiable-credentials/integrate/delegated-signatures

Sign credentials with your wallet of choice

Credential issuers, by default, sign credentials using their custodial wallet, managed by Crossmint. This means that Crossmint handles the management of the wallet used for signing, providing a default and streamlined solution for issuers.

If an issuer wants to sign credentials using a separate wallet they own, they can do so by providing a signing endpoint. This endpoint is essentially a service or URL that the issuer can set up, which Crossmint will use to access the issuer's chosen wallet for signing credentials.

<Warning>
  Delegated signature and encryption are not concurrently supported for the moment, so it is advised to also use
  [delegated storage](/minting/verifiable-credentials/integrate/store-credentials#delegated-storage) for sensitive
  data.
</Warning>

## Template Creation

Upon template creation, customers can specify parameters that configure the `delegatedSignature` specification:

* `issuerDid`: The desired issuer DID represents the entity that will be issuing the credentials.
* `endpoint`: The signing endpoint is the URL or endpoint where the credential signing process takes place
* `token`: The Auth token for the endpoint is a secure token used to authenticate requests to the signing endpoint. This token ensures that only authorized entities can access the signing endpoint.

```json theme={null}
{
  ...standard_template_params,
  delegatedSignature: {
    issuerDid: "did:polygon:<0xADDRESS>",
    endpoint: "string",
    token: "string"
  }
}
```

The credential issuance process remains unchanged, except for one crucial modification. Instead of directly calling `wallet.signTypedData(payload)` using Crossmint's wallet, Crossmint sends the payload to a designated endpoint. This endpoint is responsible for wrapping the `signTypedData` call and performing the necessary security checks to ensure only authorized payloads are processed, preventing arbitrary or malicious data from being signed.

## Request Payload

Crossmint will POST to the given endpoint with the following payload:

```json theme={null}
{
    "issuer": "did:polygon:<0xADDRESS>",
    "domain": "ethers.TypedDataDomain",
    "types": "Record<string, Array<ethers.TypedDataField>>",
    "message": "<credential_object_to_sign>",
    "token": "<auth_token>"
}
```

## Response Format

The endpoint should return a response with the following format:

```json theme={null}
{
    "credential": "<credential_object_to_sign>",
    "issuer": "<address>",
    "signature": "string"
}
```

## DID

The issuer's identity is represented by a [DID](https://www.w3.org/TR/did-core/). The DID is a string that uniquely identifies the issuer.
The easiest way to provide a DID is to send the issuer's wallet address as DID, setting issuerDid to `"did:{chain}:{address}"`.

### Web DID

Crossmint also supports [Web DID](https://w3c-ccg.github.io/did-method-web/). This allows issuer's to be identified by a domain name, setting issuerDid to `"did:web:issuer.com"`. webDID leverages existing web domain reputation to establish trust around decentralized identities.

The issuer must have a [DID Document](https://www.w3.org/TR/did-core/#did-documents) hosted at `https://issuer.com/.well-known/did.json` for the webDID mapping to work properly.
The DID document, among other useful information, needs to contain the "service" attribute, stating the issuer's wallet address:
The issuer's wallet is the wallet that will be used to sign the credential and verifiers can recognize this wallet by its related webDID.

```json theme={null}
{
    "id": "did:web:myissuer.com",
    "service": [
        {
            "id": "did:web:myissuer.com#wallet",
            "type": "wallet",
            "serviceEndpoint": "chain:<0xADDRESS>"
        }
    ]
    // ... other properties like verificationMethod, authentication, etc.
}
```


# Credential Encryption
Source: https://docs.crossmint.com/minting/verifiable-credentials/integrate/encrypt-credentials

Encrypt private credential data

Verifiable Credentials can be used to store sensitive information. In such cases, it's crucial to use encrypted credentials to ensure data privacy and security.

The encryption process is designed so that *only* the credential subject and the credential issuer can decrypt the credential. This ensures that sensitive information is only accessible to the relevant parties.

Once the credential is decrypted, it can be verified by anyone. This allows for the credential's authenticity to be confirmed while still maintaining the privacy of its content.

The process of encryption and decryption can be automated using the Crossmint API and SDK. This provides a seamless and secure way to handle sensitive information within Verifiable Credentials.

<Note>Encryption will make credential issuance and retrieval slower due to the encryption and decryption process.</Note>

## Create an encrypted credential template

When creating a [template](/minting/verifiable-credentials/integrate/create-credential-templates), you can specify an `encryption` parameter to determine the encryption modality you will use. The possible values for this parameter are:

* `crossmint-recoverable`: This option is ideal when users prioritize the convenience and security of having a fallback recovery mechanism. Crossmint will take care of encrypting the credential. The user will be required to prove ownership of the subject wallet to decrypt the credential. As a fallback mechanism, the key is also shared with the credential issuer.
* `decentralized-lit`: This option is better suited for users who prioritize full decentralization and privacy. The credential is encrypted and decrypted using the [Lit protocol](https://www.litprotocol.com/). The user will be required to prove ownership of the subject wallet to decrypt the credential.
* `none`: The certificate is not encrypted.

For example, the `encryption` field part of the template creation request below is set to `crossmint-recoverable`.

```json theme={null}
{
    "metadata": {
        "name": "Template Name",
        "description": "Encrypted credentials template"
    },
    "chain": "polygon",
    "credentials": {
        "type": "MyCustomType",
        "encryption": "crossmint-recoverable"
    }
}
```

During credential creation, the Crossmint API encrypts the credential and sets an access rule that only the credential subject and the credential issuer can decrypt the credential.

Credentials issued from this template will be encrypted for you. Behind the scenes:

* The Crossmint API encrypts the certificate's private data and sets an access rule that only the credential subject and issuer can decrypt the credential.
* Crossmint triggers a webhook to the issuer after a successful credential creation.
* Issuer receives via webhook the credential content and the encryption key.
* As a fallback a copy of the encryption key is sent to the issuer.

## Encrypted credential object

An encrypted credential consists of a 'credentialId' and a base64 encoded encrypted payload.

```json theme={null}
{
    "credentialId": "urn:uuid:<credential_id>",
    "payload": "base64_encoded_cipher_text"
}
```

## Retrieve an encrypted credential

You can leverage the standard retrieval Crossmint API endpoint to retrieve an encrypted credential:
`GET https://staging.crossmint.com/api/v1-alpha1/credentials/{credentialId}`

<Note>
  Hitting the `GET credentials/{credentialId}` endpoint as the issuer will automatically decrypt the credential for
  you and return both the clear and ciphertext.
</Note>

In case of successful autodecryption, the response object will be:

```json theme={null}
{
    "encryptedCredential": {
        "credentialId": "urn:uuid:<credential_id>",
        "payload": "base64_encoded_cipher_text"
    },
    "unencryptedCredential": "<credential_obj>",
    "decryptionError": undefined
}
```

For information on how to decrypt a credential, see [here](/minting/verifiable-credentials/integrate/decrypt-credentials).


# Issue Credentials
Source: https://docs.crossmint.com/minting/verifiable-credentials/integrate/issue-credentials

Specify the credential's values and a recipient to send it to

With both a credential type and template defined, we can proceed to issue a credential.

## 1. Issue a Credential

First and foremost, the issuer must specify a valid recipient for the credential:

* **recipient** (required): Issuer must specify a credential recipient. This can be done via `email:${userEmail}:${chain}` or `{wallet address}`.

In addition, the issuer must specify a **credential** object containing:

* **subject** (required): Object matching a defined credential type's schema, with values relevant to the recipient. The credential's contents are identified by the "subject" key within the credential, following [W3C naming standards](https://www.w3.org/TR/vc-data-model-2.0/#credential-subject).

<Warning>
  The credential subject (credential.subject) must respect the schema of the chosen Verifiable Credential type. You
  cannot add additional fields, nor exclude any that were previously set.
</Warning>

* **expiresAt** (required): Specify date, in form such as `2034-02-02` (ISO) or `none` to imply infinite expiration.

<Warning>If you don't include an expiration date, you must revoke the credential via burning to invalidate it.</Warning>

Finally, the issuer can provide optional public metadata related to the specific credential, as such:

* **metadata** (optional): NFT metadata is inherited from the VC template metadata. Metadata attributes can be set by the customer to override metadata definition inherited by baseURI.

To issue your first credential, copy the `issueCredential.js` file from below, add your API key, and templateId (that was returned to you in the previous step), and run the file from your terminal.

<CodeGroup>
  ```javascript issueCredential.js theme={null}
  const userEmail = "user@email.com"; // Replace with recipient email
  const templateId = "YOUR_TEMPLATE_ID"; // Replace with ID from previous step

  const credentialParams = {
      recipient: `email:${userEmail}:polygon-amoy`,
      credential: {
          // The CourseCompletionCertificate credential type requires course and grade declarations
          subject: {
              course: "Blockchain 101",
              grade: "A",
          },
          expiresAt: "2034-02-02",
      },
  };

  const options = {
      method: "POST",
      headers: {
          "X-API-KEY": "YOUR_API_KEY",
          "Content-Type": "application/json",
      },
      body: JSON.stringify(credentialParams),
  };

  fetch(`https://staging.crossmint.com/api/v1-alpha1/credentials/templates/${templateId}/vcs`, options)
      .then((response) => response.json())
      .then((response) => console.log(JSON.stringify(response)))
      .catch((err) => console.error(err));
  ```

  ```json Response theme={null}
  {
      "id": "d7eb777b-e9b4-4f34-ab5f-ce199111166a",
      "onChain": {
          "status": "pending",
          "chain": "polygon-amoy",
          "contractAddress": "0xdC444A3F4768185497Dae6250E2F348b99bE89F3"
      },
      "credentialId": "urn:uuid:64f9877d-a19a-4205-8d61-f8c2abed5766",
      "actionId": "d7eb777b-e9b4-4f34-ab5f-ce199111166a"
  }
  ```
</CodeGroup>

```shell theme={null}
node issueCredential.js
```

## 2. Check the status of your credential

You can [set up a webhook](/minting/verifiable-credentials/integrate/webhooks) to know when the Verifiable Credential NFT minting is completed, or call the
[action status API](/api-reference/common/get-action-status) with the returned `actionId`.

To check the template's status you will need the `nfts.create` API scope and run the following code.

```typescript checkTemplateStatus.js theme={null}
const actionId = "<YOUR_ACTION_ID>"; // Returned from previous step
const options = { method: "GET", headers: { "X-API-KEY": "<YOUR_API_KEY>" } };

fetch(`https://staging.crossmint.com/api/2022-06-09/actions/${actionId}`, options)
    .then((response) => response.json())
    .then((response) => console.log(response))
    .catch((err) => console.error(err));
```

<CardGroup>
  <Card title="API Reference" icon="terminal" href="/api-reference/verifiable-credentials/credentials/issue-credential">
    Test any API in seconds directly from the docs.
  </Card>

  <Card title="Talk to an expert" icon="message" href="https://www.crossmint.com/contact/sales">
    Contact our sales team for support.
  </Card>
</CardGroup>


# Retrieve Credentials
Source: https://docs.crossmint.com/minting/verifiable-credentials/integrate/retrieve-credentials

Get access to credentials you care about

Retrieving and effectively presenting credentials is essential for issuers, verifiers, and credential subjects. However, doing so requires interfacing with the blockchain, 3rd party services to fetch NFTs, all while at the same time struggling with unpredictable network issues, and data inconsistency.

Crossmint’s Verifiable Credentials API and SDK simplify credential management, allowing you to seamlessly retrieve and use verifiable credentials where they matter most.

## Verifiable Credential API

Crossmint's Verifiable Credentials API is primarily meant to be used by issuers. It's designed for robust backend operations, enabling seamless, automated credential retrieval without requiring user interaction.

The API integrates with your existing server-side infrastructure, ensuring efficient and scalable credential management. With the API, you can implement complex business logic, providing unparalleled control and customization.

​​You can retrieve a Verifiable Credential via the Crossmint API using different identifiers associated with the credential itself, or the NFT associated with the credential.

* [Get Verifiable Credential by ID](/api-reference/verifiable-credentials/credentials/retrieve-credential-by-id) uses the format: `urn:uuid:<UUID>`
* [Get Verifiable Credential by NFT Locator](/api-reference/verifiable-credentials/credentials/retrieve-credential-by-nft-locator) uses the format: `<chain>:<contractAddress>:<tokenId>`
* [Get Verifiable Credential by NFT ID](/api-reference/verifiable-credentials/credentials/retrieve-credential-by-nft) uses crossmint's internal NFT ID

<Warning>
  There is no access control on credential retrieval. Credential data is public and can be retrieved by anyone. Choose
  to [encrypt your credentials](/minting/verifiable-credentials/integrate/encrypt-credentials) if you need to protect
  your data.
</Warning>

<Warning>
  Credential retrieval via the crossmint API will not work for [delegated
  storage](/minting/verifiable-credentials/integrate/store-credentials).
</Warning>

To retrieve the credential, copy the `retrieveCredential.js` file from below, use your API key, the `credentialId`, and run the file from your terminal.

<CodeGroup>
  ```javascript retrieveCredential.js theme={null}
  const options = {
      method: "GET",
      headers: {
          "X-API-KEY": "YOUR_API_KEY",
      },
  };

  fetch(`https://staging.crossmint.com/api/v1-alpha1/credentials/${credentialId}`, options)
      .then((response) => response.json())
      .then((response) => console.log(JSON.stringify(response)))
      .catch((err) => console.error(err));
  ```

  ```json Response theme={null}
  {
      "unencryptedCredential": {
          "id": "urn:uuid:4c9c41af-8410-4265-9fe4-3674d74e80d9",
          "credentialSubject": {
              "course": "Blockchain 101",
              "grade": "A",
              "id": "did:polygon-amoy:0xbFB0d0F9d49d80062103199c5aD309CE7a808039"
          },
          "validUntil": "2034-02-02",
          "nft": {
              "tokenId": "1",
              "chain": "polygon-amoy",
              "contractAddress": "0x288AAbb7D72A041Ea10719d2d676B65D2E9689F5"
          },
          "issuer": { "id": "did:polygon-amoy:0xB658f974Fe3744A6F9344810BC88e021E31B4d3e" },
          "type": ["VerifiableCredential", "crossmint:5fe6040e-07a1-48bb-97a3-b588a7e927d2:courseCompletionQuickstart"],
          "validFrom": "2024-09-14T13:59:34.918Z",
          "@context": ["https://www.w3.org/2018/credentials/v1"],
          "proof": {
              "verificationMethod": "did:polygon-amoy:0xB658f974Fe3744A6F9344810BC88e021E31B4d3e#evmAddress",
              "created": "2024-09-14T13:59:34.918Z",
              "proofPurpose": "assertionMethod",
              "type": "EthereumEip712Signature2021",
              "proofValue": "0x80587c5e9a801f4eed5bca95c48083277fc2ffe2fc1254f230f1b8c11cab59f63afaaa29bf29007129068243feb0069c46a8e583a64e64ff2517a2e3babd18101b",
              "eip712": {
                  "domain": {
                      "name": "Crossmint",
                      "version": "0.1",
                      "chainId": 4,
                      "verifyingContract": "0xD8393a735e8b7B6E199db9A537cf27C61Aa74954"
                  },
                  "types": {
                      "VerifiableCredential": [
                          { "name": "@context", "type": "string[]" },
                          { "name": "type", "type": "string[]" },
                          { "name": "id", "type": "string" },
                          { "name": "issuer", "type": "Issuer" },
                          { "name": "credentialSubject", "type": "CredentialSubject" },
                          { "name": "validFrom", "type": "string" },
                          { "name": "validUntil", "type": "string" },
                          { "name": "nft", "type": "Nft" }
                      ],
                      "CredentialSubject": [
                          { "name": "id", "type": "string" },
                          { "name": "course", "type": "string" },
                          { "name": "grade", "type": "string" }
                      ],
                      "Issuer": [{ "name": "id", "type": "string" }],
                      "Nft": [
                          { "name": "tokenId", "type": "string" },
                          { "name": "contractAddress", "type": "string" },
                          { "name": "chain", "type": "string" }
                      ]
                  },
                  "primaryType": "VerifiableCredential"
              }
          }
      }
  }
  ```
</CodeGroup>

```shell theme={null}
node retrieveCredential.js
```

## Verifiable Credentials SDK

Crossmint's Verifiable Credentials SDK is primarily meant to be used by verifiers. Using the Verifiable Credentials client-side SDK is advantageous in scenarios where direct interaction with the user's wallet is preferred, directly integrating their credentials with your browser-based application.

* **Wallet Integration**: The Verifiable Credentials SDK is designed to work smoothly with any wallet, providing a streamlined experience for both users and verifiers. This reduces friction and improves the user experience.
* **Efficient Retrieval**: Once the wallet is connected, the SDK can directly interact with it to retrieve credentials. Instead of dealing with multiple API calls, the SDK surfaces credential retrieval capabilities that matter most to verifiers, such as fetching credentials based on specific filter conditions, i.e. type and issuer.
* **User Approvals**: The SDK takes care of prompting the user, when applicable, to approve transactions, such as decryption requests, enhancing security and the user's confidence in the application.

Using the SDK requires a Crossmint developer account and a client-side API key scoped to `credentials.read` and `credentials.decrypt`. Go to the `Developers -> API Keys` tab, click on `New API Key` in the `Client-side keys` section, and select the API key scopes.

<Note>
  You can download the SDK [here](https://www.npmjs.com/package/@crossmint/client-sdk-verifiable-credentials).
</Note>

The SDKs offer functions to easily retrieve and filter NFTs associated with credentials. For example, the `getCredentialNFTs` function fetches all VC NFTs in a wallet and lets you filter by credential type or issuer.

Below, we show how easy it is to retrieve academic credentials from a user's wallet.

<CodeGroup>
  ```typescript index.ts theme={null}
  import * as sdk from '@crossmint/client-sdk-verifiable-credentials';

  sdk.CrossmintAPI.init('YOUR_API_KEY');

  const wallet = "USER_WALLET";
  const filters = {
      // typeId represents an academic credential schema
      type: <typeId>
  };

  const credentials = await sdk.getCredentialNFTs(
      "polygon",
      wallet,
      filters
  );

  console.log('Academic credentials retrieved successfully:', credentials);

  ```

  ```json Response theme={null}
  [
   {
          "contractAddress": "0x5E1ab2aC27f1a0AD28f1b0DDb0E00baF2677725e",
          "chain": "polygon-amoy",
          "nfts": [
              {
                  "chain": "polygon-amoy",
                  "contractAddress": "0x5E1ab2aC27f1a0AD28f1b0DDb0E00baF2677725e",
                  "tokenId": "1"
              }
          ],
          "metadata": {
              "name": "Crossmint Tickets",
              "description": "Access Crossmint Events",
              "image": "ipfs://Qme551yKU6a5Cptsk8hxcMtWwTrKkHArZtTTwFSvu19eFD",
              "credentialMetadata": {
                  "type": [
                      "VerifiableCredential",
                      "userName"
                  ],
                  "encryption": {
                      "type": "crossmint-recoverable"
                  },
                  "credentialsEndpoint": "ipfs://bafybeidmfu6xmdpxddads6nsyxfg6hd5ylj2drrywhzvfi2bbq45owklsa",
                  "issuerDid": "did:polygon:0xd9d8BA9D5956f78E02F4506940f42ac2dAB9DABd"
              }
          }
      },
      {
          "contractAddress": "0x38989746BF435d5f6Dc7C8DdE6038b5a17E62cE2",
          "chain": "polygon-amoy",
          "nfts": [
              {
                  "chain": "polygon-amoy",
                  "contractAddress": "0x38989746BF435d5f6Dc7C8DdE6038b5a17E62cE2",
                  "tokenId": "1"
              }
          ],
          "metadata": {
              "name": "Crossmint Tickets",
              "description": "Access Crossmint Events",
              "image": "ipfs://Qme551yKU6a5Cptsk8hxcMtWwTrKkHArZtTTwFSvu19eFD",
              "credentialMetadata": {
                  "type": [
                      "VerifiableCredential",
                      "userName"
                  ],
                  "encryption": {
                      "type": "crossmint-recoverable"
                  },
                  "credentialsEndpoint": "a",
                  "issuerDid": "did:polygon:0xd9d8BA9D5956f78E02F4506940f42ac2dAB9DABd"
              }
          }
      }
  ]
  ```
</CodeGroup>

Now that the credential is retrieved, it's important to decrypt it and verify it.

<Note>In case the endpoint is called by the issuer the credential will be automatically decrypted.</Note>

<CardGroup>
  <Card title="API Reference" icon="terminal" href="/api-reference/verifiable-credentials/credentials/retrieve-credential-by-id">
    Test any API in seconds directly from the docs.
  </Card>

  <Card title="Talk to an expert" icon="message" href="https://www.crossmint.com/contact/sales">
    Contact our sales team for support.
  </Card>
</CardGroup>


# Revoke Credentials
Source: https://docs.crossmint.com/minting/verifiable-credentials/integrate/revoke-credentials

Invalidate a credential, rendering it no longer trustworthy or verifiable

To revoke a credential, you can directly use the [revoke credential API](/api-reference/verifiable-credentials/credentials/revoke-credential). Burning the NFT associated with the credential via the [burn-nft](/api-reference/minting/nfts/burn-nft) API accomplishes the same result.

Issuers can revoke a Verifiable Credential without the subject's intermediation.

To revoke the credential, copy the `revokeCredential.js` file from below, use your API key, the credentialId, and run the file from your terminal.

```javascript revokeCredential.js theme={null}
const options = {
    method: "DELETE",
    headers: {
        "X-API-KEY": "YOUR_API_KEY",
    },
};

fetch(`https://staging.crossmint.com/api/v1-alpha1/credentials/${credentialId}`, options)
    .then((response) => response.json())
    .then((response) => console.log(JSON.stringify(response)))
    .catch((err) => console.error(err));
```

```shell theme={null}
node revokeCredential.js
```

<CardGroup>
  <Card title="API Reference" icon="terminal" href="/api-reference/verifiable-credentials/credentials/revoke-credential">
    Test any API in seconds directly from the docs.
  </Card>

  <Card title="Talk to an expert" icon="message" href="https://www.crossmint.com/contact/sales">
    Contact our sales team for support.
  </Card>
</CardGroup>


# Credential Storage
Source: https://docs.crossmint.com/minting/verifiable-credentials/integrate/store-credentials

Choose how to store credential data

When creating a [template](/minting/verifiable-credentials/integrate/create-credential-templates), you can specify a `storage` parameter to determine where the credential payload will be stored. The possible values for this parameter are:

* `crossmint`
* `crossmint-private`
* `delegated`
* `decentralized-ipfs`

## Crossmint

With this option, credentials are stored on the Crossmint database. This is the most flexible solution and is compatible with all other features.

<Warning>
  There is not access control on credential retrieval, credential data is public and can be retrieved by anyone, use
  [encrypted credentials](/minting/verifiable-credentials/integrate/encrypt-credentials) if you need to protect the
  data.
</Warning>

## Crossmint Private

This option is designed for integrated systems in which the issuer is also the verifier. Credentials are stored by Crossmint, but only the issuer can retrieve the credential payload. Because the credential issuer is also the credential verifier, there is no need to encrypt the credentials.

## Decentralized Storage

This option is the most open and transparent solution as it will store the credential to a decentralized storage (IPFS). All retrieval API endpoints will still be available and will proxy the request to ipfs.

[Encrypting the payload](/minting/verifiable-credentials/integrate/encrypt-credentials) is suggested to avoid private credential data being exposed to be public.

<Note> Credential issuance will be slower than other storage options.</Note>

## Delegated Storage

This option is designed for the enterprise, giving the issuer full control over the credentials. With delegated storage, no reference to the data is stored on Crossmint databases. The credential is returned to the issuer via the [webhook](/minting/verifiable-credentials/integrate/webhooks) and the issuer is responsible for storing it.

All Crossmint retrieval endpoints will consequently be disabled. A `delegatedStorageEndpoint` parameter must be added when creating the credential template that specifies the endpoint where the credential can be retrieved (can be set to a dummy value like "unknown" if not desired).

This endpoint will be saved in the contract metadata and can be used by users to retrieve the credential associated with their NFT. Issuers can protect content privacy by encrypting the payload.

<Note>
  For delegated storage, if the credential is not catched by the webhook, it will be lost. Read more about webhooks
  [here](/minting/verifiable-credentials/integrate/webhooks).
</Note>


# Verify Credentials
Source: https://docs.crossmint.com/minting/verifiable-credentials/integrate/verify-credentials

Ensure that the credential is valid

Verification is a crucial step in the process of handling Verifiable Credentials. To ensure a credential is valid, the following checks are performed:

* Credential Structure: The credential should not be malformed. It must adhere to the correct structure as defined by the [credential type](/minting/verifiable-credentials/integrate/create-credential-types) .

* Signature Validation: The credential’s signature must be valid and match the identity of the issuer. This ensures that the credential was indeed issued by the claimed issuer and hasn’t been tampered with.

* Attribute Check: No additional attributes should have been added to the credential beyond what’s defined in its schema. This prevents unauthorized modifications to the credential.

* Expiration Check: The credential should not have expired. Credentials often have a validity period after which they are no longer considered valid.

* Revocation Check: The credential should not have been revoked by the issuer. Even if a credential is valid and hasn’t expired, it may have been revoked by the issuer for various reasons.

By performing these checks, we can ensure the authenticity and validity of a Verifiable Credential. Verifying a credential can happen either via the Crossmint API or SDK.

## API

To verify a credential on the server-side use the Crossmint API and the following endpoint, passing the [retrieved](/minting/verifiable-credentials/integrate/retrieve-credentials) unencrypted credential JSON.

<CodeGroup>
  ```javascript verifyCredential.js theme={null}
  const options = {
      method: "POST",
      headers: {
          "X-API-KEY": "YOUR_API_KEY",
          "Content-Type": "application/json",
      },
      body: `{"credential": ${JSON.stringify(credential.unencryptedCredential)}}`,
  };

  fetch("https://staging.crossmint.com/api/v1-alpha1/credentials/verification/verify", options)
      .then((response) => response.json())
      .then((response) => console.log(JSON.stringify(response)))
      .catch((err) => console.error(err));
  ```

  ```json Response theme={null}
  {
      "isValid": true
  }
  ```
</CodeGroup>

<Note> Verifying a credential via the API will require a Crossmint developer account.</Note>

## SDK

With the Verifiable Credentials client-side SDK, the verification process is performed locally, eliminating the need for interaction with Crossmint. Consequently, there is no need for a Crossmint developer account to verify the credential.

Install the `@crossmint/client-sdk-verifiable-credentials` [npm package](https://www.npmjs.com/package/@crossmint/client-sdk-verifiable-credentials) and call the `verifyCredential` function passing a `VerifiableCredential` object, as shown below.

<CodeGroup>
  ```typescript decrypt.ts theme={null}
  import * as sdk from '@crossmint/client-sdk-verifiable-credentials';

  sdk.CrossmintAPI.init('YOUR_API_KEY');

  const decryptedCredential = <CredentialObject>;

  const verificationResult = await sdk.verifyCredential(decryptedCredential);

  console.log('Verification result:', verificationResult);

  ```

  ```json Response theme={null}
  {
      "isValid": true
  }
  ```
</CodeGroup>

<Note>
  Verifying the status of the NFT related to the credential requires connection to the internet in order to access
  blockchain state.
</Note>

For details on the SDK functionality, review our [SDK reference documentation](/sdk-reference/credentials/introduction).

## Independent Verification

Since Crossmint’s Verifiable Credentials are based on the [W3C standard](https://www.w3.org/TR/vc-data-model-2.0/), you can use any library that supports this standard to verify a credential.

The W3C Verifiable Credentials standard ensures interoperability across different platforms and systems, enhancing the reliability and security of the credential verification process.

<Note>
  Crossmint verification is stricter and performs additional checks that are not part of the W3C standard. For example, that no additional fields have been added to the credential.
</Note>

<CardGroup>
  <Card title="API Reference" icon="terminal" href="/api-reference/verifiable-credentials/credentials/verify-credential">
    Test any API in seconds directly from the docs.
  </Card>

  <Card title="Talk to an expert" icon="message" href="https://www.crossmint.com/contact/sales">
    Contact our sales team for support.
  </Card>
</CardGroup>


# Webhook
Source: https://docs.crossmint.com/minting/verifiable-credentials/integrate/webhooks

Receive updates about your credentials

Webhooks are a critical component in the management and distribution of verifiable credentials, providing real-time notifications and seamless integration for issuers. Here’s why webhooks enhance the credential issuance process:

* **Automatic Credential Retrieval**: Upon issuance, the credential is sent directly to the issuer through the webhook payload. This eliminates the need for issuers to manually call `getCredential()`. This functionality is especially crucial when the issuer opts for delegated storage; without catching the webhook, the credential could be lost, as there would be no subsequent retrieval.
* **Notification of Credential Issuance Failure**: Webhooks provide immediate alerts if the credential issuance process fails. This enables issuers to quickly identify and address issues, ensuring a reliable and efficient credential issuance process.
* **Secure Storage of Encryption Keys**: In scenarios involving encryption via the "crossmint-recoverable" encryption type, the webhook stores the encryption key for the recipient subject. This ensures that, in case of any fallback, the key is readily available, maintaining the security and accessibility of the encrypted credentials.
* **Immediate Access to Credential Pass Links**: Issuers can instantly receive a link to the wallet credential pass via the webhook. This link can then be forwarded to the subject, ensuring a swift and efficient delivery of credentials.

If you choose not to use a webhook, you can query for the credential's status via the [status API](https://docs.crossmint.com/api-reference/minting/nfts/mint-status).

## Setting Up a Webhook

First, you need to [setup a webhook](https://docs.crossmint.com/docs/mintapi-webhooks) in the developer console. Once that is done either programmatically or via the Dev Console, the webhook payload received, looks as follows:

```json theme={null}
data:{
    credential: credentialObject or encryptedCredentialObjcet
    pass: wallet pass object
    secret: encryption key
}
```

The events you can monitor are:

* `credential.creation.succeeded`
  Will be emitted when the credential creation process is complete.
  The issued credential, credential pass, and encryption key will be contained in the `data.credential` field, `data.pass` field, and `data.secret` field, respectively.
  In case of encrypted credential templates, the issued credential returned will be encrypted.

* `credential.creation.failed`
  Will be emitted when the credential creation process fails. The error will be contained in the `data.error` field.


# NFT Drops Gated by Accesslists
Source: https://docs.crossmint.com/payments/advanced/accesslists

Allow purchasing in accesslist-protected NFT drops

## Access Lists

<Note>
  Accesslist support is a premium feature. To get started, [contact sales](https://www.crossmint.com/contact/sales)
</Note>

Crossmint allows you to whitelist both wallet and email addresses. Once the team
has approved your request, you will need to provide the following information:

1. Your Crossmint `clientId` or `collectionId` for the collection.

2. The list of wallet and email addresses to be included in the accesslist.

<Tip>
  If you whitelist users' email addresses, Crossmint will create wallets associated with those email addresses and
  provide them to you for inclusion in the accesslist. Users will then be able to authenticate during the purchase and
  execute the transaction.
</Tip>

<Tabs>
  <Tab title="EVM">
    You can set up accesslists using Merkle Trees or inserting the list of whitelisted addresses directly on the smart contract:

    ### A. Merkle Tree Accesslists

    While using Merkle Trees is more gas-efficient, it involves a slightly more complex setup.
    Here is an example accesslist mint function:

    <Accordion title="See Example">
      ```solidity Solidity theme={null}
      //SPDX-License-Identifier: Unlicense
      pragma solidity ^0.8.0;

      import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
      import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
      import "@openzeppelin/contracts/access/Ownable.sol";

      contract Accesslist is ERC721, Ownable {
          bytes32 public merkleRoot;
          uint256 public nextTokenId;
          mapping(address => bool) public claimed;

          constructor() ERC721("ExampleNFT", "NFT") {
              merkleRoot = 0x0;
          }

          function isWhiteListed(bytes32[] memory proof, bytes32 leaf) public view returns(bool) {
              return MerkleProof.verify(proof, merkleRoot, leaf);
          }

          function setMerkleRoot(bytes32 merkleRoot_) external onlyOwner {
              merkleRoot = merkleRoot_;
          }

          function mint(address to, bytes32[] calldata merkleProof) public payable {
              require(claimed[to] == false, "already claimed");
              claimed[to] = true;
              require(
                  isWhiteListed(
                      merkleProof,
                      keccak256(abi.encodePacked(to))
                  ),
                  "invalid merkle proof"
              );
              nextTokenId++;
              _mint(to, nextTokenId);
          }
      }
      ```
    </Accordion>

    ### B. Mapping-Based Accesslists

    The most straightforward method of whitelisting involves maintaining
    a mapping of the whitelisted addresses within your smart contract.
    This approach is faster but consumes more gas and savvy developers
    may be able to determine the addresses of the accesslist.

    <Accordion title="See Example">
      ```solidity Solidity theme={null}
      mapping(address => uint256) public whitelistMapping;
      ```

      ```solidity Solidity theme={null}
      function presale(address _to, uint256 _count) external payable {
          // ensure _to address has tokens left to mint
          require(whitelistMapping[_to] > 0, "no whitelist tokens for user");

          // decrement mapping for user
          whitelistMapping[_to] -= _count;

          // presale minting logic here
      }
      ```
    </Accordion>
  </Tab>

  <Tab title="Solana">
    You can set up accesslists on your Candy Machine using Merkle Trees or SPL Tokens

    ### A. Merkle Tree Accesslists

    Simply send the user IDs to Crossmint. Once you have the Merkle proof, you can pass it into the Crossmint Hosted Checkout `lineItems.callData` as a string, as in the example below:

    <Accordion title="See Example">
      ```jsx React theme={null}
      <CrossmintProvider apiKey="_YOUR_CLIENT_API_KEY_">
          <CrossmintHostedCheckout
              lineItems={{
                  collectionId: "crossmint:_YOUR_COLLECTION_ID_",
                  callData: {
                      type: "candy-machine",
                      quantity: 1,
                      mintingGroup: "pre",
                      merkleProof: "62, 43, 204, 46, 222, 219, 236, 32, 60, 4, 235, [...]",
                  }
              }}
          />
      </CrossmintProvider>
      ```
    </Accordion>

    ### B. SPL Token-based Accesslists

    You can whitelist wallets by airdropping them SPL tokens.
  </Tab>
</Tabs>

## Geofencing

<Note>
  Geofencing support is a premium feature only available to customers on a paid plan. To get started, [contact
  sales](https://www.crossmint.com/contact/sales)
</Note>

Crossmint supports geofencing capabilities through our Customer Success Engineering (CSE) team. Our CSE team can work with you to block transactions from specific countries or geographic regions via Stripe rules.

To set up geofencing for your project, please contact our sales team to discuss your specific requirements and implementation details.


# NFT Drops with Dynamic Price or Quantity
Source: https://docs.crossmint.com/payments/advanced/dynamic-quantity-and-price

Details about implementing dynamic functionality into the Checkout

See the below examples to understand how to implement dynamic pricing or quantity into your dApp.

<Check>
  The examples below use the [Hosted Checkout](/payments/pay-button/overview), but the same approach is compatible
  with the [Embedded Checkout](/payments/embedded/overview) as well.
</Check>

<CodeGroup>
  ```jsx React theme={null}
  import { useState } from 'react';
  import { CrossmintProvider, CrossmintHostedCheckout } from "@crossmint/client-sdk-react-ui";

  function App() {
      const [mintAmount, setMintAmount] = useState(1);
      const nftCost = 0.001;
      const apiClientId = '_YOUR_API_CLIENT_ID_';
      const collectionId = '_YOUR_COLLECTION_ID_';

      const handleDecrement = () => {
          if (mintAmount <= 1) return;
          setMintAmount(mintAmount - 1);
      }

      const handleIncrement = () => {
          if (mintAmount >= 3) return;
          setMintAmount(mintAmount + 1);
      }

      return (
          <CrossmintProvider apiKey={apiClientId}>
              <>
                  <button onClick={handleDecrement}> - </button>
                  <input
                      readOnly
                      type="number"
                      value={mintAmount}
                  />
                  <button onClick={handleIncrement}> + </button>
                  <CrossmintHostedCheckout
                      lineItems={
                          {
                              collectionId: collectionId,
                              callData: {
                                  totalPrice: (nftCost * mintAmount).toString(),
                                  _quantity: mintAmount // the `_quantity` property should match what is in your mint function
                                  // your custom minting arguments...
                              }
                          }
                      }
                  />
              </>
          </CrossmintProvider>
      );
  }

  export default App;
  ```
</CodeGroup>


# Improving Conversion
Source: https://docs.crossmint.com/payments/advanced/improving-conversion

Best practices to maximize checkout conversion

Here are a selection of best practices you can follow to optimize conversion on your checkout flow.

## 1. Ensure your checkout has the right locale

Improper locales can significantly reduce conversion. Double check that your checkout is configured to work in the locales you have customers.

You can manage the locale in your [integrated checkout components](/payments/embedded/reference/react#mintconfig), or your [payment order objects.](/payments/headless/guides/order-lifecycle/quote-phase#update-the-locale)

## 2. Choose the best payment methods

You may have data that shows your customers convert better with one payment method over another one. Customizing your checkout to feature these preferred payment methods by default is a good way to improve your conversion.

**Embedded Checkout** - Set the default payment method as your customers most preferred one (i.e. Apple Pay, Sol, etc.)

**Headless Checkout** - you have full control over your UI. Put the payment method your customers prefer as default option, and pre-fill as much information as you can.

## 3. Further customize your checkout flow

You may know your customer very well, and what exactly increases conversion for them: large images, progress bars, loyalty point reward offers.

Building these bespoke checkout experiences can increase your conversion. [Embedded](/payments/embedded/overview) or [headless checkout](/payments/headless/overview) are more customizable checkout tools.


# NFT Marketplaces & Launchpads
Source: https://docs.crossmint.com/payments/advanced/marketplaces-and-launchpads

Add fiat and cross-chain crypto payments to your platform

<Accordion title="Additional services offered to marketplaces and launchpads">
  Crossmint offers additional services to marketplaces and launchpads,
  including:

  * Custom branding and email receipts

  * Dedicated Slack channel with Crossmint's support team

  * Custom SLAs

  * APIs to register new collections programmatically

  * Increased purchase limits

  * Cart mode and ability to sweep the floor

  ...and more
</Accordion>

<Tabs>
  <Tab title="Marketplaces">
    ### Integrating Crossmint into a marketplace

    Integrating Crossmint into a marketplace can be as simple as
    adding five lines of code, depending on the level of customization required.

    The following snippet would be sufficient to render a button that enables
    the purchase of one of your listings with credit card.

    <CodeGroup>
      ```jsx EVM theme={null}
      <CrossmintProvider apiKey="_YOUR_CLIENT_API_KEY_">
        <CrossmintHostedCheckout
          lineItems={{
              tokenLocator: "ethereum:0xbC…307e:7777",
              callData: {
                totalPrice: "0.1"
              }
            }}
        />
      </CrossmintProvider>
      ```

      ```jsx Solana theme={null}
      <CrossmintProvider apiKey="_YOUR_CLIENT_API_KEY_">
        <CrossmintHostedCheckout
          lineItems={{
              tokenLocator: "solana:4oDd…x6NC",
              callData: {
                totalPrice: "0.1",
                buyerCreatorRoyaltyPercent: 100
              }
            }}
        />
      </CrossmintProvider>
      ```
    </CodeGroup>

    <br />

    <Note>[Contact sales](https://www.crossmint.com/contact/sales) to get started.</Note>
    <Tip>If you are building a new marketplace, use one of the supported contracts for a faster integration. If you are looking for help building a marketplace, [contact us](https://www.crossmint.com/contact/sales) and the Crossmint team will introduce you to the right partner.</Tip>

    ### FAQs

    <AccordionGroup>
      <Accordion title="What marketplaces are supported">
        <Snippet />
      </Accordion>

      <Accordion title="Supported contracts">
        Crossmint supports a wide range of contracts across chains, including:

        | Blockchain | Contract                                                                                    |
        | :--------- | :------------------------------------------------------------------------------------------ |
        | EVM        | Rarible, Seaport, OpenSea, Zora, LooksRare, 0x, Foundation, CoinbaseNFT, Sudoswap, Manifold |
        | Solana     | Auction House, Magic Eden API, Hyperspace, Exchange.art                                     |

        <Note>Custom integrations available only for enterprise clients.</Note>
      </Accordion>

      <Accordion title="Where can I test it?">
        You can see a live implementation of the payment button on [Tensor](https://tensor.trade/).
      </Accordion>

      <Accordion title="What is the maximum transaction limit?">
        The default transaction limit is 7,000 USD. If you need a higher limit, [contact us](https://www.crossmint.com/contact/sales)
      </Accordion>
    </AccordionGroup>
  </Tab>

  <Tab title="Launchpads">
    ### Integrating Crossmint into a launchpad

    The integration is identical to that of the standard digital asset checkout. However, Crossmint offers additional services to improve the creator experience, including the ability to register collections via API.

    <br />

    <Note>[Contact sales](https://www.crossmint.com/contact/sales) to get started.</Note>

    ### FAQs

    <Accordion title="Where can I test it?">
      Crossmint powers most major launchpads across chains. You can see in action on [Manifold](https://app.manifold.xyz/c/sleeping-potato) and [Highlight](https://highlight.xyz/mint/6525a4b606bc6fa5b8acdcfa).
    </Accordion>

    <Accordion title="How does creator and collection verification work?">
      For primary sales, Crossmint requires creators to do <Tooltip>light KYC</Tooltip> and confirm their project meets Crossmint's [content policy](https://drive.google.com/file/d/1kXv5gX7C8xHJFDAnCQTNUmXrDP05YYk1/view). There are multiple options to achieve this:

      * You can conduct project verification yourself.
      * You can send creators to register their collection at Crossmint.com and share their collectionID with you, so you can pass it to the digital asset checkout.
      * (Coming soon) You can use Crossmint's collection verification SDK to verify creators directly on your site.
    </Accordion>
  </Tab>
</Tabs>


# Mint to Specific Template
Source: https://docs.crossmint.com/payments/advanced/mint-to-specific-template

Specify which NFT template to mint from during checkout (for Managed collections only)

## Overview

When minting NFTs from a collection with multiple templates, you can specify which template to mint to using your Crossmint integration. This feature must be explicitly enabled in the Crossmint Console.

This gives you control over exactly which template gets minted when processing a purchase, rather than relying on random template selection.

## Supported Collection Types

Selecting a specific token template for purchase is supported on:

* EVM ERC-721 and ERC-1155 collections
* Solana collections

In the following chains, tokens will always be selected randomly:

* Aptos collections

## Enabling Template Minting

Follow these steps in the Crossmint Console to enable template-specific minting:

1. Go to your collection in the Crossmint Console
2. Navigate to the "Checkout" section
3. Under "NFT Template Settings", enable "Mint to specific NFT Template"

<img alt="" />

## Using Template IDs

<Warning>
  If template-specific minting is disabled for your collection and you pass a template ID in the collection locator,
  the request will select a template randomly. Make sure to enable this feature in the Console before using template IDs.
</Warning>

<Note>
  To see all your available templates, navigate to the "NFTs" section in the Console for your managed collection.

  You can also get all your available templates for a collection using the [NFT Template API](/api-reference/minting/template/get-all-templates).
</Note>

Once enabled, specify which template to mint by adding the template ID to your collection locator. The collection locator format without templateId is:

```
crossmint:<collectionId>
```

and with templateId is:

```
crossmint:<collectionId>:<templateId>
```

The `templateId` portion is optional with mint to specific template enabled. If omitted, the system will use your collection's default minting behavior.

Here's how to implement template minting in your integration:

<Tabs>
  <Tab title="Embedded Checkout v3">
    Add the template ID to your collection locator string:

    ```jsx theme={null}
    <CrossmintProvider apiKey={clientApiKey}>
      <CrossmintEmbeddedCheckout
        lineItems={{
          // For a specific template:
          collectionLocator: `crossmint:${collectionId}:${templateId}`,
          // Or for random template selection:
          // collectionLocator: `crossmint:${collectionId}`,
          callData: {
            totalPrice: "0.001",
            quantity: 1,
          },
        }}
      />
    </CrossmintProvider>
    ```
  </Tab>

  <Tab title="Headless Checkout">
    Add the template ID to your collection locator string when creating an order:

    ```json theme={null}
    {
      "payment": {
        "method": "stripe-payment-element"  // or your preferred payment method
      },
      "lineItems": [
        {
          // For a specific template:
          "collectionLocator": "crossmint:<collectionId>:<templateId>",
          // Or for random template selection:
          // "collectionLocator": "crossmint:<collectionId>",
          "callData": {
            "totalPrice": "0.001"
          }
        }
      ]
    }
    ```
  </Tab>
</Tabs>

## Error Handling

When implementing template minting, handle these potential error cases:

1. **Invalid Template ID**

   * Error message: Transaction fails with template validation error
   * Occurs when: The specified template ID doesn't exist in the collection
   * Resolution: Verify the template ID exists in your collection

2. **No Code Storefront**
   * Mint to specific template is not currently supported on No Code Storefront. If you'd like this feature, please reach out to your CSE rep

Here's how to handle these errors in your code:

<Tabs>
  <Tab title="Embedded Checkout v3">
    ```jsx theme={null}
    try {
      <CrossmintProvider apiKey={clientApiKey}>
        <CrossmintEmbeddedCheckout
          lineItems={{
            collectionLocator: `crossmint:${collectionId}:${templateId}`,
            callData: {
              totalPrice: "0.001",
              quantity: 1,
            },
          }}
          onError={(error) => {
            if (error.message.includes(`Template ${templateId} was not found in collection`)) {
              // Invalid template ID
              throw new Error("Invalid template ID provided");
            }
            throw error
          }}
        />
      </CrossmintProvider>
    } catch (error) {
      // Handle other errors
      console.error("Minting failed:", error);
    }
    ```
  </Tab>

  <Tab title="Headless Checkout">
    ```typescript theme={null}
    try {
      const response = await fetch("/api/create-order", {
        method: "POST",
        body: JSON.stringify({
          lineItems: [
            {
              collectionLocator: `crossmint:${collectionId}:${templateId}`,
              callData: {
                totalPrice: "0.001"
              }
            }
          ]
        })
      });

      if (!response.ok) {
        const error = await response.json();
        if (error.message.includes(`Template ${templateId} was not found in collection`)) {
          // Invalid template ID
          throw new Error("Invalid template ID provided");
        }
        throw error;
      }
    } catch (error) {
      // Handle the error appropriately
      console.error("Order creation failed:", error);
    }
    ```
  </Tab>
</Tabs>


# Receipt Customization
Source: https://docs.crossmint.com/payments/advanced/receipt-customization

Customize your users' order receipt

Customizing the order receipt that gets sent to your users' email addresses is possible under our Enterprise plan.

## Elements that can be customized

* **Subject**: the subject of the email.
* **Header**: the header of the email.
* **Body**: the body of the receipt within the email.
* **Company logo**: you can add your company logo.
* **Remove Crossmint's links**: you can also remove Crossmint's social links and buttons (included in the default receipt sent).
* **Remove transaction hash**: you can also remove the transaction hash (included in the default receipt sent).

## Elements that cannot be customized

* You cannot include the user's name in the receipt as this information is not always available.
* You cannot remove the "Payment powered by Crossmint" message on the footer for compliance.

<Note>Please contact your Crossmint customer success engineer and provide them with the above information.</Note>

<AccordionGroup>
  <Accordion title="What does the default purchase receipt look like?">
    Here is an example of the default purchase receipt that is emailed to users:

    <img alt="Crossmint default purchase receipt" />
  </Accordion>

  <Accordion title="What does a customized purchase receipt look like?">
    Here is an example of a customized purchase receipt that is emailed to users:

    <img alt="Crossmint customized purchase receipt" />
  </Accordion>
</AccordionGroup>


# Collection Registration and Verification API
Source: https://docs.crossmint.com/payments/advanced/registration-and-verification-api

Launchpads now use Crossmint's API to register and verify a collection.

Crossmint provides an API to facilitate collection registration and verification. This functionality is for launchpads that want to use Crossmint's checkout and allow their users to go through the KYC and collection verification flow.

## Before you get started:

Contact your Crossmint customer success engineer to request the `collections.write` scope be added to an existing API key. You will need to provide the projectId associated with the API key you will be using.

Your contract also needs to meet certain requirements. Please refer to the [Register External Collection](/payments/guides/register-collection) documentation page for further information.

<Note>Please do not share your API key secret with the Crossmint team or anyone else.</Note>

## Collection Registration and Verification process

Once a user has created a collection on your launchpad, you can optionally choose to register the collection with Crossmint to enable Credit Card payments. This API abstracts away much of the complexity involved from the user when they perform KYC and the collection verification process.

As the launchpad, you will pass information about the collection as parameters to the API. Crossmint will then return a URL where the user can complete the KYC and collection verification. This API call's structure is as follows:

<Tab title="Hosted Checkout">
  Sample code for the collection registration and verification API. Click on "Response" to see what a successful response will look like.

  <CodeGroup>
    ```jsx JavaScript theme={null}
       // Define the API URL
       const apiUrl = "https://staging.crossmint.com/api/v1-alpha1/collections";

       // Set up the request body with actual data instead of placeholders
       const requestBody = {
          chain: "ethereum", // replace with actual chain name
          contractType: "erc-721", // choose between "erc-721" or "erc-1155" or "thirdweb-drop" or "candy-machine"
          args: {
              contractAddress: "0x123...", // replace with actual contract address
              mintFunctionName: "mintUSDC(address,uint256)", // specify the mint function
              abi: [], // provide the actual contract ABI array
              toParamName: "toAddress", // specify the 'to' parameter name in the mint function
              erc20MintCurrency: "usdc", // the ERC20 currency to be used for minting
          },
          metadata: {
              title: "<collection_title>", // replace '<collection_title>' with the actual collection name
              description: "<description>", // replace `<description>` with the actual collection's description
              imageUrl: "<image_url>", // replace '<image_url>' with actual URL to an image
          },
          ownership: "external", // optional - if you are regestering the collection on behalf of a creator or yourself, choose "external". Else, choose "self".
          category: "art", // specify the verification category - this expedites the collection review
          scopes: ["payments:credit-card"], // required scopes- "payments:cross-chain" or "payments:credit-card", must specify at least one
      };
      // Set up the request options
      const requestOptions = {
          method: "POST",
          headers: {
              'Content-Type': 'application/json',
              'X-API-KEY': '<api-key>', // replace '<api-key>' with the API Key that has the scope `collections.write`
          },
          body: JSON.stringify(requestBody), // Convert the JavaScript object to a JSON string
      };
      // Make the fetch request
      fetch(apiUrl, requestOptions)
      .then((response) => response.json()) // Parsing the JSON response
      .then((data) => console.log("Success:", data))
      .catch((error) => console.error("Error:", error));
    ```

    ```json Response (Successful) theme={null}
       {
          "isClaimed": false,
          "claimUrl": "https://www.crossmint.com/claim/collection/<collectionId>";
          "collectionId": "<your-collection-id-string>",
       }


    ```
  </CodeGroup>
</Tab>

The returned URL must be the URL that your user needs to be directed to. The user can complete the verification with that URL.

## Get Collection status

You can check the status of your user's verification with the get collection status endpoint. Upon a successful request, the verification `status` for the `seller` and `collection` may have either of the following values:

* `verified` - The user has successfully completed the verification.
* `failed` - The verification failed.
* `crossmint-review` - It is being reviewed by the Crossmint team.
* `unverified` - The user has not initiated or completed the verification process.

<CodeGroup>
  ```jsx JavaScript theme={null}
     // Replace '<collectionId>' with the collectionId returned in the successful POST response
     const collectionId = 'your_collection_id'; // Replace 'your_collection_id' with the actual ID
     const apiUrl = `https://staging.crossmint.com/api/v1-alpha1/collections/${collectionId}`;
     
     // Set up the request options
     const requestOptions = {
        method: 'GET',
        headers: {
            'X-API-KEY': '<api-key>', /// replace '<api-key>' with your API Key
            'Content-Type': 'application/json',
        }
    };
    
    // Make the fetch request
    fetch(apiUrl, requestOptions)
    .then(response => {
        if (!response.ok) {
            throw new Error('Network response was not ok: ' + response.statusText);
        }
        return response.json(); // Parse the JSON from the response
    })
    .then(data => console.log('Success:', data)) // Handle the parsed data
    .catch(error => console.error('Error:', error)); // Handle any errors
  ```

  ```json Response (Successful) theme={null}
     {
        "isClaimed": true,
        "verificationStatus": {
            "seller": {
                "status": "verified"
            },
            "collection": {
                "status": "verified"
            },
        },
        "claimUrl": null,
    }
  ```
</CodeGroup>

***

## FAQs

<AccordionGroup>
  <Accordion title="What are the possible inputs for the category parameter?">
    You can find all the possible inputs below:

    ```json VerificationCategory inputs theme={null}
       VerificationCategory {
        LOYALTY: "loyalty",
        ART: "art",
        MUSIC: "music",
        GAMING: "gaming",
        TICKETING: "ticketing",
        CHARITY: "charity",
        OTHER: "other",
       }
    ```
  </Accordion>

  <Accordion title="Does every collection require seller's KYC and collection verification?">
    The verification requirement varies by the payment type selected for the collection.

    * Credit card: Seller and collection status must be “verified”.
    * Crypto: Only collection status must be “verified”.
  </Accordion>
</AccordionGroup>


# Checking Supported Tokens
Source: https://docs.crossmint.com/payments/advanced/supported-tokens

Learn how to check if a memecoin or token is supported by Crossmint Checkout

<Snippet />

## Introduction

Before integrating a memecoin or token using Crossmint's checkout, it's important to verify that it's supported by Crossmint. This guide will show you how to use the Crossmint API to check if a specific token is supported and what features are available for it.

## Prerequisites

<Steps>
  <Step title="Create a server-side API key">
    Get your API keys from the [Crossmint Console](https://www.crossmint.com/console/projects/apiKeys)

    <Snippet />

    [More info on creating API keys here](/introduction/platform/api-keys#how-to-get-and-use-api-keys)
  </Step>

  <Step title="Enable the orders.create scope">
    Make sure the `orders.create` scope is enabled for your API key.
  </Step>
</Steps>

## Getting Started

The Supported Tokens API allows you to query the status of any token to determine if it's supported by Crossmint and what features are available.

* **Endpoint**: `https://www.crossmint.com/api/v1-alpha2/tokens/:tokenLocator`
* **Method**: GET
* **Authentication**: Requires either a server or client API key

### Token Locator Format

Memecoin checkout supports the **Solana** and **Base** networks.

The token locator follows this format:

```
network:tokenAddress
```

Example:

* **Staging**: Use the XMEME test token: `solana:7EivYFyNfgGj8xbUymR7J4LuxUHLKRzpLaERHLvi7Dgu`
* **Production**: Use any supported token, e.g. TRUMP: `solana:6p6xgHyF7AeE6TZkSmFsko444wqoP15icUSqi2jfGiPN`

<Note>
  Production memecoin tokens **will not work** in the **staging** environment.
</Note>

## Checking Token Support

### Using JavaScript

Here's how to check if a token is supported using JavaScript:

```javascript theme={null}
// Example usage
const apiKey = "your-api-key"; // Replace with your actual API key
const tokenLocator = "solana:6p6xgHyF7AeE6TZkSmFsko444wqoP15icUSqi2jfGiPN"; // Example: TRUMP token

const checkTokenSupport = async (apiKey, tokenLocator) => {
    try {
        const response = await fetch(`https://www.crossmint.com/api/v1-alpha2/tokens/${tokenLocator}`, {
            method: "GET",
            headers: {
                "x-api-key": apiKey,
                "Content-Type": "application/json",
            },
        });

        const data = await response.json();
        return data;
    } catch (error) {
        console.error("Error checking token support:", error);
        throw error;
    }
};

checkTokenSupport(apiKey, tokenLocator)
    .then((result) => {
        console.log("Token support details:", result);

        if (result.available) {
            console.log("This token is supported by Crossmint!");
        } else {
            console.log("This token is not currently supported.");
        }

        console.log("Available features:", result.features);
    })
    .catch((err) => {
        console.error("Failed to check token support:", err);
    });
```

### Sample Response

A successful response will look similar to this:

```json theme={null}
{
    "token": "solana:6p6xgHyF7AeE6TZkSmFsko444wqoP15icUSqi2jfGiPN",
    "available": true,
    "features": {
        "creditCardPayment": true
    }
}
```

## Integrating with Your Checkout Flow

Once you've confirmed that a token is supported, you can use the information from the API response to customize your checkout experience.

### Example: Pre-checkout Validation

Here's an example of how to incorporate token support checking before initiating a checkout:

```javascript theme={null}
const initiateCheckout = async (apiKey, tokenLocator, amount, recipientWallet) => {
    // First, check if the token is supported
    const tokenSupport = await checkTokenSupport(apiKey, tokenLocator);

    if (!tokenSupport.available) {
        throw new Error("This token is not currently supported by Crossmint.");
    }

    if (!tokenSupport.features.creditCardPayment) {
        throw new Error("Credit card payment is not available for this token.");
    }

    // If we get here, the token is supported with credit card checkout
    // Proceed with creating an order
    const orderResponse = await fetch("https://www.crossmint.com/api/2022-06-09/orders", {
        method: "POST",
        headers: {
            "x-api-key": apiKey,
            "Content-Type": "application/json",
        },
        body: JSON.stringify({
            lineItems: [
                {
                    tokenLocator: tokenLocator,
                    executionParameters: {
                        mode: "exact-in",
                        amount: amount,
                        maxSlippageBps: "500",
                    },
                },
            ],
            payment: {
                method: "stripe-payment-element",
                receiptEmail: "user@example.com", // Replace with user's email
            },
            recipient: {
                walletAddress: recipientWallet,
            },
        }),
    });

    return await orderResponse.json();
};
```

## Best Practices

1. **Cache Results (with caution)**: Token support status can change, but for frequently accessed tokens, consider caching results for a short period (e.g., 1 hour) to reduce API calls.

2. **Handle Errors Gracefully**: Implement proper error handling to provide clear feedback to users when a token is not supported.

3. **Check Before Displaying Options**: Only display payment methods that are actually available for the token.

## Next Steps

<CardGroup>
  <Card title="Credit Card Memecoin Checkout" icon="credit-card" href="/payments/headless/quickstarts/credit-card-memecoin-cko">
    Now that you can check token support, learn how to implement a credit card checkout for memecoins
  </Card>

  <Card title="Order Lifecycle" icon="rotate" href="/payments/headless/guides/order-lifecycle">
    Understand the lifecycle of orders in Crossmint's checkout flow
  </Card>
</CardGroup>

## FAQ

<AccordionGroup>
  <Accordion title="Can I request support for a specific token?">
    Yes, if you'd like to request support for a token that is currently unsupported, contact our [support team](https://help.crossmint.com).
  </Accordion>

  <Accordion title="What happens if I try to process a transaction for an unsupported token?">
    Transactions for unsupported tokens will fail. This is why it's crucial to check token support before initiating
    a checkout process.
  </Accordion>

  <Accordion title="Are all payment methods available for all supported tokens?">
    No, each token may have different available payment features. The API response includes a `features` object that
    specifies which payment methods are available for each token.
  </Accordion>

  <Accordion title="Is there a limit to how many tokens I can check?">
    The API is rate-limited to 50 requests per second. For most applications, this should be more than sufficient.
  </Accordion>
</AccordionGroup>


# Testing Tips
Source: https://docs.crossmint.com/payments/advanced/testing-tips

This document is intended to share some of the best practices and tips for testing.

## Limits in Staging

<Tip>
  In order to preserve testnet ETH/tokens, Crossmint imposes very low upper bound limits on NFT prices in the staging
  environment. The default limit on production is USD $0.75 - $1,500 per transaction.
</Tip>

To avoid issues, set the `totalPrice` and the onchain NFT price to no more than:

* Ethereum (Sepolia): 0.000005 ETH (this applies for other EVM chains as well)
* Polygon (Amoy): 0.005 MATIC
* Solana (Devnet): 0.001 SOL
* USDC (all chains): \$10
* Other chains: the equivalent of \$0.10 in the native token

<Note>
  The minimum credit card charge amount is \$0.50. Even though the price of the NFT at the above rates will often be
  less the \$0.01, the checkout will still show \$0.50. This will be less of an issue on production when you're
  charging full price.
</Note>

## Test Credit Card Numbers

When testing the Checkout and credit card payments on staging you'll need to use test card numbers. You can use these cards to test the flow end-to-end without actually processing real payments.

You can use the following test credit card numbers:

* `4242424242424242` (Visa)
* `4000056655665556` (Visa Debit)
* `5555555555554444` (Mastercard)
* `5200828282828210` (Mastercard Debit)

For `CVV` or `CVC`, use any 3 digit number

For `Expiry Date` or `MM/YY`, enter any future date

### Advanced Card Testing

If you want to simulate purchases from [different countries](https://stripe.com/docs/testing?testing-method=card-numbers#international-cards), [decline conditions](https://stripe.com/docs/testing?testing-method=card-numbers#declined-payments), or other [brands](https://stripe.com/docs/testing?testing-method=card-numbers#cards) refer to the [Stripe documentation](https://stripe.com/docs/testing?testing-method=card-numbers) for more test card numbers.

## Reviewing Orders in the Developer Console

You can get insights into the purchases being made against your collection by navigating to the Orders tab for your collection in the Developer Console. You can use this to get insights about orders in production, but also to see the status of orders when testing out your integration in the staging environment.

<Frame type="simple">
  <img alt="Orders view in developer console" />
</Frame>

<Note>
  When looking for pre-completion phase orders while testing [Headless Checkout](/payments/headless/overview), you'll
  need to enter the order ID in the search box. This is because the console view purposefully has a reduced list of
  status options for filtering.
</Note>


# NFT Drops Priced in USDC
Source: https://docs.crossmint.com/payments/advanced/usdc-support

How to set up Crossmint if your collection is denominated in USDC

<Tip>
  By denominating your collection in USDC, you can eliminate price volatility, and offer a more accessible experience
  to users.
</Tip>

## Ensure you are using a supported USDC token

First of all, make sure your collection is denominated in one of the USDC token addresses supported by Crossmint.

<div>
  <table>
    <thead>
      <tr>
        <th>Chain</th>
        <th>Network</th>
        <th>USDC Token Address</th>
        <th>USDXM Token Address</th>
      </tr>
    </thead>
  </table>
</div>

<Note>
  USDC.e is only supported on previously registered integrations on Polygon mainnet. Please use the native USDC
  address for new projects.
</Note>

<Check>
  If you need some testnet USDC you can mint it freely from the contract or from this faucet app that uses the same
  testnet token contracts as the Checkout tools.

  [Crossmint Testnet USDXM Faucet](https://usdc-faucet.vercel.app/)
</Check>

## Validate your collection meets the requirements

<Tabs>
  <Tab title="EVM">
    In addition to the standard requirements, keep in mind:

    1. **The mint function should be `nonpayable`.**
    2. **The USDC token has 6 decimals** instead of 18 like ETH, Matic, and most other tokens.
    3. **The `totalPrice` attribute in the `callData` of your `lineItems` should be in units of USDC**. If your intended price is 100 USD, then you will set `totalPrice` to `100` e.g. `totalPrice="100"`.
    4. **Your ERC-20 transfer call must request the funds from `msg.sender`** instead of the address parameter. This allows Crossmint to pay from our fleet of treasury wallets and deliver the NFTs directly to the user's wallet. See an example mint function below.

    ```solidity Solidity theme={null}
    function mintUSDC(address _to) public {
      // pre payment logic here

      // note that you need to transfer from msg.sender, NOT the _to address
      tokenInstance.transferFrom(msg.sender, address(this), priceUSDC );

      // actual minting logic here
    }
    ```

    ```tsx theme={null}
    <CrossmintProvider apiKey="_YOUR_CLIENT_API_KEY_">
        <CrossmintEmbeddedCheckout
            lineItems={{
                collectionLocator: "crossmint:_YOUR_COLLECTION_ID_",
                callData: {
                    totalPrice: "100", // 100 USDC
                    quantity: 1,
                }
            }}
        />
    </CrossmintProvider>
    ```

    <Note>The `totalPrice` attribute in the `callData` of your `lineItems` should be in units of USDC. If your intended price is 100 USD, then you will set `totalPrice` to `100` e.g. `totalPrice="100"`.</Note>

    <Accordion title="Using a thirdweb contract?">
      Add a claim phase with currency type `USDC`. In staging. you must use `Custom ERC-20` and specify one of the token address listed above. In mainnet, you should select the default USDC option.
    </Accordion>
  </Tab>

  <Tab title="Solana">
    Denominate your candy machine on USDC and Crossmint will automatically detect it. You can learn how on this [guide](https://medium.com/crossmint-tech/how-to-create-a-fixed-price-usdc-nft-drop-on-solana-2ab251e61384).
  </Tab>
</Tabs>


# Webhooks
Source: https://docs.crossmint.com/payments/advanced/webhooks

Track order lifecycle events and payment status with webhooks

# Webhooks Overview

Webhooks allow you to track the status of payments and order lifecycle events in your application. They provide real-time notifications for various events like payment processing, NFT minting, and order fulfillment.

## Webhook Systems by Checkout Version

Crossmint offers different webhook systems for Checkout V2 and V3:

### Checkout V2 Webhooks (Legacy)

The Checkout V2 webhook system provides basic payment tracking with a single event type:

* `purchase.succeeded` - Triggered when an NFT has been successfully purchased and delivered

### Checkout V3 Webhooks (Current)

The Checkout V3 webhook system offers comprehensive order lifecycle tracking with multiple event types:

**Quote Phase**

* `orders.quote.created` - Triggered when a new order is created
* `orders.quote.updated` - Triggered when order details are modified

**Payment Phase**

* `orders.payment.succeeded` - Triggered when payment is successfully processed
* `orders.payment.failed` - Triggered when payment fails

**Delivery Phase**

* `orders.delivery.initiated` - Triggered when delivery begins
* `orders.delivery.completed` - Triggered when delivery succeeds
* `orders.delivery.failed` - Triggered when delivery fails

## Setting Up Webhooks

### 1. Create an endpoint route

Using a standard nodejs API server, create an endpoint.

<Accordion title="I don't have a webserver or want to test locally">
  You can test locally by installing [ngrok](https://ngrok.com/docs/getting-started/) and creating a routed endpoint
  to a specified port. > **Note**: Use ngrok only for testing. In production, ensure your endpoint is properly secured
  with HTTPS and appropriate access controls.
</Accordion>

### 2. Configure the endpoint

Your endpoint should:

* Handle POST requests only
* Parse webhook events from the request body
* Respond with a `200` status code to acknowledge receipt

<Tip>Your server must return a 2xx HTTP status quickly so the webhook is marked as delivered.</Tip>

Example handler:

```javascript theme={null}
// endpoint.js

export default function handler(req, res) {
    if (req.method === "POST") {
        console.log(`[webhook] Event received:`, req.body);
    }
    res.status(200).json({});
}
```

<Warning>
  Don't be strict with payload validations as Crossmint may add new fields to the webhooks as products evolve.
</Warning>

<Tip>Your server must return a 2xx HTTP status quickly so the webhook is marked as delivered.</Tip>

### 3. Example Webhook Responses

<AccordionGroup>
  <Accordion title="Checkout V2: purchase.succeeded">
    <CodeGroup>
      ```json EVM theme={null}
      {
          "type": "purchase.succeeded",
          "status": "success",
          "walletAddress": "<EVM_ADDRESS>",
          "projectId": "<PROJECT_ID>",
          "collectionId": "<COLLECTION_ID>",
          "clientId": "<CLIENT_ID>",
          "txId": "<TX_ID>",
          "contractAddress": "<CONTRACT_ADDRESS>",
          "tokenIds": [<TOKEN_IDS>], // only present for EVM collections
          "passThroughArgs": "<YOUR_ARGS_JSON>" // only if whPassThroughArgs set
      }
      ```

      ```json Solana theme={null}
      {
          "type": "purchase.succeeded",
          "status": "success", 
          "walletAddress": "<SOL_ADDRESS>",
          "clientId": "<CLIENT_ID>",
          "txId": "<TXID>",
          "mintAddress": "<MINT_HASH>",
          "passThroughArgs": "<YOUR_ARGS_JSON>"
      }
      ```
    </CodeGroup>
  </Accordion>

  <Accordion title="Checkout V3: orders.quote.created">
    ```json theme={null}
    {
        "type": "orders.quote.created",
        "payload": {
            "totalPrice": {
                "amount": "0.50",
                "currency": "usd"
            },
            "lineItems": [
                {
                    "metadata": {
                        "title": "Collection Name",
                        "description": "Collection Description",
                        "imageUrl": "https://..."
                    },
                    "price": {
                        "amount": "0.50",
                        "currency": "usd"
                    },
                    "quantity": 1
                }
            ]
        }
    }
    ```
  </Accordion>

  <Accordion title="Checkout V3: orders.payment.succeeded">
    ```json theme={null}
    {
        "type": "orders.payment.succeeded",
        "payload": {
            "orderIdentifier": "7723139d-fba3-474d-8e52-0ac7512d5c7b",
            "paymentMethodType": "credit-card",
            "totalPrice": {
                "amount": "0.50",
                "currency": "usd"
            }
        }
    }
    ```
  </Accordion>

  <Accordion title="Checkout V3: orders.delivery.completed">
    ```json theme={null}
    {
        "type": "orders.delivery.completed",
        "payload": {
            "orderIdentifier": "7723139d-fba3-474d-8e52-0ac7512d5c7b",
            "lineItems": [
                {
                    "delivery": {
                        "status": "completed",
                        "recipient": {
                            "locator": "email:user@example.com:polygon",
                            "email": "user@example.com",
                            "walletAddress": "0x1234..."
                        },
                        "txId": "0x2e69f11dae7869b92e3d5eaf4cadd50c48b5c6803d1232815f979d744521ad4c",
                        "tokens": [
                            {
                                "locator": "polygon:0xE04Cf294985282Ddc088E6433c064cfB85eD9EdA:3",
                                "contractAddress": "0xE04Cf294985282Ddc088E6433c064cfB85eD9EdA",
                                "tokenId": "3",
                                "quantity": "1500000",
                                "symbol": "TOKEN",
                                "decimals": 6
                            }
                        ]
                    }
                }
            ]
        }
    }
    ```

    <Note>
      The `quantity`, `symbol`, and `decimals` fields are optional and only present when applicable (e.g., for fungible token purchases in exact-in execution mode).
    </Note>
  </Accordion>
</AccordionGroup>

### 4. Pass Custom Arguments (Optional)

<Warning>
  Custom arguments (whPassThroughArgs) are only supported in Checkout V2 webhooks. This feature is not available in
  Checkout V3 webhooks (orders.\*).
</Warning>

You can pass custom arguments through Checkout V2 webhooks to track additional information:

* User IDs (If you want additional security, sign this ID with a custom key, or send it as a signed JWT, and verify its integrity later on your server)
* Timestamps
* Product SKUs
* Custom metadata

Example of passing arguments:

```jsx theme={null}
function NFTSalePage() {
    const whArgs = {
        uid: 123424,
        sku: 123123123,
        metadata: { custom: "data" },
    };

    const whArgsSerialized = JSON.stringify(whArgs);

    return (
        <CrossmintPayButton
            projectId="_YOUR_PROJECT_ID_"
            collectionId="_YOUR_COLLECTION_ID_"
            whPassThroughArgs={whArgsSerialized}
        />
    );
}
```

Then, extract them on the server:

```javascript theme={null}
export default function handler(req, res) {
    const { whPassThroughArgs } = req.body;

    if (whPassThroughArgs) {
        const whArgsDeserialized = JSON.parse(whPassThroughArgs);
        console.log(whArgsDeserialized);
    }

    res.status(200).json({});
}
```

### 5. Pre & Post Processing

Add your pre and post processing logic when setting up your webhook listener. For example, you can call back to your database when a certain id has succeeded or even use <a href="https://sendgrid.com/">Sendgrid</a> or <a href="https://www.emailjs.com/">EmailJS</a> to send an email to a recipient when a mint completes.

### 6. Configure in Crossmint Console

1. Navigate to the [Webhooks page](https://www.crossmint.com/console/webhooks) in the console
2. Click **Add Endpoint**
3. Enter your endpoint URL
4. Select the webhook events to receive
5. Click **Create**

<Frame type="simple">
  <img alt="Add webhook endpoint UI" />
</Frame>

### 6. Security

For security, verify webhook signatures using the signing secret from your endpoint details page:

<Frame type="simple">
  <img alt="Screenshot of webhooks status UI" />
</Frame>

See the [Verify Webhooks](/introduction/platform/webhooks/verify-webhooks) guide for implementation details.

## Testing Webhooks

1. Use test card number `4242 4242 4242 4242` for successful payments
2. Use `4000 0000 0000 4954` to test payment failures
3. Monitor webhook deliveries in the [Console](https://www.crossmint.com/console/webhooks)

<Accordion title="Watch a video tutorial">
  <Frame type="simple">
    <iframe />
  </Frame>
</Accordion>


# Localization
Source: https://docs.crossmint.com/payments/embedded/customize/localization

Customize the language and currency displayed on checkout

<Snippet />

## How to Adjust the Currency and Language

To customize the language use the property `locale` and for currency, set `defaultCurrency`. Here's an example:

```tsx {3,16} theme={null}
<CrossmintProvider apiKey="_YOUR_CLIENT_API_KEY_">
    <CrossmintEmbeddedCheckout
        locale="es-ES" // Change locale to Spanish
        lineItems={{
            collectionLocator: "crossmint:_YOUR_COLLECTION_ID_",
            callData: {
                // your callData args
            },
        }}
        payment={{
            crypto: {
                enabled: true,
            },
            fiat: {
                enabled: true,
                defaultCurrency: "eur", // Change default currency to be Euro
            },
        }}
    />
</CrossmintProvider>
```


# Apple Pay Integration Guide
Source: https://docs.crossmint.com/payments/embedded/guides/apple-pay

Learn how to enable Apple Pay on your site for Checkout

To enable Apple Pay on your site, follow these steps using the [Crossmint Developer Console](https://www.crossmint.com/console/apple-pay-domains).

## Prerequisites

1. **HTTPS Hosting**: Your site must be hosted on HTTPS to ensure secure transactions.
2. **Crossmint Account**: You need an active Crossmint developer account.

## Setup Instructions

### Step 1: Download the Verification File

1. Go to the [Apple Pay Domains](https://www.crossmint.com/console/apple-pay-domains) page in the Crossmint Console.
2. Click **Download file** to get the Apple Developer Merchant ID Domain Association file.

### Step 2: Host the Verification File

Host the downloaded file on your server at the following path:

```
https://[your-domain]/.well-known/apple-developer-merchantid-domain-association
```

<Accordion title="Example: Next.js App Router">
  **Option 1: Using the Public Folder**

  1. Create the `.well-known` folder inside your `public` directory.
  2. Place the downloaded file in `public/.well-known/` with the filename `apple-developer-merchantid-domain-association` (no extension).

  **Option 2: Using a Route**

  1. Create a folder at `app/.well-known/apple-developer-merchantid-domain-association/`
  2. Add a `route.ts` file with the following content:

  ```typescript route.ts theme={null}
  import { NextResponse } from "next/server";

  export async function GET() {
      return new NextResponse("PASTE_FILE_CONTENT_HERE", {
          headers: {
              "Content-Type": "text/plain",
          },
      });
  }
  ```

  Replace `PASTE_FILE_CONTENT_HERE` with the content of the downloaded verification file.
</Accordion>

<Accordion title="Example: Next.js Page Router">
  1. Create the `.well-known` folder inside your `public` directory.
  2. Place the downloaded file in `public/.well-known/` with the filename `apple-developer-merchantid-domain-association` (no extension).
</Accordion>

<Accordion title="Example: Vite">
  1. Create the `.well-known` folder inside your `public` directory.
  2. Place the downloaded file in `public/.well-known/` with the filename `apple-developer-merchantid-domain-association` (no extension).
</Accordion>

### Step 3: Verify Your Domain

1. Return to the [Apple Pay Domains](https://www.crossmint.com/console/apple-pay-domains) page in the Crossmint Console.
2. Enter your domain (e.g., `example.com` or `checkout.example.com`) in the input field.
3. Click **Verify domain**.

If verification succeeds, your domain will appear in the list of registered domains and Apple Pay will be enabled for that domain.

<Note>
  If verification fails, ensure the file is publicly accessible at the correct path. You can test by visiting `https://your-domain/.well-known/apple-developer-merchantid-domain-association` in your browser.
</Note>

## Local Testing

Using [ngrok](https://ngrok.com/) is recommended for local testing. Ngrok allows you to expose your local server to the internet securely.

1. Start ngrok with a fixed domain if possible for consistent testing.
2. Host the verification file on your local server.
3. Register the ngrok domain in the Crossmint Console.
4. Test Apple Pay on Safari (macOS) or any iOS device.

***

For further assistance, please contact our support team.


# Use Connected Wallet as Payer
Source: https://docs.crossmint.com/payments/embedded/guides/custom-payer

Learn how to configure an already connected wallet as the payer wallet

## Overview

By default, Embedded checkout includes wallet connector UI. However, if your customers have already
connected their wallet to your website, you can configure that connected wallet directly as the payer.

This is useful when:

* You're already using a wallet connection solution (like RainbowKit, Solana Wallet Adapter, Web3Modal, or ConnectKit)
* You are using embedded wallets (from Crossmint or other providers)

## Quick Integration

Here's a simple example using [wagmi](https://wagmi.sh/), [viem](https://viem.sh/) and [TanStack Query](https://tanstack.com/query/v5):

<Note>
  Make sure you have this environment variables on `.env.local` or directly replace it in the code `bash
        NEXT_PUBLIC_CLIENT_API_KEY="__YOUR_CLIENT_KEY__" # From API Keys page NEXT_PUBLIC_RECIPIENT_WALLET_ADDRESS="" #
        Address receiving the assets NEXT_PUBLIC_RECEIPT_EMAIL="user@example.com"
        NEXT_PUBLIC_COLLECTION_ID="__YOUR_COLLECTION_ID__" # From Collection details page `
</Note>

<CodeGroup>
  ```tsx Checkout.tsx theme={null}
  import { CrossmintEmbeddedCheckout } from "@crossmint/client-sdk-react-ui";
  import { Hex, parseTransaction } from "viem";
  import { useAccount, useWalletClient } from "wagmi";
  import { baseSepolia, polygonAmoy } from "wagmi/chains";

  export default function Checkout() {
    const { address } = useAccount();
    const { data: walletClient } = useWalletClient();
    const collectionId = process.env.NEXT_PUBLIC_COLLECTION_ID as string;

    const chainIds: Record<string, number> = {
      "base-sepolia": baseSepolia.id,
      "polygon-amoy": polygonAmoy.id,
    } as const;

    // Don't render checkout if wallet is not connected
    if (!address || !walletClient) {
      return (
        <div className="flex flex-col items-center justify-center p-6">
          <h2 className="text-xl text-gray-600 mb-4">Please connect your wallet to continue</h2>
        </div>
      );
    }

    return (
      <CrossmintEmbeddedCheckout
        locale="es-ES"
        recipient={{
          walletAddress: process.env.NEXT_PUBLIC_RECIPIENT_WALLET_ADDRESS ?? "",
        }}
        payment={{
          crypto: {
            // Enable crypto payment, this example only uses Crypto
            enabled: true,
            payer: {
              address,
              initialChain: "base-sepolia",
              supportedChains: ["base-sepolia", "polygon-amoy"],
              handleChainSwitch: async (chain) => {
                await walletClient.switchChain({
                  id: chainIds[chain],
                });
              },
              handleSignAndSendTransaction: async (serializedTx) => {
                try {
                  const tx = parseTransaction(serializedTx as Hex);
                  const hash = await walletClient.sendTransaction({
                    to: tx.to,
                    value: tx.value,
                    data: tx.data ?? "0x",
                    gas: tx.gas,
                    chainId: tx.chainId,
                  });

                  return { success: true, txId: hash };
                } catch (error) {
                  return {
                    success: false,
                    errorMessage: error instanceof Error ? error.message : "Transaction failed",
                  };
                }
              },
            },
          },
          fiat: { enabled: false },
          receiptEmail: process.env.NEXT_PUBLIC_RECEIPT_EMAIL ?? "",
        }}
        lineItems={{
          collectionLocator: `crossmint:${collectionId}`,
          callData: {
            quantity: 1,
          },
        }}
      />
    );
  }

  ```

  ```tsx WalletConnector.tsx theme={null}
  import { useAccount, useConnect, useDisconnect } from "wagmi";

  export default function WalletConnector() {
    const { address, isConnected } = useAccount();
    const { connect, connectors, isPending } = useConnect();
    const { disconnect } = useDisconnect();

    if (!isConnected) {
      return (
        <div className="absolute top-4 right-4">
          <button
            onClick={() => connect({ connector: connectors[0] })}
            disabled={isPending}
            className="px-4 py-2 bg-blue-600 text-white rounded-lg hover:bg-blue-700 disabled:opacity-50 cursor-pointer"
          >
            {isPending ? 'Connecting...' : 'Connect Wallet'}
          </button>
        </div>
      );
    }

    return (
      <div className="absolute top-4 right-4">
        <div className="flex items-center gap-2">
          <span className="px-4 py-2 bg-green-600 text-white rounded-lg">
            {address?.slice(0, 6)}...{address?.slice(-4)}
          </span>
          <button
            onClick={() => disconnect()}
            className="px-3 py-2 bg-red-600 text-white rounded-lg hover:bg-red-700 cursor-pointer text-sm"
          >
            Disconnect
          </button>
        </div>
      </div>
    );
  }
  ```

  ```tsx Home.tsx theme={null}
  "use client";

  import { CrossmintProvider } from "@crossmint/client-sdk-react-ui";
  import { WagmiProvider, createConfig, http } from "wagmi";
  import { baseSepolia, polygonAmoy } from "wagmi/chains";
  import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
  import { injected } from "wagmi/connectors";
  import Checkout from "@/components/Checkout";
  import WalletConnector from "@/components/WalletConnector";

  export default function Home() {
      const clientApiKey = process.env.NEXT_PUBLIC_CLIENT_API_KEY as string;
      // Create a client
      const queryClient = new QueryClient();

      // Create wagmi config
      const config = createConfig({
          chains: [baseSepolia, polygonAmoy] as any,
          connectors: [injected()] as any,
          transports: {
              [baseSepolia.id]: http(),
              [polygonAmoy.id]: http(),
          },
      } as any);

      return (
          <WagmiProvider config={config}>
              <QueryClientProvider client={queryClient}>
                  <div className="relative flex flex-col items-center justify-start h-screen p-6 bg-white">
                      <WalletConnector />
                      <CrossmintProvider apiKey={clientApiKey}>
                          <div className="max-w-[450px] w-full">
                              <Checkout />
                          </div>
                      </CrossmintProvider>
                  </div>
              </QueryClientProvider>
          </WagmiProvider>
      );
  }
  ```
</CodeGroup>

<Note>
  When the user clicks the hosted checkout button, our SDK will first call `handleChainSwitch` to ensure the correct
  network is set, then `handleSignAndSendTransaction` to complete the purchase.
</Note>

## Payer Configuration

The `payer` prop accepts the following configuration:

| Property                       | Type                                                     | Description                                                                                                                                                               |
| ------------------------------ | -------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `address`                      | `string`                                                 | The wallet address of the payer                                                                                                                                           |
| `initialChain`                 | `PayerSupportedBlockchains`                              | The initial blockchain (e.g. "polygon", "ethereum", "base-sepolia")                                                                                                       |
| `supportedChains`              | `PayerSupportedBlockchains[]`                            | Optional list of supported chains. Defaults to `initialChain` if not specified                                                                                            |
| `handleChainSwitch`            | `(chain: PayerSupportedBlockchains) => Promise<void>`    | Function to handle chain switching                                                                                                                                        |
| `handleSignAndSendTransaction` | `(serializedTx: string) => Promise<TransactionResponse>` | Function to handle transaction signing and sending, where `TransactionResponse` is either `{ success: true, txId: string }` or `{ success: false, errorMessage: string }` |

## Popular Wallet Solutions

You can integrate Crossmint with popular Web3 solutions:

### RainbowKit

```tsx theme={null}
import { useConnectModal } from "@rainbow-me/rainbowkit";

// Similar implementation as above, but using RainbowKit's hooks
```

### Web3Modal

```tsx theme={null}
import { useWeb3Modal } from "@web3modal/react";

// Similar implementation as above, but using Web3Modal's hooks
```

## Best Practices

1. **Error Handling**: Always return clear error messages in `handleSignAndSendTransaction`
2. **Chain Support**: Be explicit about supported chains to avoid runtime errors
3. **User Experience**: Show loading states during chain switches and transactions
4. **Wallet Connection**: Ensure wallet is connected before showing checkout

## Related Resources

* [Payment Methods](/payments/embedded/guides/payment-methods)
* [React Hooks](/payments/embedded/guides/hooks)
* [Testing Tips](/payments/advanced/testing-tips)


# Google Pay Mobile
Source: https://docs.crossmint.com/payments/embedded/guides/google-pay

Learn how to enable Google Pay for token checkout and onramp flows using Crossmint's mobile SDKs

<Info>
  **This guide is for mobile apps only.** For web applications, Google Pay works automatically when enabled via the `payment.fiat.allowedMethods.googlePay` prop—no additional setup required. See [Payment Methods](/payments/embedded/guides/payment-methods) for web configuration.
</Info>

This guide covers how to enable Google Pay for token checkout and onramp flows in **React Native** and **Android native (Kotlin)** applications. Mobile apps require additional native configuration that web apps don't need.

## Overview

Crossmint's mobile SDKs provide pre-built checkout components that support Google Pay out of the box. When properly configured, users see the native Android Google Pay sheet, providing seamless access to payment credentials stored in Google Wallet without leaving your app.

### Mobile vs Web

| Platform                   | Setup Required         | Guide                                                        |
| -------------------------- | ---------------------- | ------------------------------------------------------------ |
| Web (React, Next.js, etc.) | Enable via props only  | [Payment Methods](/payments/embedded/guides/payment-methods) |
| React Native (Expo)        | Expo plugin + rebuild  | This guide                                                   |
| React Native (Bare)        | Manual Android config  | This guide                                                   |
| Android Native (Kotlin)    | AndroidManifest config | This guide                                                   |

### Supported Use Cases

* Token purchases (buy tokens with fiat)
* Stablecoin onramp (USDC, etc.)
* NFT checkout

## Mobile SDK Integration

<Tabs>
  <Tab title="React Native">
    ### Prerequisites

    Before starting, ensure you have:

    * React Native project with Expo or bare workflow
    * Crossmint account with API keys (staging and/or production)
    * Android device or emulator with Google Play Services

    <Steps>
      <Step title="Install Dependencies">
        ```shell theme={null}
        pnpm add @crossmint/client-sdk-react-native-ui
        ```

        The SDK includes `react-native-webview` as a dependency. If you need to install it separately, ensure version **13.15.0 or higher**:

        ```shell theme={null}
        pnpm add react-native-webview@^13.15.0
        ```
      </Step>

      <Step title="Configure the Expo Plugin">
        Update your `app.json` to enable Google Pay:

        ```json theme={null}
        {
          "expo": {
            "plugins": [
              [
                "@crossmint/client-sdk-react-native-ui",
                {
                  "enableGooglePay": true
                }
              ]
            ]
          }
        }
        ```

        <Warning>
          This plugin modifies native Android permissions required for Google Pay. The app must be rebuilt after adding this configuration.
        </Warning>
      </Step>

      <Step title="Rebuild Your App">
        Hot reload cannot apply the permission changes. You must rebuild:

        ```shell theme={null}
        npx expo run:android
        ```

        Or for bare React Native:

        ```shell theme={null}
        npx react-native run-android
        ```
      </Step>

      <Step title="Implement the Checkout Component">
        Use `CrossmintEmbeddedCheckout` for token purchases:

        ```javascript theme={null}
        import {
          CrossmintEmbeddedCheckout,
          CrossmintProvider,
        } from "@crossmint/client-sdk-react-native-ui";

        export default function CheckoutScreen() {
          return (
            <CrossmintProvider apiKey="your_client_side_api_key">
              <CrossmintEmbeddedCheckout
                recipient={{
                  walletAddress: "YOUR_WALLET_ADDRESS",
                }}
                payment={{
                  crypto: { enabled: false },
                  fiat: {
                    enabled: true,
                    allowedMethods: {
                      card: true,
                      applePay: false,
                      googlePay: true,
                    },
                  },
                }}
                lineItems={{
                  tokenLocator: "solana:TOKEN_ADDRESS",
                  executionParameters: {
                    mode: "exact-in",
                    amount: "1",
                    maxSlippageBps: "500",
                  },
                }}
              />
            </CrossmintProvider>
          );
        }
        ```

        <Note>
          For staging/testing, use the XMEME test token:

          ```javascript theme={null}
          tokenLocator: "solana:7EivYFyNfgGj8xbUymR7J4LuxUHLKRzpLaERHLvi7Dgu"
          ```
        </Note>
      </Step>

      <Step title="Customize Appearance (Optional)">
        Hide destination and email inputs for a cleaner UI:

        ```javascript theme={null}
        <CrossmintEmbeddedCheckout
          // ... other props
          appearance={{
            rules: {
              DestinationInput: { display: "hidden" },
              ReceiptEmailInput: { display: "hidden" },
            },
            variables: {
              colors: {
                backgroundPrimary: "#000000",
                textPrimary: "#ffffff",
              },
            },
          }}
        />
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="Android Native (Kotlin)">
    <Note>
      The Kotlin SDK is currently in **Beta**. It provides the same checkout functionality with native Jetpack Compose components.
    </Note>

    ### Prerequisites

    * Minimum Android SDK version 24 (Android 7.0)
    * Jetpack Compose
    * Crossmint account with API keys

    <Steps>
      <Step title="Add the SDK Dependency">
        In your app-level `build.gradle.kts`:

        ```kotlin theme={null}
        dependencies {
            implementation("com.crossmint:crossmint-sdk-android:0.0.9")
        }
        ```
      </Step>

      <Step title="Configure AndroidManifest.xml">
        Add the required query intents to enable Google Pay functionality:

        ```xml theme={null}
        <manifest xmlns:android="http://schemas.android.com/apk/res/android">
            <queries>
                <intent>
                    <action android:name="org.chromium.intent.action.PAY"/>
                </intent>
                <intent>
                    <action android:name="org.chromium.intent.action.IS_READY_TO_PAY"/>
                </intent>
                <intent>
                    <action android:name="org.chromium.intent.action.UPDATE_PAYMENT_DETAILS"/>
                </intent>
            </queries>
        </manifest>
        ```
      </Step>

      <Step title="Create Orders Server-Side">
        <Warning>
          **Security requirement:** Order creation must happen on your backend to protect your API key.
        </Warning>

        <CodeGroup>
          ```bash cURL theme={null}
          curl --location 'https://staging.crossmint.com/api/2022-06-09/orders' \
          --header 'x-api-key: YOUR_SERVER_API_KEY' \
          --header 'Content-Type: application/json' \
          --data-raw '{
              "recipient": {
                  "walletAddress": "YOUR_WALLET_ADDRESS"
              },
              "payment": {
                  "receiptEmail": "user@example.com",
                  "method": "card"
              },
              "lineItems": {
                  "tokenLocator": "solana:TOKEN_ADDRESS",
                  "executionParameters": {
                      "mode": "exact-in",
                      "amount": "1"
                  }
              }
          }'
          ```

          ```javascript Node.js theme={null}
          const url = 'https://staging.crossmint.com/api/2022-06-09/orders';

          const payload = {
              recipient: {
                  walletAddress: "YOUR_WALLET_ADDRESS"
              },
              payment: {
                  receiptEmail: "user@example.com",
                  method: "card"
              },
              lineItems: {
                  tokenLocator: "solana:TOKEN_ADDRESS",
                  executionParameters: {
                      mode: "exact-in",
                      amount: "1"
                  }
              }
          };

          const options = {
              method: 'POST',
              headers: {
                  'x-api-key': 'YOUR_SERVER_API_KEY',
                  'Content-Type': 'application/json'
              },
              body: JSON.stringify(payload)
          };

          const response = await fetch(url, options);
          const data = await response.json();
          console.log(data);
          ```

          ```python Python theme={null}
          import requests

          url = "https://staging.crossmint.com/api/2022-06-09/orders"

          payload = {
              "recipient": {
                  "walletAddress": "YOUR_WALLET_ADDRESS"
              },
              "payment": {
                  "receiptEmail": "user@example.com",
                  "method": "card"
              },
              "lineItems": {
                  "tokenLocator": "solana:TOKEN_ADDRESS",
                  "executionParameters": {
                      "mode": "exact-in",
                      "amount": "1"
                  }
              }
          }

          headers = {
              "x-api-key": "YOUR_SERVER_API_KEY",
              "Content-Type": "application/json"
          }

          response = requests.post(url, json=payload, headers=headers)
          print(response.json())
          ```
        </CodeGroup>

        The response includes `orderId` and `clientSecret` needed for the checkout component.
      </Step>

      <Step title="Implement the Checkout Component">
        ```kotlin theme={null}
        import com.crossmint.kotlin.checkout.CheckoutEnvironment
        import com.crossmint.kotlin.checkout.CrossmintEmbeddedCheckout
        import com.crossmint.kotlin.checkout.models.*

        @Composable
        fun CheckoutScreen(orderId: String, clientSecret: String) {
            CrossmintEmbeddedCheckout(
                orderId = orderId,
                clientSecret = clientSecret,
                payment = CheckoutPayment(
                    crypto = CheckoutCryptoPayment(enabled = false),
                    fiat = CheckoutFiatPayment(
                        enabled = true,
                        allowedMethods = CheckoutAllowedMethods(
                            googlePay = true,
                            applePay = false,
                            card = true
                        )
                    )
                ),
                appearance = CheckoutAppearance(
                    rules = CheckoutAppearanceRules(
                        destinationInput = CheckoutDestinationInputRule(display = "hidden"),
                        receiptEmailInput = CheckoutReceiptEmailInputRule(display = "hidden")
                    )
                ),
                environment = CheckoutEnvironment.STAGING,
                modifier = Modifier.fillMaxSize()
            )
        }
        ```
      </Step>
    </Steps>
  </Tab>
</Tabs>

## Google Pay Production Approval

Google Pay works immediately in **staging** environments. For **production**, Google requires explicit approval of your app.

<AccordionGroup>
  <Accordion title="Step 1: Create Your Business Profile">
    1. Navigate to the [Google Pay & Wallet Console](https://pay.google.com/business/console)
    2. Select "Merchant" as your business type
    3. Complete all business profile information
    4. Navigate to **Google Pay API** and click "Get Started"
    5. Accept the Google Pay API Terms of Service
    6. Note your **Merchant ID** (top-right corner after completion)
  </Accordion>

  <Accordion title="Step 2: Submit Your Android App for Approval">
    In the Google Pay & Wallet Console:

    1. Navigate to **Google Pay API** then **Integrations** then **Integrate with your Android app**
    2. Locate your Android application and click "Manage"
    3. Select your integration type (typically "Gateway")
    4. Upload screenshots of your TEST Google Pay integration
    5. Click "Save" then "Submit for approval"

    **Required Screenshots:**

    * Product/item selection showing Google Pay option
    * Cart or checkout view with payment options
    * Google Pay payment sheet with card selection
    * Confirmation or receipt screen
  </Accordion>

  <Accordion title="Step 3: Go Live">
    After Google approval (typically \~1 business day):

    1. Sign your APK with a **release key** (debug keys don't work in production)
    2. Update environment settings:
       * Kotlin: `environment = CheckoutEnvironment.PRODUCTION`
       * React Native: Use production API key
    3. Publish your app to Google Play Store
  </Accordion>
</AccordionGroup>

## SDK Version Requirements

| Component                                        | Minimum Version |
| ------------------------------------------------ | --------------- |
| `@crossmint/client-sdk-react-native-ui`          | Latest          |
| `react-native-webview` (if installed separately) | 13.15.0         |
| `com.crossmint:crossmint-sdk-android`            | Latest          |
| Google Play Services (user device)               | 25.18.30        |

## Troubleshooting

<AccordionGroup>
  <Accordion title="Google Pay button doesn't appear">
    1. **Plugin not configured:** Verify `enableGooglePay: true` in `app.json` plugins
    2. **App not rebuilt:** Run `npx expo run:android` after adding the plugin
    3. **Environment mismatch:** Staging works without approval; production requires it
    4. **Payment method disabled:** Check `googlePay: true` in `allowedMethods`
  </Accordion>

  <Accordion title="PaymentRequest API is not supported error">
    1. **AndroidManifest missing queries:** Add all three Chromium intent queries
    2. **Native rebuild required:** Hot reload cannot apply permission changes
    3. **Device requirements:** User needs Google Play Services 25.18.30+ and WebView 137+
  </Accordion>

  <Accordion title="Order status stuck on undefined">
    1. Check that your API key is valid for the environment (staging vs production)
    2. Verify the `tokenLocator` is correct and available
    3. Ensure the quote hasn't expired (quotes have time limits)
  </Accordion>

  <Accordion title="Token checkout errors">
    **"Token purchase is only available in production":** Some tokens only work in production. Use the XMEME test token for staging: `7EivYFyNfgGj8xbUymR7J4LuxUHLKRzpLaERHLvi7Dgu`
  </Accordion>
</AccordionGroup>

## Testing Guidance

<Tabs>
  <Tab title="Staging Environment">
    * Use staging API keys from your Crossmint console
    * Google Pay functions immediately after proper configuration
    * Use XMEME test token for token testing
    * Test with real Google accounts and saved payment methods
  </Tab>

  <Tab title="Production Environment">
    * Requires completed Google approval process
    * Sign APK with release key
    * Use production API keys
    * Real charges may occur - test with small amounts
  </Tab>
</Tabs>

## Useful Resources

<CardGroup>
  <Card title="React Native Token Quickstart" icon="mobile" href="/payments/embedded/quickstarts/credit-card-memecoin-react-native">
    Get started with token checkout in React Native
  </Card>

  <Card title="Google Pay & Wallet Console" icon="wallet" href="https://pay.google.com/business/console">
    Manage your Google Pay merchant account
  </Card>

  <Card title="Checkout Expo Demo" icon="github" href="https://github.com/Crossmint/checkout-expo-demo">
    Example React Native Expo project with checkout
  </Card>

  <Card title="Kotlin Checkout SDK" icon="github" href="https://github.com/Crossmint/crossmint-kotlin-checkout">
    Example Android Kotlin project with checkout
  </Card>
</CardGroup>


# React Hooks
Source: https://docs.crossmint.com/payments/embedded/guides/hooks

Learn how to use React hooks to control and customize your Embedded Checkout experience

<Snippet />

<Snippet />

## Complete Example

Here's a full example showing how to implement a custom checkout experience:

```tsx theme={null}
import {
    CrossmintProvider,
    CrossmintCheckoutProvider,
    CrossmintEmbeddedCheckout,
    useCrossmintCheckout,
} from "@crossmint/client-sdk-react-ui";

function CheckoutPage() {
    return (
        <CrossmintProvider apiKey="YOUR_API_KEY">
            <CrossmintCheckoutProvider>
                <div className="checkout-container">
                    <CrossmintEmbeddedCheckout
                        lineItems={{
                            collectionLocator: "crossmint:your-collection-id",
                            callData: {
                                totalPrice: "0.001",
                                quantity: 1,
                            },
                        }}
                        payment={{
                            crypto: { enabled: true },
                            fiat: { enabled: true },
                        }}
                    />
                    <CheckoutStatus />
                </div>
            </CrossmintCheckoutProvider>
        </CrossmintProvider>
    );
}

function CheckoutStatus() {
    const { order } = useCrossmintCheckout();

    if (!order) {
        return <div>Loading...</div>;
    }

    switch (order.phase) {
        case "completed":
            return <div>Purchase complete!</div>;
        case "delivery":
            return <div>Delivering your NFTs...</div>;
        case "payment":
            return <div>Processing payment...</div>;
        case "quote":
            return <div>Preparing your order...</div>;
    }
}
```

<Snippet />

## Migration from Previous Version

If you're migrating from the previous version, note these key differences:

* The event system has been replaced with the `useCrossmintCheckout` hook
* Order status is now accessed through the hook instead of event listeners
* Custom UI is built using React components instead of event handlers
* Components must be wrapped with required providers

<Note>
  The new hook-based approach provides a more React-friendly experience and better TypeScript support compared to the
  previous event system.
</Note>

## Related Resources

* [UI Customization](/payments/embedded/guides/ui-customization)
* [Payment Methods](/payments/embedded/guides/payment-methods)
* [Order Lifecycle](/payments/headless/guides/order-lifecycle)
* [Testing Tips](/payments/advanced/testing-tips)


# Item Selection
Source: https://docs.crossmint.com/payments/embedded/guides/item-selection

Specify which items to purchase with Embedded Checkout

The Embedded Checkout allows you to specify which items your users can purchase using the `lineItems` property. This guide explains how to configure item selection for different asset types.

<Snippet />

## Item Selection Examples

<CodeGroup>
  ```tsx collectionLocator theme={null}
  <CrossmintProvider apiKey="_YOUR_CLIENT_API_KEY_">
      <CrossmintEmbeddedCheckout
          lineItems={{
              collectionLocator: "crossmint:_YOUR_COLLECTION_ID_", // Crossmint managed collection
              // collectionLocator: "crossmint:_YOUR_COLLECTION_ID_:_TEMPLATE_ID_", // With specific template
              callData: {
                  totalPrice: "5.00",
                  quantity: 1, // matches your contract's parameter name
              },
          }}
      />
  </CrossmintProvider>
  ```

  ```tsx collectionLocator - imported contract theme={null}
  <CrossmintProvider apiKey="_YOUR_CLIENT_API_KEY_">
      <CrossmintEmbeddedCheckout
          lineItems={{
              collectionLocator: "ethereum:0x71c7656ec7ab88b098defb751b7401b5f6d897", // External collection registered in Crossmint Console
              callData: {
                  totalPrice: "5.00",
                  quantity: 1, // matches your contract's parameter name
                  // For external contracts, you might need additional parameters such as:
                  // _amount: 1, // if your mint function uses _amount instead of quantity
                  // tokenId: "123", // if your contract requires a specific tokenId
                  // metadata: "ipfs://...", // if your contract accepts metadata
              },
          }}
      />
  </CrossmintProvider>
  ```

  ```tsx tokenLocator - EVM theme={null}
  <CrossmintProvider apiKey="_YOUR_CLIENT_API_KEY_">
      <CrossmintEmbeddedCheckout
          lineItems={{
              tokenLocator: "ethereum:0x71c7656ec7ab88b098defb751b7401b5f6d897:1234", // <blockchain>:<contractAddress>:<tokenId>
              callData: {
                  totalPrice: "25.00", // Only totalPrice is required for token purchases
                  // For external EVM contracts, you might need additional parameters:
                  // _amount: 1, // if your contract uses _amount instead of quantity
                  // tokenId: "1234", // if your contract requires explicit tokenId
                  // metadata: "ipfs://...", // if your contract accepts metadata
              },
          }}
      />
  </CrossmintProvider>
  ```

  ```tsx tokenLocator - Solana theme={null}
  <CrossmintProvider apiKey="_YOUR_CLIENT_API_KEY_">
      <CrossmintEmbeddedCheckout
          lineItems={{
              tokenLocator: "solana:7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU", // <blockchain>:<tokenAddress>
              callData: {
                  totalPrice: "25.00",
                  buyerCreatorRoyaltyPercent: 100, // Required for Solana
              },
          }}
      />
  </CrossmintProvider>
  ```

  ```tsx productLocator theme={null}
  <CrossmintProvider apiKey="_YOUR_CLIENT_API_KEY_">
      <CrossmintEmbeddedCheckout
          lineItems={{
              productLocator: "amazon:B01DFKC2SO", // Amazon ASIN
              // productLocator: "amazon:https://www.amazon.com/dp/B01DFKC2SO", // Amazon URL
              // productLocator: "shopify:https://your-store.myshopify.com/products/product-name:123456789", // Shopify
          }}
      />
  </CrossmintProvider>
  ```
</CodeGroup>

<Snippet />

<Snippet />

<Snippet />

## Accessing Item Data in React Components

When using Embedded Checkout, you can access the current order's item data using the `useCrossmintCheckout` hook:

```tsx theme={null}
import { useCrossmintCheckout } from "@crossmint/client-sdk-react-ui";

function YourComponent() {
    const { order } = useCrossmintCheckout();

    // Access line items data
    const lineItems = order?.lineItems || [];

    return (
        <div>
            {lineItems.map((item, index) => (
                <div key={index}>
                    <h3>{item.metadata?.name}</h3>
                    <p>
                        Price: {item.quote?.totalPrice?.amount} {item.quote?.totalPrice?.currency}
                    </p>
                </div>
            ))}
        </div>
    );
}
```

<Note>
  The `useCrossmintCheckout` hook must be used within components wrapped by both `CrossmintProvider` and
  `CrossmintCheckoutProvider`.
</Note>


# Payment Methods
Source: https://docs.crossmint.com/payments/embedded/guides/payment-methods

Enable a complete payment suite for your digital asset checkout - from traditional credit cards and digital wallets to cross-chain crypto payments, all through a single integration

## Overview

Crossmint's Embedded Checkout makes it easy to accept multiple payment methods. Users can pay:

* With credit/debit cards
* Using Apple Pay or Google Pay
* Using ETH, SOL, USDC, EURC, or other supported tokens
* Using cross-chain crypto on supported chains

## Quick Integration

Enable all payment methods with just a few lines of code:

```jsx theme={null}
<CrossmintEmbeddedCheckout
    lineItems={{
        collectionLocator: `crossmint:${collectionId}`,
        callData: {
            totalPrice: "0.001",
            quantity: 1,
        },
    }}
    payment={{
        crypto: {
            enabled: true, // Enable crypto payments
        },
        fiat: {
            enabled: true, // Enable fiat payments
        },
    }}
/>
```

## Fiat Payments

### Credit Cards & Digital Wallets

Embedded Checkout provides a seamless fiat payment experience supporting:

* All major credit and debit cards
* Apple Pay for iOS/Safari users
* Google Pay for Android/Chrome users

You can configure which fiat payment methods to enable:

```jsx theme={null}
payment={{
  fiat: {
    enabled: true,
    // By default, all payment methods are enabled if you don't specify any.
    allowedMethods: {
      card: true, // Enable/disable credit cards
      applePay: true, // Enable/disable Apple Pay
      googlePay: true, // Enable/disable Google Pay
    },
    defaultCurrency: "usd" // Set default currency
  }
}}
```

## Crypto Payments

### Native Wallet Support

Embedded Checkout works with any Web3 wallet, including:

* MetaMask
* Coinbase Wallet
* WalletConnect
* Phantom

Users can pay with ETH, SOL, stablecoins (USDC, EURC), or other supported tokens on their preferred chain. Enable crypto payments with:

```jsx theme={null}
payment={{
  crypto: {
    enabled: true,
    defaultChain: "ethereum", // Optional: Set default blockchain
    defaultCurrency: "usdc" // Optional: Set default currency (usdc, eurc, eth)
  }
}}
```

## Cross-Chain Support

The checkout supports paying with funds from any supported blockchain, even if the digital asset is on a different chain. For example, a user could pay for a digital asset on Polygon using ETH from their Ethereum wallet. The checkout handles all necessary conversions automatically.

## Customizing the Default Experience

Set a default payment method to guide users:

```jsx theme={null}
payment={{
  defaultMethod: "fiat", // or "crypto"
  crypto: {
    enabled: true
  },
  fiat: {
    enabled: true
  }
}}
```

### Test Price Limits and Test Credit Cards

When building your applications using the staging environment, you can use various test credit cards numbers to see the entire process end-to-end, without actually having to transact using a real credit card. Check out the Testing Tips page for more info on [price limits](/payments/advanced/testing-tips#limits-in-staging) and [test card numbers](/payments/advanced/testing-tips#test-credit-card-numbers).

## Best Practices

* Enable Multiple Payment Methods: Offer both fiat and crypto options to maximize conversion
* Set Default Currency: Choose a default that matches your target market
* Test All Flows: Use test cards and test wallets to verify the complete payment experience
* Handle Events: Use the `useCrossmintCheckout` hook to track payment status and handle completion

## Related Resources

* [Price Limits](/payments/advanced/testing-tips#limits-in-staging)
* [Test Credit Card Numbers](/payments/advanced/testing-tips#test-credit-card-numbers)
* [Order Lifecycle](/payments/headless/guides/order-lifecycle)
* [Customizing Appearance](/payments/embedded/guides/ui-customization)
* [React Hooks](/payments/embedded/guides/hooks)


# Production Launch
Source: https://docs.crossmint.com/payments/embedded/guides/production-launch

Follow this checklist to ensure you are ready for production launch with Embedded Checkout

## From Staging to Production with Embedded Checkout

<Check>
  Embedded checkout in production requires enablement by the Customer Success Engineering team. [Contact Crossmint's
  team](https://www.crossmint.com/contact/sales) to get access.
</Check>

<Snippet />

***

### Launch Checklist

1. Change your API keys to the production versions. Ensure your production API key has the appropriate scopes enabled, such as `orders.create`.
2. Update your collection ID to the production one.
3. As needed, change your passed-in props to be production ready (e.g. make `email`, `payment`, `lineItems` programmatically filled).

<Accordion title="See Code Example">
  <CodeGroup>
    ```jsx {(1, 4)} Production theme={null}
    <CrossmintProvider apiKey="YOUR_PROD_API_KEY">
        <CrossmintEmbeddedCheckout
            lineItems={{
                collectionLocator: "crossmint:YOUR_PROD_COLLECTION_ID",
                callData: {
                    totalPrice: "0.25",
                    quantity: 1,
                },
            }}
            payment={{
                crypto: { enabled: true },
                fiat: { enabled: true },
            }}
            recipient={{
                email: "steve@gmail.com",
            }}
        />
    </CrossmintProvider>
    ```

    ```jsx {(1, 4)} Staging theme={null}
    <CrossmintProvider apiKey="YOUR_STAGING_API_KEY">
        <CrossmintEmbeddedCheckout
            lineItems={{
                collectionLocator: "crossmint:YOUR_STAGING_COLLECTION_ID",
                callData: {
                    totalPrice: "0.001",
                    quantity: 1,
                },
            }}
            payment={{
                crypto: { enabled: true },
                fiat: { enabled: true },
            }}
            recipient={{
                email: "test@crossmint.com",
            }}
        />
    </CrossmintProvider>
    ```
  </CodeGroup>
</Accordion>


# Specify Recipient
Source: https://docs.crossmint.com/payments/embedded/guides/specify-recipient

Select where purchased items should be delivered in Embedded Checkout

<Snippet />

## Specifying the Recipient

For Embedded Checkout, you specify the recipient by adding a `recipient` object to your checkout component. The recipient can be specified by email, wallet address, or physical address for physical products.

### Recipient by Email

When specifying a recipient by email, Crossmint will automatically create a secure custodial wallet on the fly for that email address:

```jsx React {4} theme={null}
<CrossmintProvider apiKey="YOUR_API_KEY">
    <CrossmintEmbeddedCheckout
        recipient={{
            email: "user@example.com", // Email address of the recipient
        }}
        // other properties removed for brevity
    />
</CrossmintProvider>
```

The recipient will be able to access their purchased items by logging into their Crossmint wallet in [staging](https://staging.crossmint.com/user/collection) or [mainnet](https://www.crossmint.com/user/collection).

### Recipient by Wallet Address

To deliver items directly to a specific blockchain wallet address:

```jsx React {4} theme={null}
<CrossmintProvider apiKey="YOUR_API_KEY">
    <CrossmintEmbeddedCheckout
        recipient={{
            walletAddress: "0x1234567890abcdef1234567890abcdef12345678", // For EVM chains
            // walletAddress: "5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty" // For Solana
        }}
        // other properties removed for brevity
    />
</CrossmintProvider>
```

### Physical Product Recipients

<Snippet />

When purchasing physical products, you can specify a physical address for delivery:

```jsx React {5-13} theme={null}
<CrossmintProvider apiKey="YOUR_API_KEY">
    <CrossmintEmbeddedCheckout
        recipient={{
            email: "user@example.com",
            physicalAddress: {
                name: "John Doe",
                line1: "123 Main St",
                line2: "Apt 4B", // optional
                city: "San Francisco",
                state: "CA",
                postalCode: "94105",
                country: "US",
            },
        }}
        // other properties removed for brevity
    />
</CrossmintProvider>
```


# UI Customization
Source: https://docs.crossmint.com/payments/embedded/guides/ui-customization

Learn how to customize the Embedded Checkout UI to match your brand identity and design system

## Quick Start

The checkout UI can be customized using the `appearance` prop:

```jsx theme={null}
<CrossmintEmbeddedCheckout
    appearance={{
        fonts: [{ cssSrc: "https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600&display=swap" }],
        variables: {
            fontFamily: "Inter, system-ui, sans-serif",
            colors: {
                backgroundPrimary: "#ffffff",
                textPrimary: "#000000",
                accent: "#0074D9",
            },
        },
    }}
/>
```

## Customization Options

### Background Customization

The embedded checkout component has a **transparent background** by default. The `backgroundPrimary` color in the appearance configuration only affects internal components (inputs, cards, etc.) within the iframe, not the iframe body itself.

To customize the overall background, wrap the component in a div with your desired background styling:

#### Solid Background Colors

```jsx theme={null}
{
    /* Tailwind CSS */
}
<div className="bg-gray-900">
    <CrossmintEmbeddedCheckout {...props} />
</div>;

{
    /* Custom CSS */
}
<div style={{ backgroundColor: "#1a1a1a" }}>
    <CrossmintEmbeddedCheckout {...props} />
</div>;
```

<Note>
  Remember that the `backgroundPrimary` color in your appearance configuration should complement your wrapper
  background for the best visual result.
</Note>

### Custom Fonts

Load custom fonts using the `fonts` array:

```jsx theme={null}
appearance={{
  fonts: [
    { cssSrc: "https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600&display=swap" },
    { cssSrc: "https://fonts.googleapis.com/css2?family=Roboto:wght@400;500;700&display=swap" }
  ]
}}
```

### Global Variables

Control the overall look and feel with these global variables:

```jsx theme={null}
appearance={{
  variables: {
    // Typography
    fontFamily: "Inter, system-ui, sans-serif",
    fontSizeUnit: "16px",

    // Spacing
    spacingUnit: "1rem",
    borderRadius: "8px",

    // Colors
    colors: {
      borderPrimary: "#E0E0E0",
      backgroundPrimary: "#FFFFFF",
      textPrimary: "#000000",
      textSecondary: "#666666",
      danger: "#FF0000",
      warning: "#FFA500",
      accent: "#0074D9"
    }
  }
}}
```

### Component Rules

<AccordionGroup>
  <Accordion title="Input Visibility">
    Control the visibility of specific inputs:

    ```jsx theme={null}
    appearance={{
      rules: {
        DestinationInput: {
          display: "hidden"  // Hides the wallet address input
        },
        ReceiptEmailInput: {
          display: "hidden"  // Hides the email input
        }
      }
    }}
    ```

    <Note>
      When hiding inputs, make sure to provide the corresponding values via props:

      * For hidden `DestinationInput`, provide `recipient.walletAddress`
      * For hidden `ReceiptEmailInput`, provide `payment.receiptEmail`
    </Note>
  </Accordion>

  <Accordion title="Labels">
    Customize label styling:

    ```jsx theme={null}
    appearance={{
        rules: {
            Label: {
                font: {
                    family: "Inter",
                    size: "14px",
                    weight: "500",
                },
                colors: {
                    text: "#333333",
                },
            },
        },
    }}
    ```
  </Accordion>

  <Accordion title="Input Fields">
    Style input fields:

    ```jsx theme={null}
    appearance={{
        rules: {
            Input: {
                borderRadius: "8px",
                font: {
                    family: "Inter",
                    size: "16px",
                    weight: "400",
                },
                colors: {
                    text: "#000000",
                    background: "#FFFFFF",
                    border: "#E0E0E0",
                    boxShadow: "none",
                    placeholder: "#999999",
                },
                hover: {
                    colors: {
                        border: "#0074D9",
                    },
                },
                focus: {
                    colors: {
                        border: "#0074D9",
                        boxShadow: "0 0 0 2px rgba(0,116,217,0.2)",
                    },
                },
            },
        },
    }}
    ```
  </Accordion>

  <Accordion title="Tabs">
    Customize tab appearance:

    ```jsx theme={null}
    appearance={{
        rules: {
            Tab: {
                borderRadius: "4px",
                font: {
                    family: "Inter",
                    size: "14px",
                    weight: "500",
                },
                colors: {
                    text: "#666666",
                    background: "transparent",
                },
                selected: {
                    colors: {
                        text: "#000000",
                        background: "#F5F5F5",
                    },
                },
                hover: {
                    colors: {
                        background: "#F0F0F0",
                    },
                },
            },
        },
    }}
    ```
  </Accordion>

  <Accordion title="Primary Buttons">
    Style primary buttons:

    ```jsx theme={null}
    appearance={{
      rules: {
        PrimaryButton: {
          borderRadius: "8px",
          font: {
            family: "Inter",
            size: "16px",
            weight: "600"
          },
          colors: {
            text: "#FFFFFF",
            background: "#0074D9"
          },
          hover: {
            colors: {
              background: "#0063B8"
            }
          },
          disabled: {
            colors: {
              text: "#FFFFFF",
              background: "#CCCCCC"
            }
          }
        }
      }
    }}
    ```
  </Accordion>
</AccordionGroup>

## Common Examples

### Modern Dark Theme

```jsx theme={null}
appearance={{
  variables: {
    fontFamily: "Inter, system-ui, sans-serif",
    colors: {
      backgroundPrimary: "#1A1A1A",
      textPrimary: "#FFFFFF",
      textSecondary: "#A0A0A0",
      borderPrimary: "#333333",
      accent: "#7928CA"
    }
  },
  rules: {
    Input: {
      colors: {
        background: "#2D2D2D",
        border: "#404040",
        text: "#FFFFFF",
        placeholder: "#666666"
      }
    },
    PrimaryButton: {
      colors: {
        background: "#7928CA",
        text: "#FFFFFF"
      },
      hover: {
        colors: {
          background: "#6B24B2"
        }
      }
    }
  }
}}
```

### Minimal Light Theme

```jsx theme={null}
appearance={{
  variables: {
    fontFamily: "system-ui, sans-serif",
    borderRadius: "4px",
    colors: {
      backgroundPrimary: "#FFFFFF",
      textPrimary: "#000000",
      borderPrimary: "#E0E0E0",
      accent: "#000000"
    }
  },
  rules: {
    Input: {
      borderRadius: "4px",
      colors: {
        background: "#F5F5F5",
        border: "transparent"
      },
      focus: {
        colors: {
          border: "#000000",
          boxShadow: "none"
        }
      }
    },
    PrimaryButton: {
      borderRadius: "4px",
      colors: {
        background: "#000000",
        text: "#FFFFFF"
      }
    }
  }
}}
```

## Related Resources

* [Payment Methods](/payments/embedded/guides/payment-methods)
* [React Hooks](/payments/embedded/guides/hooks)
* [Order Lifecycle](/payments/headless/guides/order-lifecycle)
* [Testing Tips](/payments/advanced/testing-tips)


# Overview
Source: https://docs.crossmint.com/payments/embedded/overview

Create seamless purchases with a fully customizable checkout experience

For an overview of our checkout solution, please refer to the [introduction](/payments/introduction). This guide specifically covers embedded checkout features.

## See It in Action

The video below showcases Embedded Checkout for memecoins on <a href="https://fomo.family/">FOMO</a>, highlighting a seamless mobile onboarding experience with Apple Pay.

<video />

## When is the Embedded Checkout the best fit?

Embedded Checkout is the best choice for most teams. It offers experiences that can feel fully native (see the video above), and is a more complete product than headless. Embedded handles orchestration between multiple PSPs, error and state management, and has better approval rates than headless.

## Get Started

<CardGroup>
  <Card title="Quickstart" icon="bolt" href="/payments/embedded/quickstarts/credit-card-nft">
    Start selling digital assets in 5 minutes.
  </Card>

  <Card title="Talk to an expert" icon="message" href="https://www.crossmint.com/contact/sales">
    Contact our sales team for advanced support.
  </Card>
</CardGroup>

## Advanced Topics

<CardGroup>
  <Card title="Marketplaces & Launchpads" icon="cart-shopping" href="/payments/advanced/marketplaces-and-launchpads" />

  <Card title="SDK Reference" icon="gear" href="/payments/embedded/reference/react" />

  <Card title="Purchasing Multiple Assets" icon="rectangle-vertical-history" href="/payments/pay-button/guides/item-selection#multiple-item-orders" />

  <Card title="Bring your own Collection" icon="file-import" href="/payments/guides/register-collection" />

  <Card title="USDC Contracts" icon="circle-dollar" href="/payments/advanced/usdc-support" />

  <Card title="Checkout Localization" icon="globe" href="/payments/embedded/customize/localization" />

  <Card title="Webhooks" icon="bars-progress" href="/payments/advanced/webhooks" />

  <Card title="Accesslists" icon="clipboard" href="/payments/advanced/accesslists" />
</CardGroup>


# Pay with Card - Memecoins (React)
Source: https://docs.crossmint.com/payments/embedded/quickstarts/credit-card-memecoin

Create a fully customized embedded memecoin checkout experience that accepts credit cards

<Snippet />

## Introduction

This guide will show you how to accept credit card payments using Crossmint's Embedded Checkout for memecoin sales. You'll learn how to:

* Set up credit card payments for Solana memecoin purchases in JavaScript
* Implement an embedded checkout UI using Crossmint's React components
* Track order status and delivery

<Snippet />

<Snippet />

<Snippet />

## Embedded Memecoin Checkout

The fastest way to start selling memecoins is to use our embedded checkout solution adapted for fungible tokens.

### Important Parameters

Before implementing the checkout, note these key parameters:

* `receiptEmail`: Required for delivering payment receipts
* `executionParameters.mode`: Set to "exact-in" for memecoin purchases (specifies exact USD amount to spend). "exact-out" is for NFTs, while "exact-in" is for fungible tokens.
* `maxSlippageBps`: Optional slippage tolerance (default is typically 500 BPS or 5% if not specified)

<Note>
  **Testing in Staging?** Use the XMEME test token: `solana:7EivYFyNfgGj8xbUymR7J4LuxUHLKRzpLaERHLvi7Dgu`. Production tokens will not work in the staging environment.
</Note>

<Snippet />

### Memecoin Embedded Integration

Next, we will set up a project file with Crossmint's embedded checkout to accept memecoin purchases.

<Steps>
  <Step title="Add environment variables">
    Create `.env.local` in your project root:

    ```sh theme={null}
    NEXT_PUBLIC_CLIENT_API_KEY="_YOUR_CLIENT_API_KEY_"                    # From API Keys page
    NEXT_PUBLIC_TOKEN_ADDRESS="7EivYFyNfgGj8xbUymR7J4LuxUHLKRzpLaERHLvi7Dgu" # xmeme token for staging testing
    NEXT_PUBLIC_RECIPIENT_WALLET_ADDRESS="YOUR_SOLANA_WALLET_ADDRESS"     # Add desired recipient wallet
    NEXT_PUBLIC_RECEIPT_EMAIL="YOUR_EMAIL"                               # Add desired recipient email
    ```
  </Step>

  <Step title="Create the checkout page">
    Create `/src/app/page.tsx` with:

    ```tsx theme={null}
    "use client";
    import { CrossmintProvider, CrossmintEmbeddedCheckout } from "@crossmint/client-sdk-react-ui";

    export default function Home() {
        const clientApiKey = process.env.NEXT_PUBLIC_CLIENT_API_KEY as string;
        const tokenAddress = process.env.NEXT_PUBLIC_TOKEN_ADDRESS as string;
        const recipientWalletAddress = process.env.NEXT_PUBLIC_RECIPIENT_WALLET_ADDRESS as string;

        return (
            <div className="flex flex-col items-center justify-start h-screen p-6 bg-white">
                <CrossmintProvider apiKey={clientApiKey}>
                    <div className="max-w-[450px] w-full">
                        <CrossmintEmbeddedCheckout
                            recipient={{
                                walletAddress: recipientWalletAddress, // Wallet address to receive the memecoins
                            }}
                            lineItems={{
                                tokenLocator: `solana:${tokenAddress}`, // Token address in format solana:tokenAddress (e.g., solana:7EivYFyNfgGj8xbUymR7J4LuxUHLKRzpLaERHLvi7Dgu for xmeme token)
                                executionParameters: {
                                    mode: "exact-in", // The execution method for the order. It tells Crossmint to operate in buying fungibles mode
                                    amount: "5", // Amount in USD
                                    maxSlippageBps: "500" // Optional - default slippage will be applied if not specified
                                }
                            }}
                            payment={{
                                receiptEmail: process.env.NEXT_PUBLIC_RECEIPT_EMAIL as string, // Email address to receive the receipt
                                crypto: {
                                    enabled: false, // Only fiat is supported for memecoin purchases
                                },
                                fiat: {
                                    enabled: true,
                                },
                                defaultMethod: "fiat",
                            }}
                        />
                    </div>
                </CrossmintProvider>
            </div>
        );
    }
    ```

    For more details on tokenLocator formatting and other item selection options, see our [embedded item selection guide](/payments/embedded/guides/item-selection#item-selection-examples).
  </Step>

  <Step title="Run your app">
    <Snippet />
  </Step>

  <Step title="Test your app">
    Test purchases in staging using test credit cards, like `4242424242424242` (Visa). More information on testing can be found [here](/payments/advanced/testing-tips#test-credit-card-numbers).

    For production launch with live memecoin tokens, [contact our sales team](https://www.crossmint.com/contact/sales).
  </Step>
</Steps>

Here's how your embedded checkout will look after implementation:

<img alt="Embedded Memecoin Checkout" />

Note the quote expiration timer above the checkout button.

🎉 Congratulations! You've successfully set up your embedded memecoin checkout. Check out the [Next Steps](#next-steps) section below to learn how to customize your integration.

<Snippet />

## Next Steps

<CardGroup>
  <Card title="Customize UI" icon="paintbrush" href="/payments/embedded/guides/ui-customization">
    Learn how to customize the embedded checkout experience
  </Card>

  <Card title="Handle Webhooks" icon="bell" href="/payments/advanced/webhooks">
    Implement webhook handling for order updates
  </Card>
</CardGroup>

<Snippet />

<Note>
  If the quote expires (after 1 minute), the embedded checkout will automatically refresh the quote. You can
  customize this behavior using the checkout hooks.
</Note>

<Snippet />


# Pay with Card - Memecoins (React Native)
Source: https://docs.crossmint.com/payments/embedded/quickstarts/credit-card-memecoin-react-native

Create a fully customized embedded memecoin checkout experience for React Native that accepts credit cards

<Snippet />

# Crossmint Checkout React Native SDK Quickstart

<Note>
  For this quickstart we'll be using Expo. You can follow this [tutorial](https://docs.expo.dev/tutorial/create-your-first-app/) to create an expo app. **Only do steps 1 and 3**, plus the Crossmint-specific steps below.

  **Prerequisites:** Before starting, ensure you have completed the [Expo prerequisites](https://docs.expo.dev/tutorial/create-your-first-app/#prerequisites) including Node.js, Git, and your development environment setup.
</Note>

## Following Expo Tutorial + Crossmint SDK

<Steps>
  <Step title="Initialize a new Expo app">
    ```bash theme={null}
    npx create-expo-app@latest crossmint-checkout-quickstart

    cd crossmint-checkout-quickstart
    ```
  </Step>

  <Step title="Run reset-project script">
    ```bash theme={null}
    npm run reset-project
    ```
  </Step>

  <Step title="Install @crossmint/client-sdk-react-native-ui">
    <Snippet />
  </Step>

  <Step title="Add your .env.local environment variables">
    ```bash theme={null}
    EXPO_PUBLIC_CLIENT_CROSSMINT_API_KEY="your_client_side_api_key"
    EXPO_PUBLIC_RECIPIENT_WALLET_ADDRESS="your_solana_wallet_address" 
    EXPO_PUBLIC_RECEIPT_EMAIL="your-email@example.com"
    ```

    <Note>The `receiptEmail` field is **required** for delivering payment receipts to customers.</Note>
  </Step>

  <Step title="Replace index.tsx with">
    ```jsx theme={null}
    import { CrossmintEmbeddedCheckout, CrossmintProvider } from "@crossmint/client-sdk-react-native-ui";

    export default function Index() {
        return (
            <CrossmintProvider apiKey={process.env.EXPO_PUBLIC_CLIENT_CROSSMINT_API_KEY ?? ""}>
                <CrossmintEmbeddedCheckout
                    recipient={{
                        walletAddress: process.env.EXPO_PUBLIC_RECIPIENT_WALLET_ADDRESS ?? "",
                    }}
                    payment={{
                        crypto: {
                            enabled: false,
                        },
                        fiat: {
                            enabled: true,
                        },
                        receiptEmail: process.env.EXPO_PUBLIC_RECEIPT_EMAIL ?? "",
                    }}
                    lineItems={{
                        tokenLocator: "solana:7EivYFyNfgGj8xbUymR7J4LuxUHLKRzpLaERHLvi7Dgu", // XMEME token (staging)
                        executionParameters: {
                            mode: "exact-in", // Specifies exact USD amount to spend (vs exact-out for NFTs)
                            amount: "1", // USD amount to spend
                            maxSlippageBps: "500", // Maximum slippage tolerance in basis points (500 = 5%, default if not specified)
                        },
                    }}
                />
            </CrossmintProvider>
        );
    }
    ```
  </Step>

  <Step title="Run your project">
    <CodeGroup>
      ```bash npm theme={null}
      npm run ios
      # For Android:
      npm run android
      ```

      ```bash yarn theme={null}
      yarn ios
      # For Android:
      yarn android
      ```

      ```bash pnpm theme={null}
      pnpm ios
      # For Android:
      pnpm android
      ```

      ```bash bun theme={null}
      bun ios
      # For Android:
      bun android
      ```
    </CodeGroup>
  </Step>
</Steps>

### Result

<img alt="React Native Crossmint Checkout Result" />


# Pay with Card - NFTs (React)
Source: https://docs.crossmint.com/payments/embedded/quickstarts/credit-card-nft

Embed a onchain checkout into a web app in under 5 minutes

<Frame type="simple">
  <img alt="Crossmint Embedded Checkout Demo" />
</Frame>

## Introduction

In this guide, you will create a web app with Next.js which allows customers to buy NFTs with credit card and crypto payments, using Crossmint's embedded checkout. Crossmint also supports payments for [crypto onramp](/stablecoin-orchestration/onramp/quickstarts/react), [memecoins](/payments/headless/quickstarts/credit-card-memecoin-cko), and other onchain assets (ERC20 tokens, ERC721 tokens, and ERC1155 tokens).

If you want to get started immediately, you can clone a repo with a functioning embedded checkout here: [https://github.com/Crossmint/crossmint-embedded-demo](https://github.com/Crossmint/crossmint-embedded-demo). If you want to get started step by step, continue following the guide below.

<Snippet />

<Snippet />

### Basic Integration

Perfect for getting started quickly with a simple checkout flow.

<Steps>
  <Step title="Add environment variables">
    Create `.env.local` in your project root:

    ```sh theme={null}
    NEXT_PUBLIC_CLIENT_API_KEY="_YOUR_CLIENT_API_KEY_"    # From API Keys page
    NEXT_PUBLIC_COLLECTION_ID="_YOUR_COLLECTION_ID_"      # From Collection details page
    ```
  </Step>

  <Step title="Create the checkout page">
    Replace your home page (e.g `{root_dir}/app/page.tsx`) with:

    ```tsx theme={null}
    "use client";

    import { CrossmintProvider, CrossmintEmbeddedCheckout } from "@crossmint/client-sdk-react-ui";

    export default function Home() {
        const clientApiKey = process.env.NEXT_PUBLIC_CLIENT_API_KEY as string;
        const collectionId = process.env.NEXT_PUBLIC_COLLECTION_ID as string;

        return (
            <div className="flex flex-col items-center justify-start h-screen p-6 bg-white">
                <CrossmintProvider apiKey={clientApiKey}>
                    <div className="max-w-[450px] w-full">
                        <CrossmintEmbeddedCheckout
                            lineItems={{
                                collectionLocator: `crossmint:${collectionId}`,
                                callData: {
                                    totalPrice: "0.001",
                                    quantity: 1,
                                },
                            }}
                            payment={{
                                crypto: { enabled: true },
                                fiat: { enabled: true },
                            }}
                        />
                    </div>
                </CrossmintProvider>
            </div>
        );
    }
    ```
  </Step>

  <Step title="Run your app">
    Navigate to the directory your package.json is to run the app

    ```bash theme={null}
    cd embedded-checkout/crossmint-embedded-checkout-demo
    ```

    <Snippet />
  </Step>
</Steps>

### Advanced Integration

Need purchase tracking, multiple NFT purchases at once, or more customization? Here's a complete setup with additional features:

```tsx theme={null}
"use client";

import { useEffect } from "react";
import {
    CrossmintProvider,
    CrossmintCheckoutProvider,
    CrossmintEmbeddedCheckout,
    useCrossmintCheckout,
} from "@crossmint/client-sdk-react-ui";

// Component with purchase tracking
function Checkout() {
    const { order } = useCrossmintCheckout();
    const collectionId = process.env.NEXT_PUBLIC_COLLECTION_ID as string;

    useEffect(() => {
        if (order && order.phase === "completed") {
            console.log("Purchase completed!");
            // Handle successful purchase
        }
    }, [order]);

    return (
        <CrossmintEmbeddedCheckout
            lineItems={[
                {
                    collectionLocator: `crossmint:${collectionId}`,
                    callData: {
                        totalPrice: "0.001",
                        quantity: 1,
                    },
                },
                {
                    collectionLocator: `crossmint:${collectionId}`,
                    callData: {
                        totalPrice: "0.002",
                        quantity: 2,
                    },
                },
            ]}
            payment={{
                crypto: {
                    enabled: true,
                    defaultChain: "polygon", // Set preferred blockchain
                    defaultCurrency: "matic", // Set preferred crypto
                },
                fiat: {
                    enabled: true,
                    defaultCurrency: "usd", // Set preferred fiat currency
                    allowedMethods: {
                        card: true,
                        applePay: true,
                        googlePay: true,
                    },
                },
                receiptEmail: "receipt@example.com", // Optional: Set receipt email
            }}
            recipient={{
                email: "buyer@example.com", // NFTs will be delivered to this email's wallet
                // Or use walletAddress: "0x..." for direct delivery
            }}
            locale="en-US" // Set interface language
        />
    );
}

// Main component with providers
export default function Home() {
    const clientApiKey = process.env.NEXT_PUBLIC_CLIENT_API_KEY as string;

    return (
        <div className="flex flex-col items-center justify-start min-h-screen p-6">
            <CrossmintProvider apiKey={clientApiKey}>
                <CrossmintCheckoutProvider>
                    <Checkout />
                </CrossmintCheckoutProvider>
            </CrossmintProvider>
        </div>
    );
}
```

<Note>
  This advanced example showcases: - Multiple NFTs in one checkout - Purchase status tracking - Preferred payment
  methods and currencies - Email-based NFT delivery - Language settings Learn more in our guides: - [Payment
  Methods](/payments/embedded/guides/payment-methods) - [Multi-purchases](/payments/pay-button/guides/item-selection#multiple-item-orders) -
  [React Hooks](/payments/embedded/guides/hooks)
</Note>

### Testing Your Integration

<Note>
  This demo uses the staging environment: - Use [test credit
  cards](/payments/advanced/testing-tips#test-credit-card-numbers) for payments - Get test USDC from our
  [faucet](/payments/advanced/testing-tips#getting-test-tokens) - Check [price
  limits](/payments/advanced/testing-tips#limits-in-staging) for staging
</Note>

## All Set!

You've successfully integrated card and crypto payments with the Crossmint Embedded Checkout!

<Frame type="simple">
  <img />
</Frame>

<Note>
  Remember this demo is built on staging, so the digital assets will show up on the testnets. To launch on production,
  check the [production launch checklist](/payments/advanced/production-launch). You will need to contact
  [Sales](https://www.crossmint.com/contact/sales) to enable the embedded checkout on production.
</Note>

## Next Steps

### Customize the UI and Behavior Further

<CardGroup>
  <Card title="UI Customization" icon="paintbrush" href="/payments/embedded/guides/ui-customization">
    Learn how to customize the look and feel of your checkout
  </Card>

  <Card title="Payment Methods" icon="credit-card" href="/payments/embedded/guides/payment-methods">
    Configure available payment options for your users
  </Card>

  <Card title="React Hooks" icon="code" href="/payments/embedded/guides/hooks">
    Use React hooks to build custom checkout experiences
  </Card>
</CardGroup>

### Advanced Topics

<CardGroup>
  <Card title="SDK Reference" icon="gear" href="/payments/embedded/reference/react" />

  <Card title="Launch in Production" icon="ship" href="/payments/advanced/production-launch" />

  <Card title="Localization" icon="globe" href="/payments/embedded/customize/localization" />

  <Card title="Multi-purchases" icon="cart-plus" href="/payments/pay-button/guides/item-selection#multiple-item-orders" />
</CardGroup>


# React
Source: https://docs.crossmint.com/payments/embedded/reference/react

React SDK reference for Embedded Checkout component properties

## Properties

The Embedded Checkout component supports two modes of operation:

1. **New Order Mode**: Create orders client-side by passing `lineItems`, `recipient`, and other order details directly to the component.
2. **Existing Order Mode**: Use orders created server-side by passing `orderId` and `clientSecret` to the component.

<Note>
  Use **Existing Order Mode** when you need server-side order creation for enhanced security, custom business logic, or when integrating with the [Headless API](/payments/headless/overview).
</Note>

### Existing Order Properties

Use these properties when working with orders created server-side via the [Create Order API](/api-reference/headless/create-order).

<ResponseField name="orderId" type="string">
  The unique identifier of an existing order created via the server-side API. When provided, the checkout will load and process this existing order instead of creating a new one.

  ```tsx theme={null}
  <CrossmintEmbeddedCheckout
    orderId="order_abc123"
    clientSecret="secret_xyz789"
    payment={{
      crypto: { enabled: true },
      fiat: { enabled: true }
    }}
  />
  ```

  <Note>The `payment` object is still required when using existing orders to configure which payment methods are enabled in the checkout UI.</Note>

  <Warning>When using `orderId`, do not pass `lineItems`, `recipient`, or `locale` as these are already defined in the server-side order.</Warning>
</ResponseField>

<ResponseField name="clientSecret" type="string">
  Secret token associated with the order for additional security. This is returned when creating an order via the server-side API.

  <Note>The `clientSecret` helps ensure that only authorized clients can access and complete the order.</Note>
</ResponseField>

### New Order Properties

Use these properties when creating orders directly in the client.

<ResponseField name="lineItems" type="object | array">
  Specifies the assets to purchase. Can be a single item or array of items. Required when creating a new order (not used with `orderId`).

  <Accordion title="lineItems properties">
    <ResponseField name="collectionLocator" type="string">
      Collection identifier in one of these formats:

      * `crossmint:<_YOUR_COLLECTION_ID_>[:_TEMPLATE_ID_]` - For collections created in Crossmint Console
        * Template ID is optional and requires template minting to be enabled
        * If template minting is disabled and a template ID is provided, the mint will select a template randomly
      * `<blockchain>:<contract-address>` - For collections using direct contract addresses (e.g., `polygon-amoy:0xF3d2d7b5666f579DcE385b2d53c54AB1b09Ef563`)

      <Note>
        When using template minting, append the templateId to the collection locator: `crossmint:collectionId:templateId`.
        Template minting must be enabled in the Crossmint Console or the mint will select a template randomly.
        See the [Mint to Specific Template guide](/payments/advanced/mint-to-specific-template) for details on enabling template minting and error handling.
      </Note>
    </ResponseField>

    <ResponseField name="tokenLocator" type="string">
      For secondary sales (buying existing assets). Token identifier in one of these formats:

      * EVM chains: `<blockchain>:<contractAddress>:<tokenId>`
      * Solana: `<blockchain>:<tokenAddress>`

      <Note>Using `tokenLocator` doesn't require registering the collection in Crossmint Console.</Note>

      <Warning>Use either `collectionLocator` (for primary sales) or `tokenLocator` (for secondary sales), not both.</Warning>
    </ResponseField>

    <ResponseField name="callData" type="object">
      Arguments passed to your contract's mint function:

      ```solidity Solidity theme={null}
      // Example mint function
      function mint(
        address to,  // Auto-filled by Crossmint
        uint256 quantity,
        uint256 totalPrice
      ) public payable {
        // ...
      }
      ```

      <Warning>Parameter names must match your contract's function arguments exactly.</Warning>

      <Check>Do not pass the recipient argument (e.g. `to`) in callData. Crossmint handles this automatically.</Check>
    </ResponseField>
  </Accordion>
</ResponseField>

<ResponseField name="recipient" type="object">
  Delivery details for the assets. You must specify either email OR wallet address, not both. Only used when creating new orders (not used with `orderId`).

  <Accordion title="recipient properties">
    <ResponseField name="email" type="string">
      Assets delivered to user's Crossmint wallet linked to this email
    </ResponseField>

    <ResponseField name="walletAddress" type="string">
      Assets delivered directly to this blockchain address
    </ResponseField>
  </Accordion>

  When not provided, user will be prompted during checkout.
</ResponseField>

<ResponseField name="locale" type="string">
  Sets the checkout interface language. Only used when creating new orders (not used with `orderId`).

  `en-US` `de-DE` `es-ES` `fr-FR` `it-IT` `ja-JP` `ko-KR` `pt-PT` `ru-RU` `th-TH` `tr-TR` `uk-UA` `vi-VN` `zh-CN` `zh-TW` `Klingon`
</ResponseField>

### Common Properties

These properties can be used with both new orders and existing orders.

<ResponseField name="payment" type="object">
  Configuration for payment methods.

  <Accordion title="payment properties">
    <ResponseField name="crypto" type="object">
      Crypto payment settings:

      ```tsx theme={null}
      {
        enabled: true,  // Enable/disable crypto payments
        defaultChain?: string, // Optional: e.g., "ethereum", "polygon", "solana"
        defaultCurrency?: string // Optional: e.g., "eth", "usdc"
      }
      ```

      <Note>
        For the complete list of supported chains, see [Supported Chains](/introduction/supported-chains).
      </Note>
    </ResponseField>

    <ResponseField name="fiat" type="object">
      Card & wallet payment settings:

      ```tsx theme={null}
      {
        enabled: true,  // Enable/disable fiat payments
        defaultCurrency?: string,  // Optional: e.g., "usd", "eur", "gbp"
        allowedMethods: {
          card: boolean,       // Credit/debit cards
          applePay: boolean,   // Apple Pay
          googlePay: boolean   // Google Pay
        }
      }
      ```

      <Note>
        Crossmint supports multiple fiat currencies. Contact our [support team](https://help.crossmint.com) for the complete list of available currencies.
      </Note>

      <Note>
        Embedded Checkout supports additional payment method customization. See our [Embedded Checkout payment methods guide](/payments/embedded/guides/payment-methods) for details.
      </Note>
    </ResponseField>

    <ResponseField name="receiptEmail" type="string">
      Optional email address where purchase receipt will be sent
    </ResponseField>

    <ResponseField name="defaultMethod" type="string">
      Sets the default payment tab: `fiat` or `crypto`
    </ResponseField>
  </Accordion>
</ResponseField>

<ResponseField name="appearance">
  Customization options for the checkout UI. See our [UI Customization guide](/payments/embedded/guides/ui-customization) for complete details.

  **Notable appearance options:**

  * Hide destination input: `rules.DestinationInput.display: "hidden"`
  * Hide receipt email input: `rules.ReceiptEmailInput.display: "hidden"`

  <Note>If inputs are hidden, you must provide the corresponding values via recipient/payment props.</Note>
</ResponseField>

## React Hooks

The following React hooks are available for use with the Embedded Checkout:

<ResponseField name="useCrossmintCheckout" type="function">
  The `useCrossmintCheckout` hook is used to access the current order and checkout state.
</ResponseField>

<Note>
  All Crossmint hooks must be used within components wrapped by both `CrossmintProvider` and `CrossmintCheckoutProvider`:
</Note>

```tsx theme={null}
<CrossmintProvider apiKey="YOUR_API_KEY">
    <CrossmintCheckoutProvider>
        <YourComponent /> {/* Hooks can be used here */}
    </CrossmintCheckoutProvider>
</CrossmintProvider>
```

The following properties are available from the `useCrossmintCheckout` hook:

<ResponseField name="order" type="object">
  The current order object containing all order details including order ID, phase, line items, quote, and delivery information.

  ```tsx theme={null}
  const { order } = useCrossmintCheckout();
  ```

  For the complete Order object schema, see the [Get Order API reference](/api-reference/headless/get-order).

  To understand order phases and lifecycle, see the [Order Lifecycle guides](/payments/headless/guides/order-lifecycle/quote-phase).
</ResponseField>


# Create/Deploy an NFT Collection
Source: https://docs.crossmint.com/payments/guides/create-collection

Easily deploy a collection in the console and enable payments

The easiest way to get started with selling or airdropping NFTs is to use the developer console to deploy and manage your NFT contracts.

## Create a Crossmint NFT Collection

This guide will deploy an ERC-721 contract on the Polygon Amoy testnet. Currently, you can also deploy to the mainnets and testsnets for Polygon, Base, Optimism, and Solana directly from the console. Additional chains are supported when deploying via the [create-collection API](/api-reference/minting/collection/create-collection).

<Steps>
  <Step title="Navigate to Token collections and click `New collection`">
    <Frame type="simple">
      <img alt="New collections screenshot" />
    </Frame>
  </Step>

  <Step title="Enter Collection Information">
    This information is displayed in the Hosted Checkout and Storefront. You can edit it later.

    <Frame type="simple">
      <img alt="Collection info screenshot" />
    </Frame>
  </Step>

  <Step title="Select `Create a new contract` option">
    <Frame type="simple">
      <img alt="Create Collection screenshot" />
    </Frame>
  </Step>

  <Step title="Select `Sell NFTs` option">
    If you want to use this collection exclusively with the [Minting Tools](/minting/introduction), select the `Airdrop NFTs` option only.

    <Frame type="simple">
      <img alt="Select sell or airdrop NFTs screenshot" />
    </Frame>
  </Step>

  <Step title="Select preferred Blockchain">
    Crossmint has staging and production [environments](/introduction/platform/staging-vs-production) to facilitate working in testnets or mainnets.

    <Frame type="simple">
      <img alt="Select blockchain screenshot" />
    </Frame>

    <br />

    <Check>When creating a new collection on production you'll need some API credits to cover the gas cost of contract deployment.</Check>
  </Step>

  <Step title="Configure Payment Settings">
    #### NFT Price

    Enter the price you want to charge for your NFT. When using the staging environment, please set very low test prices to help use preserve our testnet currency. Everything works the same in staging and production, so you can test your collection with low prices in staging and then deploy to production with higher prices.
    In production, there is a lower bound limit of USD $0.75, and an upper bound limit of USD $1,500 per transaction. You can find more information if you need to [increase this limit](/payments/advanced/production-launch#default-transaction-limit).

    #### USDC

    Several chains support USDC for the currency. This option is useful for price stability and to receive payouts in a stable token. You can find more info on [configuring USDC here](/payments/advanced/usdc-support).

    <Frame type="simple">
      <img alt="Crossmint collection nft-price configuration" />
    </Frame>

    ### Fee Sponsorship

    This option enables you to control who pays the fees of the NFT purchase including gas and credit card transaction fees. The default option is "Buyer", which means that if you set a price of 10 USDC, the final price the buyer pays will be 10 USDC plus fees.

    If you want to provide a consistent price for your customers, select the "You" option to sponsor the fees. When you sponsor the fees they will be deducted from the amount the buyer pays and the remainder will be paid to the recipient wallet you set in the next step.

    <Frame type="simple">
      <img alt="Crossmint collection fee sponsorship configuration" />
    </Frame>

    #### Recipient Address

    Enter the wallet address where you want to receive payments. This is the address where Crossmint will send the proceeds from NFT sales.

    <Note>
      Want to split payments across multiple addresses? Use a [splits.org](https://splits.org) address as the payout recipient.
    </Note>

    <Frame type="simple">
      <img alt="Crossmint collection payments settings screenshot" />
    </Frame>
  </Step>

  <Step title="Review details and click `Deploy contract` to complete">
    Make sure you review the Content policy. When launching in production you'll need to submit collection verification information to ensure your collection is compliant with our <a href="https://www.crossmint.com/content-policy">Content Policy</a>. You can find more information about everything required for your production launch in the [Production Launch](/payments/advanced/production-launch) section.

    <Frame type="simple">
      <img alt="Crossmint collection complete screenshot" />
    </Frame>
  </Step>
</Steps>

## Adding NFTs

This is **required** before you can sell or airdrop the NFTs. Without this step there is not any actual information to use for creating the NFTs yet. You can create unique NFT metadata per token or an Open Edition style NFT where all tokens share the same metadata.

<Accordion title="Manual Uploading">
  <Steps>
    <Step title="Select `Manual upload` option">
      <Frame type="simple">
        <img alt="manual upload screenshot" />
      </Frame>
    </Step>

    <Step title="Fill out Metadata">
      #### NFT Name

      The name of your NFT (max 32 characters).

      #### Supply

      For unique per NFT, enter 1. You will need to configure the metadata for each NFT. You can do this via the developer console individually. For projects with many unique NFTs you should use the [Create Template API](/api-reference/minting/template/create-template) with a script.

      For an Open Edition NFT, enter the total quantity, or select the Unlimited checkbox. This will be the only metadata you need to configure.

      #### Description

      The description of your NFT (max 64 characters).

      #### Image

      Upload an image for your NFT.

      Recommended image formats are: JPEG, PNG, WEBP, or GIF. In most cases, the medium in which NFTs are displayed don't require extremely high resolution files. Strike a balance and lean towards file sizes that do not require significant bandwidth to download (below 10 MB for example).

      #### Attributes `optional`

      Additional attributes of the NFT. Add as few or as many as you like. You can refer to the [OpenSea metadata standards](https://docs.opensea.io/docs/metadata-standards#attributes) page for detailed explanations of how to use these in your project.

      <Frame type="simple">
        <img alt="Entering metadata screenshot" />
      </Frame>

      Click the `Create NFT` button to complete.
    </Step>
  </Steps>
</Accordion>

<Accordion title="Batch Uploading with CSV">
  <Steps>
    <Step title="Select `Batch upload` option">
      <Frame type="simple">
        <img alt="batch upload screenshot" />
      </Frame>
    </Step>

    <Step title="Prepare Metadata CSV">
      You can download an example of how your file should be structured here: [batch-upload-example.zip](https://www.crossmint.com/assets/examples/batch-upload-example.zip).

      <Frame type="simple">
        <img alt="upload csv screenshot" />
      </Frame>

      <Note>You can upload a maximum of 1000 items at a time. For collections that require more than 1000 tokens, you can repeat the batch upload process multiple times.</Note>

      The CSV should include a header row with the following fields:

      * `name` - The name for the token.
      * `image` - The filename of the image, which will be uploaded in the next step.
      * `description` - A description for the token.
      * `supply ` - How many of the token should be available.
      * `animation_url` - (optional)

      You can add attributes via additional columns in the spreadsheet. For example, to add an attribute named `weapon`, include an additional column with the attribute name for the header row. You can refer to the example file linked above to see this in action.

      Once you have your CSV ready, upload it to move on to the next step for media files.
    </Step>

    <Step title="Prepare Media Files">
      The image file names must match the value(s) in the `image` column of the uploaded CSV file. These files should be in a flat folder structure for upload (no sub-folders).

      Click the "Upload media files" button and then select all of the images referenced in the `metadata.csv` file you uploaded in the previous step.

      <Frame type="simple">
        <img alt="upload media files screenshot" />
      </Frame>
    </Step>

    <Step title="Complete the Batch Upload">
      Click the "Upload" button to upload the CSV and media files. If any media files are missing you'll be notified which ones they are in the UI.

      <Frame type="simple">
        <img alt="batch upload complete screenshot" />
      </Frame>
    </Step>

    <Step title="Done!">
      If you need to upload additional token metadata click the "New batch upload" button. Otherwise select "View my NFTS" to close the modal and view the metadata for your tokens.

      <Frame type="simple">
        <img alt="batch upload finish screenshot" />
      </Frame>
    </Step>
  </Steps>
</Accordion>

<Accordion title="Bulk Uploading via API">
  You can also perform bulk uploading by calling the [create-template](/api-reference/minting/template/create-template) API using a script that loops through your `metadata.csv` file. You'll need to have an [API key](/introduction/platform/api-keys#how-to-get-and-use-api-keys) with the `nfts.create` scope enabled.

  Below is an example script that will keep your request volume below the 120/min [rate limit](/introduction/platform/api-keys#rate-limits).

  <Check>
    This code example is available as a repository on GitHub also:
    [crossmint/bulk-uploader](https://github.com/Crossmint/bulk-uploader)
  </Check>

  <Note>
    Before running this script you'll need to upload your media files to a service that can host the files, such as [Pinata](https://www.pinata.cloud/).

    The `image` column of your `metadata.csv` should include the full URL to the file instead of only a file name like the batch upload option above.
  </Note>

  ```javascript bulkUploader.js theme={null}
  const fs = require("fs");
  const csv = require("csv-parser");
  require("dotenv").config();

  const collectionId = process.env.COLLECTION_ID;
  const apiKey = process.env.API_KEY;
  const apiUrl = `https://staging.crossmint.com/api/2022-06-09/collections/${collectionId}/templates`;

  // Rate limiting setup
  const rateLimit = 100; // requests per minute
  const interval = 60000 / rateLimit; // interval in milliseconds

  async function sendRequest(data) {
      try {
          const response = await fetch(apiUrl, {
              method: "POST",
              headers: {
                  "Content-Type": "application/json",
                  "X-API-KEY": `${apiKey}`,
              },
              body: JSON.stringify(data),
          });
          const responseData = await response.json();
          console.log("Success:", responseData);
      } catch (error) {
          console.error("Error:", error.message);
      }
  }

  // Read and process the CSV file
  function processFile() {
      let promise = Promise.resolve();
      fs.createReadStream("metadata.csv")
          .pipe(csv())
          .on("data", (row) => {
              promise = promise.then(() => {
                  const postData = {
                      metadata: {
                          name: row.name,
                          image: row.image, // this should be a publicly accessible URL
                          description: row.description,
                      },
                      supply: { limit: Number(row.supply) },
                      reuploadLinkedFiles: false, // this is optional
                  };
                  return sendRequest(postData).then(() => new Promise((resolve) => setTimeout(resolve, interval)));
              });
          })
          .on("end", () => {
              promise.then(() => {
                  console.log("Finished processing file.");
              });
          });
  }

  processFile();
  ```

  Run the script to bulk upload your template metadata.

  ```node theme={null}
  node bulkUploader.js
  ```
</Accordion>

## Send a Test NFT

Once you have added metadata you can send a test NFT to yourself or another user. The interface to mint and send from the console supports email and wallet address for the recipient.

<Steps>
  <Step title="Mint and send a test NFT">
    You can mint and send a test NFT to an email address or wallet to make sure everything is working as expected.

    <Frame type="simple">
      <img alt="Mint and Send NFT screenshot" />
    </Frame>
  </Step>

  <Step title="Enter email or wallet">
    If you enter an email address the NFT will be sent to a unique Crossmint custodial wallet associated with that email address. The owner of this email can log in to Crossmint to view their NFT. The wallet option will send directly to the wallet address.

    <Warning>Crossmint does ***not*** send an email to the user when you airdrop NFTs from the console.</Warning>

    <Frame type="simple">
      <img alt="Enter an email and Send NFT screenshot" />
    </Frame>
  </Step>

  <Step title="Done!">
    That's all there is to it. Check below for recommended next steps.
  </Step>
</Steps>

<Snippet />


# Register External Collection
Source: https://docs.crossmint.com/payments/guides/register-collection

Import custom and/or third party contracts

Crossmint has a pre-audited library of [smart contracts](/minting/nfts/integrate/create-collections) that serve most use cases. However, if you have custom needs, you can also bring your own.

<Tip>
  The Checkout has been battle-tested at scale with Crossmint's collections, and may result in a more reliable
  experience than using an untested, imported contract, or at least require less trouble-shooting.
</Tip>

<AccordionGroup>
  <Accordion title="When does it make sense to bring my own contract?">
    * When you require very custom functionality not supported by Crossmint's contracts.
    * If you're developing a marketplace.
    * If you have an accesslist.
  </Accordion>

  <Accordion title="What about secondary sale contracts/marketplaces?">
    Secondary markets are platforms where NFTs are traded after their initial mint/primary sale. These are marketplaces where users can buy and sell NFTs from each other.
    It requires manual support from Crossmint to import secondary contracts. See our [marketplaces and launchpads guide](/payments/advanced/marketplaces-and-launchpads).

    The self-serve option is only available for importing primary contracts for EVM and Solana.

    When importing contracts, Crossmint has support to fetch listings from the following secondary marketplaces:

    * **Auction House**: Solana's native marketplace protocol
    * **Tensor**: High-performance Solana NFT marketplace
    * **Magic Eden API**: Popular multi-chain NFT marketplace
    * **Hyperspace**: Cross-chain NFT marketplace and aggregator

    To add support for a new marketplace, please [contact sales](https://www.crossmint.com/contact/sales?utm_source=devrel\&utm_medium=docs\&utm_campaign=backlinks).
  </Accordion>
</AccordionGroup>

## Quick Navigation

All collection imports start with the same initial steps, then diverge based on your blockchain:

* [Common Steps (All Chains)](#common-steps-all-chains) - Steps 1-4 for all blockchains
* [EVM-Specific Steps](#evm-specific-steps) - Steps for Ethereum, Polygon, etc.
* [Solana-Specific Steps](#solana-specific-steps) - Additional steps for Solana candy machines

## Common Steps (All Chains)

These initial steps are the same whether you're importing an EVM contract or a Solana candy machine:

<Steps>
  <Step title="Navigate to Token collections and click `New collection`">
    <Frame type="simple">
      <img alt="New collections screenshot" />
    </Frame>
  </Step>

  <Step title="Enter Collection Information">
    This information is displayed in the Hosted Checkout and Storefront. You can edit it later.

    <Frame type="simple">
      <img alt="Collection info screenshot" />
    </Frame>
  </Step>

  <Step title="Select `Import an existing contract` option">
    <Frame type="simple">
      <img alt="Import Collection screenshot" />
    </Frame>
  </Step>

  <Step title="Select the Blockchain your contract is deployed on">
    Remember, Crossmint has staging and production [environments](/introduction/platform/staging-vs-production).
    When working in the staging environment, choose the mainnet name. For example, if your contract is on the
    Polygon Amoy testnet, select Polygon.

    <Frame type="simple">
      <img alt="Select blockchain screenshot" />
    </Frame>
  </Step>
</Steps>

After completing these common steps, continue with the blockchain-specific instructions below.

## EVM-Specific Steps

Complete the [Common Steps](#common-steps-all-chains) above first, then continue with these EVM-specific steps:

### Pre-requisites

* Your contract must be ERC-721, ERC-721A, or ERC-1155 compliant.
* The minting function must allow minting directly to an address that is different from the one that invoked the contract. And it must contain at least one parameter that specifies that recipient address.
* A single address must be able to call the mint function unlimited times but does not need to be able to hold unlimited NFTs.

### Contract Registration

You may register contracts manually from the console or via <Tooltip>API</Tooltip>.

<AccordionGroup>
  <Accordion title="My ABI wasn't automatically imported">
    When you compile your smart contract there will be a corresponding abi file with an `.abi` or `.json` extension.

    Inside this file, you'll see JSON property named abi, which describes the functions in your smart contract. Here's an example of a very simple abi file. Yours will likely have more function descriptions.

    ```json theme={null}
    // Example generated abi file for smart contract
    {
        "abi": [
            {
                "inputs": [],
                "stateMutability": "nonpayable",
                "type": "constructor"
            },
            {
                "inputs": [
                    {
                        "internalType": "address",
                        "name": "_to",
                        "type": "address"
                    }
                ],
                "name": "mintTo",
                "outputs": [],
                "stateMutability": "payable",
                "type": "function"
            }
        ]
    }
    ```

    Copy the JSON array object that comes after the string `abi` and paste it into the `Contract ABI` text box in the developer console. The content you paste in should begin with `[` and end with `]`.
  </Accordion>

  <Accordion title="Specifying the remaining parameters">
    Whether your ABI was retrieved automatically or you pasted it in manually, you need to specify the:

    * Mint function
    * Recipient address parameter name
    * \[Optional] Quantity of NFTs to mint parameter name

    Crossmint will attempt to automatically select these values for you, but it's important to ensure they are set correctly. Especially if you're setting up a USDC mint function as the list of options will be longer.
  </Accordion>

  <Accordion title="Using proxy contracts">
    Proxy contracts are an advanced feature. You should use this only if you are certain that your contracts adhere to this pattern. This is crucial because Crossmint requires the actual NFT contract address when you register a mint/buy/purchase/claim function in a sales contract or revenue splitter.

    If you don't specify the NFT contract address, our system won't be able to extract token URI information or facilitate transfers. Set this up only if it isn't a transparent proxy, which is common for upgradeable contracts.
  </Accordion>
</AccordionGroup>

### EVM Contract Import Steps

<Steps>
  <Step title="Step 5: Select `Import my own contract` option">
    <Frame type="simple">
      <img alt="Select contract provider screenshot" />
    </Frame>
  </Step>

  <Step title="Step 6: Contract Address">
    Enter the address of your contract and the console will determine the contract type automatically.

    <Frame type="simple">
      <img alt="Enter contract address screenshot" />
    </Frame>
  </Step>

  <Step title="Step 7: Proxy or Sales Contract (optional)">
    Notice in the screenshot that the example has the same contract address that was entered in previous step. This indicates a basic setup where the purchase function is within the registered NFT contract. The only reason to change this is if purchases should be sent to a different contract address that is not the same as the NFT contract.

    Most developers do not need to change this. If you are unsure, leave it as is. Transparent upgradeable contracts also do not need to use this setting and should use the beacon address in the previous step.

    <Frame type="simple">
      <img alt="Sales contract option screenshot" />
    </Frame>
  </Step>

  <Step title="Step 8: Contract ABI">
    As long as your contract is verified on the block explorer we can query the ABI automatically. If you have not verified your contract, you must enter the ABI manually.

    <Frame type="simple">
      <img alt="Contract ABI section screenshot" />
    </Frame>
  </Step>

  <Step title="Step 9: Mint Function Currency">
    Unless you specifically deployed a contract that supports USDC you must leave the native currency selected. If you are unsure, leave it as is.

    <Frame type="simple">
      <img alt="Contract mint function currency section screenshot" />
    </Frame>
  </Step>

  <Step title="Step 10: Select Mint Function">
    If you selected the native currency in the previous step, this will be a very short list. If you have multiple mint functions in your contract that you want to accept payments for, you must register each one separately.

    <Note>USDC mint functions typically are NOT `payable`. Change the currency selector to USDC to populate the mint function list with valid options.</Note>

    The mint function must accept an address parameter and mint to that address. If your mint function lacks this you'll need to deploy a new contract or modify your existing contract.

    <Frame type="simple">
      <img alt="Contract mint function section screenshot" />
    </Frame>
  </Step>

  <Step title="Step 11: Parameter for recipient address">
    After the mint function has been selected, this will be a short list built from the function parameters of type `address`. If you have multiple options here, ensure that you select the correct one. Doing this incorrectly will result in the purchased NFTs being sent to the wrong address and they likely will not be recoverable.

    <Frame type="simple">
      <img alt="Contract mint function recipient address section screenshot" />
    </Frame>
  </Step>

  <Step title="Step 12: Parameter for quantity">
    This will be a short list built from the function parameters of type `uint256`. If you have multiple options here, ensure that you select the correct one. Doing this incorrectly will result in the NFT checkout tools not being able to properly mint the correct quantity of NFTs.

    <Frame type="simple">
      <img alt="Contract mint function quantity parameter section screenshot" />
    </Frame>
  </Step>

  <Step title="Step 13: Review details and click `Register collection` to complete">
    <Frame type="simple">
      <img alt="EVM registration complete screenshot" />
    </Frame>
  </Step>
</Steps>

## Solana-Specific Steps

Complete the [Common Steps](#common-steps-all-chains) above first, then continue with these Solana-specific steps:

Instant support for:

* **Primaries**: Candy Machine v3, Metaplex Instant Sales, Magic Eden's Launchpad
* **Secondaries**: Auction House, Tensor, Magic Eden API, Hyperspace

<Note>
  Only the integrations listed above are available at the moment. For custom integrations, please [contact
  sales](https://www.crossmint.com/contact/sales?utm_source=devrel\&utm_medium=docs\&utm_campaign=backlinks).
</Note>

### Solana Candy Machine Import

Crossmint supports Candy Machine v3. After completing the common steps above, continue with these Solana-specific steps:

<Steps>
  <Step title="Step 5: Select Solana for the blockchain">
    This step replaces step 4 from the common steps above - select Solana from the blockchain dropdown.

    <Frame type="simple">
      <img alt="Select Solana blockchain screenshot" />
    </Frame>
  </Step>

  <Step title="Step 6: Choose candy machine version and enter candy machine ID">
    Find the ID in the `cache.json` file in the folder where you deployed your Candy Machine.

    <Frame type="simple">
      <img alt="Candy machine registration screenshot" />
    </Frame>
  </Step>

  <Step title="Step 7: Review details and click `Register collection` to complete">
    <Frame type="simple">
      <img alt="Candy machine registration complete screenshot" />
    </Frame>
  </Step>
</Steps>

Congratulations! 🎉 You've successfully registered your external collection in Crossmint.

<Snippet />

## FAQs

<AccordionGroup>
  <Accordion title="What about Xion blockchain contracts?">
    For Xion blockchain contracts, please refer to our [Xion Contract Requirements](/minting/advanced/xion-contracts) documentation.
  </Accordion>

  <Accordion title="What about other blockchains? (Aptos, Sui, etc.)">
    Currently only importing EVM and Solana primary contracts is self-serve. If you wish to import Aptos and Sui contracts, please [contact
    sales](https://www.crossmint.com/contact/sales?utm_source=devrel\&utm_medium=docs\&utm_campaign=backlinks).
  </Accordion>

  <Accordion title="Can I register my collection via API?">
    Yes! You can programmatically register collections using the Collections Registration API.

    **API Endpoint:** `POST https://staging.crossmint.com/api/v1-alpha1/collections`

    **Required Headers:**

    * `Content-Type: application/json`
    * `x-api-key: <your-api-key>` (requires `collections.create` scope)

    <CodeGroup>
      ```bash EVM Contract Example theme={null}
      curl --request POST \
           --url https://staging.crossmint.com/api/v1-alpha1/collections \
           --header 'content-type: application/json' \
           --header 'x-api-key: <X_API_KEY>' \
           --data '{
             "chain": "ethereum",
             "contractType": "erc-721",
             "args": {
               "contractAddress": "0x1234567890123456789012345678901234567890",
               "abi": "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"}],\"name\":\"mintTo\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}]",
               "mintFunctionName": "mintTo(address)",
               "toParamName": "_to",
               "quantityParamName": "_quantity",
               "contractType": "erc-721"
             },
             "metadata": {
               "title": "My NFT Collection",
               "description": "A custom NFT collection",
               "imageUrl": "https://example.com/collection-image.png",
               "social": {
                 "twitter": "https://twitter.com/mycollection",
                 "discord": "https://discord.gg/mycollection"
               }
             },
             "ownership": "external",
             "category": "art",
             "scopes": ["payments:credit-card", "payments:cross-chain"]
           }'
      ```

      ```bash Solana Candy Machine Example theme={null}
      curl --request POST \
           --url https://staging.crossmint.com/api/v1-alpha1/collections \
           --header 'content-type: application/json' \
           --header 'x-api-key: <X_API_KEY>' \
           --data '{
             "chain": "solana",
             "contractType": "candy-machine",
             "args": {
               "candyMachineId": "your-candy-machine-id-here"
             },
             "metadata": {
               "title": "My Solana Collection",
               "description": "A Solana NFT collection",
               "imageUrl": "https://example.com/collection-image.png"
             },
             "ownership": "external",
             "category": "art",
             "scopes": ["payments:credit-card", "payments:cross-chain"]
           }'
      ```
    </CodeGroup>

    **Key Parameters:**

    * **chain**: `"solana"`, `"ethereum"`, `"polygon"`, `"bsc"`
    * **contractType**: `"candy-machine"`, `"erc-721"`, `"erc-1155"`, `"thirdweb-drop"`
    * **args**: Contract-specific arguments (see examples above)
      * For EVM: `contractAddress`, `abi`, `mintFunctionName`, `toParamName`, `contractType` (required); `quantityParamName`, `tokenContractAddress` (optional)
      <Note>
        In EVM, if you use a separate contract for minting than for token metadata, set the minting contract address as `contractAddress`, and the token contract address as `tokenContractAddress`.
      </Note>
      * For Solana: `candyMachineId` (required)
    * **metadata**: Object with `title`, `description`, `imageUrl` (all required), and optional `social` object with `twitter`/`discord` links
    * **ownership**: `["self", "external"]`. Set to `"external"` for imported contracts
    * **category**: `"art"`, `"gaming"`, `"music"`, `"loyalty"`, `"ticketing"`, `"charity"`, `"other"`
    * **scopes**: `["payments:credit-card", "payments:cross-chain"]`. Scopes are required when `ownership` is `"external"`

    **Response (201 Created):**
    The API returns a collection object with identifiers you can use with Crossmint's checkout and payment systems.

    ```json theme={null}
    {
        "collectionId": "abc123-def456-ghi789...",
        "clientId": "abc123-def456-ghi789..."
    }
    ```

    <Note>This API is currently in alpha (v1-alpha1) and subject to change. The returned `collectionId` and `clientId` are typically the same value and can be used interchangeably for checkout integration.</Note>
  </Accordion>
</AccordionGroup>


# Client or Server
Source: https://docs.crossmint.com/payments/headless/guides/client-or-server

Understand the reasons to use client-side or server-side API keys

The headless checkout supports both server-side and client-side API keys. It's important that you select the right key for your implementation.

## When to use a server-side API key

* Testing in the [API Playground](/api-reference/headless/create-order) of the documentation
* Testing with cURL requests or running scripts from your command line
* Building applications that make API calls to your own backend, which then make the actual API call to Crossmint

<Note>The key consideration here is if the API request is coming from a server environment.</Note>

### Server Side Example Code

```typescript route.ts (server-side) theme={null}
import { callCrossmintAPI } from "@/app/utils/crossmint";
import { NextRequest, NextResponse } from "next/server";

const crossmintBaseUrl = process.env.CROSSMINT_API_URL;
const crossmintApiKey = process.env.CROSSMINT_API_KEY;

const crossmintAPIHeaders = {
    accept: "application/json",
    "content-type": "application/json",
    "x-api-key": crossmintApiKey,
};

const callCrossmintAPI = async (endpoint: string, options: { method: string; body?: any; params?: any }) => {
    const url = `${crossmintBaseUrl}/${endpoint}`;
    const { body, method } = options;

    const response = await fetch(url, {
        body: body ? JSON.stringify(body) : null,
        method,
        headers: crossmintAPIHeaders,
    });
    const json = await response.json();
    return json;
};

export async function POST(req: NextRequest, res: NextResponse) {
    try {
        const body = await req.json();
        console.log("create order: ", body);

        const apiResponse = await callCrossmintAPI("/orders", {
            method: "POST",
            body,
        });

        return NextResponse.json(apiResponse, { status: 200 });
    } catch (error) {
        console.log("failed to create order");
        return NextResponse.json({ message: "Error creating order" }, { status: 500 });
    }
}
```

## When to use a client-side API key

* Your application will be making API requests to Crossmint directly from a browser

<Note>
  When you create client-side API keys you must add the authorized origins that can use the key. For example, in
  testing you'll need to indicate `http://localhost:3000` (or similar local dev URLs) as authorized origins, or the
  request will be denied.
</Note>

<img alt="Client Key Domain" />

There is one additional step when using a client-side API key in your application with headless checkout. The first call will be to create the order. The response will include a `clientSecret` property that you must persist in state and then pass as an additional header in subsequent API requests to the [update-order](/api-reference/headless/edit-order) or [get-order](/api-reference/headless/get-order) routes.

### Client Side Example Code

<Note>
  The sample code below shows direct client-side API calls to Crossmint using a client-side API key. The `component.tsx` file is simplified to only show the relevant logic for making requests directly from the browser to Crossmint's API.
</Note>

<CodeGroup>
  ```tsx component.tsx (create-order) theme={null}
  // note the end of try block where the clientSecret is saved to local state
  const { setOrder, setClientSecret } = useLocalState();

  const createOrder = async (orderInput: any) => {
      try {
          const res = await fetch(`https://staging.crossmint.com/api/2022-06-09/orders`, {
              method: "POST",
              headers: {
                  "Content-Type": "application/json",
                  "x-api-key": process.env.NEXT_PUBLIC_CLIENT_SIDE_KEY,
              },
              body: JSON.stringify(orderInput),
          });

          const order = await res.json();

          setOrder(order.order);
          setClientSecret(order.clientSecret);
      } catch (e) {
          console.error(e);
          throw new Error("Failed to create order");
      }
  };
  ```

  ```tsx component.tsx (update-order) theme={null}
  // note the `authorization` header, which contains previously saved clientSecret
  const { order, clientSecret, setOrder } = useLocalState();

  const updateOrder = async (orderInput: any) => {
      try {
          const res = await fetch(`https://staging.crossmint.com/api/2022-06-09/orders/${order.orderId}`, {
              method: "PATCH",
              headers: {
                  "Content-Type": "application/json",
                  "x-api-key": process.env.NEXT_PUBLIC_CLIENT_SIDE_KEY,
                  authorization: clientSecret,
              },
              body: JSON.stringify(orderInput),
          });

          const updatedOrder = await res.json();

          setOrder(updatedOrder);
      } catch (e) {
          console.error(e);
          throw new Error("Failed to update order");
      }
  };
  ```

  ```tsx component.tsx (get-order) theme={null}
  // note the `authorization` header, which contains previously saved clientSecret
  const { order, clientSecret, setOrder } = useLocalState();

  const getOrder = async () => {
      try {
          const res = await fetch(`https://staging.crossmint.com/api/2022-06-09/orders/${order.orderId}`, {
              method: "GET",
              headers: {
                  "Content-Type": "application/json",
                  "x-api-key": process.env.NEXT_PUBLIC_CLIENT_SIDE_KEY,
                  authorization: clientSecret,
              },
          });

          const refreshedOrder = await res.json();

          setOrder(refreshedOrder);

          return refreshedOrder.lineItems[0].delivery.status;
      } catch (e) {
          console.error(e);
          throw new Error("Failed to fetch order");
      }
  };
  ```
</CodeGroup>

### Mobile Applications

When using client-side API keys in mobile applications, you must include an additional `x-app-identifier` header in your requests. This header should contain the bundle identifier (iOS) or package name (Android) that you whitelisted when creating your API key.

<img alt="Client Key Domain Mobile" />

<CodeGroup>
  ```swift iOS (Swift) theme={null}
  let headers = [
      "Content-Type": "application/json",
      "x-api-key": "your-client-side-api-key",
      "x-app-identifier": "com.yourcompany.yourapp", // iOS Bundle ID
      "authorization": clientSecret // When updating/reading orders
  ]
  ```

  ```kotlin Android (Kotlin) theme={null}
  val headers = mapOf(
      "Content-Type" to "application/json",
      "x-api-key" to "your-client-side-api-key",
      "x-app-identifier" to "com.yourcompany.yourapp", // Android Package Name
      "authorization" to clientSecret // When updating/reading orders
  )
  ```

  ```javascript React Native theme={null}
  const headers = {
      "Content-Type": "application/json",
      "x-api-key": "your-client-side-api-key",
      "x-app-identifier": "com.yourcompany.yourapp", // Bundle ID or Package Name
      authorization: clientSecret, // When updating/reading orders
  };
  ```
</CodeGroup>

<Note>
  The `x-app-identifier` must match one of the mobile app identifiers you whitelisted when creating your client-side
  API key. For more information on setting up mobile app identifiers, see the [Client-side API
  Keys](/introduction/platform/api-keys/client-side#mobile-app-identifiers) documentation.
</Note>


# Design Your UI
Source: https://docs.crossmint.com/payments/headless/guides/design-your-ui

How to get started with setting up your UI

This guide will walk you through the basic steps of implementing a user interface integrated with the Headless Checkout. The first step in the process will be to create an Order via API call.

You can create an order on load and add the recipient later, or wait to create the order when you have the recipient info ready. Creating the order immediately helps obtain the price quote for display. Let's proceed with that approach in mind.

## Building Your App

There are four key components you'll need to represent in the UI for your users.

1. Purchase Preview - a visual explanation of what they are buying and the price
2. Wallet Connection - cross-chain payments will require the ability to connect a wallet
3. Payment Status - keeping the user updated about the payment acceptance
4. Delivery Status - progress of delivery and information upon completion/failure

### Purchase Preview

It is common to create an order upon initial render for your user, and then update the details of that order as the adjustments are made by the user. You'll need to create a function in your application that can call the create-order API and save the response.

<Tabs>
  <Tab title="Preview Screenshot">
    After you create the `order` you'll get back metadata related to the `collectionId` you pass in the [create-order](/api-reference/headless/create-order) call. You can use this metadata to build the preview highlighted in the screenshot below.

    <Frame type="simple">
      <img alt="preview purchase screenshot" />
    </Frame>
  </Tab>

  <Tab title="Code Snippet">
    ```jsx theme={null}
    useEffect(() => {
        if (order != null) {
            return;
        }

        createOrder({
            payment: {
                method: "ethereum-sepolia",
                currency: "eth",
            },
            locale: "en-US",
            lineItems: [
                {
                    collectionLocator: "crossmint:YOUR_CROSSMINT_COLLECTION_ID",
                    callData: {
                        totalPrice: "0.001",
                    },
                },
            ],
        });
    }, [order]);
    ```
  </Tab>
</Tabs>

### Wallet Connection

To enable the cross-chain payments feature, you'll need to provide an easy way for users to connect their wallet. This guide will not go into detail about how to add any specific tools, since there are a variety available and the implementation of each is unique to the tool.

However, you will want to set up your app to listen for changes to the primary connected wallet and selected network so that the order is updated automatically.

<Tabs>
  <Tab title="Wallet & Network Screenshot">
    Once the user has connected their wallet they might still change the primary connected account or network. You need to listen for these changes and update the order.

    <Frame type="simple">
      <img alt="preview wallet and network screenshot" />
    </Frame>
  </Tab>

  <Tab title="Code Snippet">
    Note the dependency array at the end of this `useEffect` watches `primaryWallet` and `selectedNetwork`. If any of these change your app needs to refresh the order with the new values.

    ```jsx theme={null}
    useEffect(() => {
        if (order == null || primaryWallet == null) {
            return;
        }

        const currentRecipient = order.lineItems[0].delivery.recipient?.walletAddress;
        const isSameWallet = currentRecipient === primaryWallet.address;
        const isSameNetwork = order.payment.method === selectedNetwork;
        if (isSameWallet && isSameNetwork) {
            return;
        }

        updateOrder({
            recipient: {
                walletAddress: primaryWallet.address,
            },
            payment: {
                method: selectedNetwork,
                currency: "eth",
                payerAddress: primaryWallet.address,
            },
        });
    }, [primaryWallet, selectedNetwork]);
    ```
  </Tab>
</Tabs>


# Item Selection
Source: https://docs.crossmint.com/payments/headless/guides/item-selection

Specify which items to purchase with Headless Checkout API

The Headless Checkout API allows you to specify which items your users can purchase using the `lineItems` property. This guide explains how to configure item selection for different asset types.

<Snippet />

## JSON Item Selection Examples

<CodeGroup>
  ```json collectionLocator theme={null}
  {
    "lineItems": [
      {
        "collectionLocator": "crossmint:_YOUR_COLLECTION_ID_", // Crossmint managed collection
        // "collectionLocator": "crossmint:_YOUR_COLLECTION_ID_:_TEMPLATE_ID_", // With specific template
        "callData": {
          "totalPrice": "5.00",
          "quantity": 1 // matches your contract's parameter name
        }
      }
    ]
  }
  // To use exact-in mode, add executionParameters: { maxSlippageBps: "500" } to the lineItem object. For custom contract params, add executionParameters: { customParam: "value" }.
  ```

  ```json collectionLocator - imported contract theme={null}
  {
    "lineItems": [
      {
        "collectionLocator": "ethereum:0x71c7656ec7ab88b098defb751b7401b5f6d897", // External collection registered in Crossmint Console
        "callData": {
          "totalPrice": "5.00",
          "quantity": 1 // matches your contract's parameter name
          // For external contracts, you might need additional parameters such as:
          // "_amount": 1, // if your mint function uses _amount instead of quantity
          // "tokenId": "123", // if your contract requires a specific tokenId
          // "metadata": "ipfs://...", // if your contract accepts metadata
        }
      }
    ]
  }
  ```

  ```json tokenLocator - EVM theme={null}
  {
    "lineItems": [
      {
        "tokenLocator": "ethereum:0x71c7656ec7ab88b098defb751b7401b5f6d897:1234", // <blockchain>:<contractAddress>:<tokenId>
        "callData": {
          "totalPrice": "25.00" // Only totalPrice is required for token purchases
          // For external EVM contracts, you might need additional parameters:
          // "_amount": 1, // if your contract uses _amount instead of quantity
          // "tokenId": "1234", // if your contract requires explicit tokenId
          // "metadata": "ipfs://...", // if your contract accepts metadata
        }
      }
    ]
  }
  // To use exact-in mode, add executionParameters: { maxSlippageBps: "500" } to the lineItem object. For custom contract params, add executionParameters: { customParam: "value" }.
  ```

  ```json tokenLocator - Solana theme={null}
  {
    "lineItems": [
      {
        "tokenLocator": "solana:7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU", // <blockchain>:<tokenAddress>
        "callData": {
          "totalPrice": "25.00",
          "buyerCreatorRoyaltyPercent": 100 // Required for Solana
        }
      }
    ]
  }
  // To use exact-in mode, add executionParameters: { maxSlippageBps: "500" } to the lineItem object. For custom contract params, add executionParameters: { customParam: "value" }.
  ```

  ```json productLocator theme={null}
  {
    "lineItems": [
      {
        "productLocator": "amazon:B01DFKC2SO", // Amazon ASIN
        // "productLocator": "amazon:https://www.amazon.com/dp/B01DFKC2SO", // Amazon URL
        // "productLocator": "shopify:https://your-store.myshopify.com/products/product-name:123456789", // Shopify
      }
    ]
  }
  ```
</CodeGroup>

<Snippet />

<Snippet />

## Complete API Request Examples

For those who want a full copy/pastable code example, extended versions of the JSON guides are provided below.

<CodeGroup>
  ```javascript collectionLocator theme={null}
  const options = {
      method: "POST",
      headers: { "x-api-key": "_YOUR_API_KEY_", "Content-Type": "application/json" },
      body: JSON.stringify({
          recipient: {
              email: "buyer@example.com",
          },
          payment: {
              method: "ethereum-sepolia",
              currency: "eth",
          },
          lineItems: [
              {
                  collectionLocator: "crossmint:_YOUR_COLLECTION_ID_", // Crossmint managed collection
                  // collectionLocator: "crossmint:_YOUR_COLLECTION_ID_:_TEMPLATE_ID_", // With specific template
                  callData: {
                      totalPrice: "5.00",
                      quantity: 1, // matches your contract's parameter name
                  },
              }
          ],
      }),
  };

  fetch("https://staging.crossmint.com/api/2022-06-09/orders", options)
      .then((response) => response.json())
      .then((response) => console.log(response))
      .catch((err) => console.error(err));
  ```

  ```javascript tokenLocator - EVM theme={null}
  const options = {
      method: "POST",
      headers: { "x-api-key": "_YOUR_API_KEY_", "Content-Type": "application/json" },
      body: JSON.stringify({
          recipient: {
              email: "buyer@example.com",
          },
          payment: {
              method: "ethereum-sepolia",
              currency: "eth",
          },
          lineItems: [
              {
                  tokenLocator: "ethereum:0x71c7656ec7ab88b098defb751b7401b5f6d897:1234", // <blockchain>:<contractAddress>:<tokenId>
                  callData: {
                      totalPrice: "25.00", // Only totalPrice is required for token purchases
                      // For external EVM contracts, you might need additional parameters:
                      // _amount: 1, // if your contract uses _amount instead of quantity
                      // tokenId: "1234", // if your contract requires explicit tokenId
                      // metadata: "ipfs://...", // if your contract accepts metadata
                  },
              }
          ],
      }),
  };

  fetch("https://staging.crossmint.com/api/2022-06-09/orders", options)
      .then((response) => response.json())
      .then((response) => console.log(response))
      .catch((err) => console.error(err));
  ```

  ```javascript tokenLocator - Solana theme={null}
  const options = {
      method: "POST",
      headers: { "x-api-key": "_YOUR_API_KEY_", "Content-Type": "application/json" },
      body: JSON.stringify({
          recipient: {
              email: "buyer@example.com",
          },
          payment: {
              method: "solana",
              currency: "sol",
          },
          lineItems: [
              {
                  tokenLocator: "solana:7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU", // <blockchain>:<tokenAddress>
                  callData: {
                      totalPrice: "25.00",
                      buyerCreatorRoyaltyPercent: 100, // Required for Solana
                  },
              }
          ],
      }),
  };

  fetch("https://staging.crossmint.com/api/2022-06-09/orders", options)
      .then((response) => response.json())
      .then((response) => console.log(response))
      .catch((err) => console.error(err));
  ```

  ```javascript productLocator theme={null}
  const options = {
      method: "POST",
      headers: { "x-api-key": "_YOUR_API_KEY_", "Content-Type": "application/json" },
      body: JSON.stringify({
          recipient: {
              email: "buyer@example.com",
              physicalAddress: {
                  name: "John Doe",
                  line1: "123 Main St",
                  city: "San Francisco",
                  state: "CA",
                  postalCode: "94105",
                  country: "US",
              },
          },
          payment: {
              method: "ethereum-sepolia",
              currency: "eth",
          },
          lineItems: [
              {
                  productLocator: "amazon:B01DFKC2SO", // Amazon ASIN
                  // productLocator: "amazon:https://www.amazon.com/dp/B01DFKC2SO", // Amazon URL
                  // productLocator: "shopify:https://your-store.myshopify.com/products/product-name:123456789", // Shopify
              }
          ],
      }),
  };

  fetch("https://staging.crossmint.com/api/2022-06-09/orders", options)
      .then((response) => response.json())
      .then((response) => console.log(response))
      .catch((err) => console.error(err));
  ```

  ```javascript collectionLocator - imported contract theme={null}
  const options = {
      method: "POST",
      headers: { "x-api-key": "_YOUR_API_KEY_", "Content-Type": "application/json" },
      body: JSON.stringify({
          recipient: {
              email: "buyer@example.com",
          },
          payment: {
              method: "ethereum-sepolia",
              currency: "eth",
          },
          lineItems: [
              {
                  collectionLocator: "ethereum:0x71c7656ec7ab88b098defb751b7401b5f6d897", // External collection registered in Crossmint Console
                  callData: {
                      totalPrice: "5.00",
                      quantity: 1, // matches your contract's parameter name
                      // For external contracts, you might need additional parameters such as:
                      // _amount: 1, // if your mint function uses _amount instead of quantity
                      // tokenId: "123", // if your contract requires a specific tokenId
                      // metadata: "ipfs://...", // if your contract accepts metadata
                  },
              }
          ],
      }),
  };

  fetch("https://staging.crossmint.com/api/2022-06-09/orders", options)
      .then((response) => response.json())
      .then((response) => console.log(response))
      .catch((err) => console.error(err));
  ```
</CodeGroup>

<Note>
  For more details on physical product purchases, see our guides for [Amazon
  Integration](/payments/headless/guides/providers/amazon) and [Shopify
  Integration](/payments/headless/guides/providers/shopify).
</Note>

<Snippet />


# Localization
Source: https://docs.crossmint.com/payments/headless/guides/localization

Customize the language of receipts and currency of the checkout

## Currencies and Languages Available

| Variable           | Possible Values                                                                                                                   | Description                                                                                                                                                              |
| ------------------ | --------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `locale`           | `en-US` `de-DE` `es-ES` `fr-FR` `it-IT` `ja-JP` `ko-KR` `pt-PT` `ru-RU` `th-TH` `tr-TR` `uk-UA` `vi-VN` `zh-CN` `zh-TW` `Klingon` | Language selected for the email receipt.                                                                                                                                 |
| `payment.currency` | `usd` `aud` `eur` `gbp` `hkd` `inr` `jpy` `krw` `sgd` `vnd`                                                                       | Currency for the payment quote. The original price of the collection will be automatically converted to the selected currency using the most recent bank exchange rates. |

<Note>
  Localization is not supported for stablecoins. While `payment.crypto.defaultCurrency` can be set to `usdc` or other
  supported tokens, localized stablecoins like `eurc` are not available.
</Note>

To customize the language use the property `locale` and for currency, set `currency` under the payment object. Here's an example:

```json {2,6} theme={null}
{
    "locale": "es-ES", // Price for receipt (e.g. Spanish customers)
    "payment": {
        "receiptEmail": "jsmith@example.com",
        "method": "card",
        "currency": "eur" // If collection is priced in USD, price returned for quote will be in EUR
    },
    "lineItems": [
        {
            "collectionLocator": "crossmint:76ced33d-fec8-4741-a69f-450f1ae09fa6",
            "callData": {
                "totalPrice": "<string>"
            }
        }
    ]
}
```

<Note>
  When implementing a headless checkout, you'll need to handle the display of localized content in your own UI based
  on the locale you've selected. The locale only affects the email receipt language, not the checkout interface built
  by you.
</Note>


# Multiple Line Items
Source: https://docs.crossmint.com/payments/headless/guides/multiple-line-items

How to handle orders with multiple NFTs at once

The Headless Checkout multiple line items feature is used to build more elaborate purchase experiences, which require multiple NFT purchases at once. Multiple line items is currently only supported for NFTs.

<Note>Currently, there is a maximum limit of 15 NFTs per order.</Note>

Example use cases include:

* A marketplace where a buyer can add multiple NFTs to a cart and make the purchase in a single transaction.
* Enabling the purchase of multiple distinct tokens from an ERC-1155 contract in a single transaction.

## Marketplace Sales

The following example requires that you have a custom `collectionId` that supports secondary sales provisioned for you by your Crossmint Customer Success Engineer. For more information on marketplace and launchpad support, check [this guide](/payments/advanced/marketplaces-and-launchpads).

If you need to contact the team about getting set up with secondary sales support [contact the team](https://www.crossmint.com/contact/sales).

### Multiple `lineItems` for Secondary Sales

To enable a multi item purchase, you simply need to pass an array of `lineItems` instead of a single object when creating an order.

The below examples demonstrate how to create a multiple line item order for secondary sales:

<CodeGroup>
  ```shell cURL theme={null}
  curl --request POST \
    --url https://staging.crossmint.com/api/2022-06-09/orders \
    --header 'Content-Type: application/json' \
    --header 'x-api-key: _YOUR_API_KEY_' \
    --data '{
      "recipient": {
        "email": "testy@crossmint.com"
      },
      "locale": "en-US",
      "payment": {
        "receiptEmail": "testy@crossmint.com",
        "method": "ethereum-sepolia",
        "currency": "eth"
      },
      "lineItems": [
        {
          "collectionLocator": "crossmint:_YOUR_SECONDARY_SALES_COLLECTION_ID_",
          "callData": {
            "contractAddress": "0x___CONTRACT_ADDRESS_OF_TOKEN",
            "tokenId": "234"
          }
        },
        {
          "collectionLocator": "crossmint:_YOUR_SECONDARY_SALES_COLLECTION_ID_",
          "callData": {
            "contractAddress": "0x___ANOTHER_TOKEN_CONTRACT",
            "tokenId": "567"
          }
        }
      ]
    }'
  ```

  ```javascript JavaScript theme={null}
  const options = {
    method: 'POST',
    headers: {'x-api-key': '_YOUR_API_KEY_', 'Content-Type': 'application/json'},
    body: '{
      "recipient": {
        "email": "test@crossmint.com"
      },
      "locale": "en-US",
      "payment": {
        "receiptEmail": "test@crossmint.com",
        "method": "ethereum-sepolia",
        "currency": "eth",
        "payerAddress": "0x1234_payer_address"
      },
      "lineItems": [
        {
          "collectionLocator": "crossmint:_YOUR_SECONDARY_SALES_COLLECTION_ID_",
          "callData": {
            "contractAddress": "0x___CONTRACT_ADDRESS_OF_TOKEN",
            "tokenId": "234"
          }
        },
        {
          "collectionLocator": "crossmint:_YOUR_SECONDARY_SALES_COLLECTION_ID_",
          "callData": {
            "contractAddress": "0x___ANOTHER_TOKEN_CONTRACT",
            "tokenId": "567"
          }
        }
      ]
    }'
  };

  fetch('https://staging.crossmint.com/api/2022-06-09/orders', options)
    .then(response => response.json())
    .then(response => console.log(response))
    .catch(err => console.error(err));
  ```
</CodeGroup>

After this step you will collect payment from the buyer as outlined in the [Order Lifecycle](/payments/headless/guides/order-lifecycle/) section.

## Primary Sales of Multiple Items

<Note>
  If you have a custom ERC-721 contract that supports the minter being able to specify which token they want to mint
  you could use the example(s) below to enable them to purchase multiple and specific tokens in the same transaction.
  This is an uncommon pattern for ERC-721 contracts though.
</Note>

In the following example, the use case is purchasing two unique tokens from an ERC-1155 contract. You can see that the `_id` passed in the `callData` of each `lineItem` is unique (1 and 2).

<CodeGroup>
  ```shell cURL theme={null}
  curl --request POST \
    --url https://staging.crossmint.com/api/2022-06-09/orders \
    --header 'Content-Type: application/json' \
    --header 'x-api-key: _YOUR_API_KEY_' \
    --data '{
    "recipient": {
      "email": "testy@crossmint.com"
    },
    "locale": "en-US",
    "payment": {
      "receiptEmail": "testy@crossmint.com",
      "method": "ethereum-sepolia",
      "currency": "eth"
    },
    "lineItems": [
      {
        "collectionLocator": "crossmint:_YOUR_COLLECTION_ID_",
        "callData": {
          "_id_": "1",
          "quantity": "1"
        }
      },
      {
        "collectionLocator": "crossmint:_YOUR_COLLECTION_ID_",
        "callData": {
          "_id_": "2",
          "quantity": "1"
        }
      },
    ]
  }'
  ```

  ```javascript JavaScript theme={null}
  const options = {
    method: 'POST',
    headers: {'x-api-key': '_YOUR_API_KEY_', 'Content-Type': 'application/json'},
    body: '{
        "recipient":
        {
            "email": "testy@crossmint.com"
        },
        "locale": "en-US",
        "payment":
        {
            "receiptEmail": "testy@crossmint.com",
            "method": "ethereum-sepolia",
            "currency": "eth",
            "payerAddress": "0x1234_payer_address"
        },
        "lineItems": [
          {
            "collectionLocator": "crossmint:_YOUR_COLLECTION_ID_",
            "callData": {
              "_id_": "1",
              "quantity": "1"
            }
          },
          {
            "collectionLocator": "crossmint:_YOUR_COLLECTION_ID_",
            "callData": {
              "_id_": "2",
              "quantity": "1"
            }
          },
        ]
      }'
    };

  fetch('https://staging.crossmint.com/api/2022-06-09/orders', options)
    .then(response => response.json())
    .then(response => console.log(response))
    .catch(err => console.error(err));
  ```
</CodeGroup>

As in the secondary sales example above, you'll need to handle the remaining steps of the order lifecycle in your UI - payment, delivery, etc.

## Error Handling

As outlined in the [Delivery Phase](/payments/headless/guides/order-lifecycle/delivery-phase#error-handling) of the order lifecycle guides, it is important to keep track of the delivery for each item passed when you created the order and report back to the user on the status of the order.

Each line item is attempted and processed independently. If one line item fails, others will still go through and be fulfilled. If any items are undeliverable, the buyer will be automatically refunded for that specific portion of their order.
For definitions of delivery and line item statuses, see the <a href="/payments/headless/guides/status-codes">Status Codes</a> page.


# Order Complete Phase
Source: https://docs.crossmint.com/payments/headless/guides/order-lifecycle/completed-phase

Completion phase of the order lifecycle

The final phase in the order lifecycle is order completion. This occurs once payment has been successful and the delivery phase is finished.

For a multi-item order, as long as at least one item was fulfilled successfully the order is considered successful. If all items fail to deliver in an order then the order status is failed.

To determine the order completion status simply check the `order.phase` property. This will be set to `completed` for a successful order or `failed` if all items were unable to be delivered.
For reference on all statuses (quote, payment, delivery), see the [Status Codes](/payments/headless/guides/status-codes) page.

<Note>
  For a multi-item order you'll need to loop through the `lineItems` array returned in the get order response to
  ensure the `delivery.status` is `completed` for each item.
</Note>

### Recommendations

Think through and implement the call to action that makes sense for your buyers.

#### Where can they access the purchased item?

If the token was minted to their Crossmint wallet you can provide a direct link and/or render a representation of it.

Even if they minted directly to an existing wallet you can provide a link to display the token in Crossmint. Use the following URL format to display NFTs within Crossmint:

`https://www.crossmint.com/user/collection/<chain>:<contractAddress>:<tokenId>`

For info on the values to use for `<chain>` refer to the [supported chains](/introduction/supported-chains) page.

#### What are the next steps?

Can they stake, trade, or utilize the purchase in some way? Tell them how!

#### Handling Order failure

If there were any issues with delivery explain what happened and ensure they know that refunds are automatic. Anyone who purchases through Crossmint and has an issue with delivery can contact our support team for assistance.


# Pay with Card
Source: https://docs.crossmint.com/payments/headless/guides/order-lifecycle/credit-card-payment-phase

Payment acceptance phase of the order lifecycle for credit cards.

The order lifecycle can be summarized as follows:

<Steps>
  <Step title="Order Creation or Update">
    Your application determines recipient info for the buyer. It can be an email wallet or wallet address. Create or
    update an order with this info to proceed to next step.
  </Step>

  <Step title="API Response">
    The API response returned from create/update order call(s) will include a `clientSecret` and `order` object that your
    application uses to render the Crossmint Embedded Component.
  </Step>

  <Step title="Render Crossmint Embedded Component">
    Use the `clientSecret` and `order.orderId` returned in the API response to render the Crossmint Embedded Component
    for credit card checkout.
  </Step>

  <Step title="User Completes Payment">The buyer completes checkout via credit card.</Step>

  <Step title="Poll for Status">
    Your application will poll the GET order status and update the UI as the order progresses to the next phase.
  </Step>
</Steps>

<Note>During the initial `quote` phase of the order the payment status will be `requires-quote`.</Note>

Once the quote phase is completed, the order enters the payment phase and will have the status `awaiting-payment`, which indicates that the order is ready to be paid.

For the complete, authoritative list of payment statuses and their meanings, see the [Status Codes](/payments/headless/guides/status-codes) page. |

### Render the Crossmint Embedded Component

When the order is ready to accept payment, the API response will include a `clientSecret` and `order` object. You can use these with the Crossmint Embedded Component to collect the user's credit card payment.

<Accordion title="Example response">
  ```json theme={null}
  {
    "clientSecret": "_YOUR_CLIENT_SECRET_",
    "order": {
      "orderId": "5ddc0090-7f63-4f6a-b68d-a91f8253b02e",
      "phase": "payment",
      "locale": "en-US",
      "lineItems": [], // removed for brevity
      "quote": {
        "status": "valid",
        "quotedAt": "_timestamp_",
        "expiresAt": "_timestamp_",
        "totalPrice": {
          "amount": "0.5",
          "currency": "usd"
        }
      },
      "payment": {
        "status": "awaiting-payment",
        "method": "basis-theory",
        "currency": "usd",
        "preparation": {},
        "receiptEmail": "test@example.com"
      }
    }
  }
  ```
</Accordion>

After creating an order, you'll need to render the Crossmint Embedded Component to collect payment information. This secure, embeddable UI component lets you accept payment methods, validates input, and handles errors:

```tsx theme={null}
import { CrossmintEmbeddedCheckout, CrossmintProvider } from "@crossmint/client-sdk-react-ui";

export function MyCheckoutPage({ clientSecret, order, recipientWalletAddress, receiptEmail }) {
  return (
    <div className="w-full">
      <CrossmintProvider apiKey="<YOUR_CLIENT_SIDE_KEY>">
        <CrossmintEmbeddedCheckout 
          recipient={{ walletAddress: recipientWalletAddress}}
          clientSecret={clientSecret}
          orderId={order.orderId}
          payment={{
            crypto: {
                enabled: false,
            },
            fiat: {
                enabled: true,
                allowedMethods: {
                    card: true,
                    applePay: false,
                    googlePay: false,
                },
            },
            defaultMethod: "fiat",
            receiptEmail: receiptEmail,
          }}
          appearance={{
              rules: {
                  DestinationInput: {
                      display: "hidden",
                  },
                  ReceiptEmailInput: {
                      display: "hidden",
                  },
              },
          }} />
      </CrossmintProvider>
    </div>
  );
}
```

<Tip>
  The `CrossmintEmbeddedCheckout` component is highly customizable. You can adjust colors, styling, layout, and behavior to match your brand. Learn more in our [UI customization guide](/payments/embedded/guides/ui-customization).
</Tip>

### Poll for Status Updates

<Snippet />

### Handling Refunded Payments

When polling for order status, you may encounter a situation where `payment.status` is `completed` but the order also contains a `payment.refunded` property. This indicates that the payment was initially successful but has since been refunded.

```json theme={null}
{
    "order": {
        "payment": {
            "status": "completed",
            "refunded": {
                "amount": "1.00",
                "currency": "usd"
            }
        }
    }
}
```

The `payment.refunded` object includes the following fields:

* `amount`: The amount that was refunded
* `currency`: The currency of the refund

When you encounter this state, your application should:

1. Display an appropriate message to the user indicating that their payment was refunded
2. Prevent any further actions related to the order (such as delivery expectations)
3. Provide options for the user to place a new order if desired

This state typically occurs when there was an issue with processing the order after payment was received, such as insufficient liquidity for memecoin purchases or compliance issues.


# Pay with Crypto
Source: https://docs.crossmint.com/payments/headless/guides/order-lifecycle/crypto-payment-phase

Payment acceptance phase of the order lifecycle for pay with crypto

An overview of the process works as follows:

<Steps>
  <Step title="Order Creation or Update">
    Your user selects the chain, token, and wallet they want to pay from via your application and you create or
    update an existing order with this information.
  </Step>

  <Step title="API Response">
    The API response returned from create or update order will include a `serializedTransaction` that your
    application uses to request payment from the user's wallet.
  </Step>

  <Step title="User Confirms Transaction">
    After your application initiates the payment request the user must confirm the transaction.
  </Step>

  <Step title="Poll for Status">
    Your application will poll the GET order status and update the UI as the order progresses to the next phase.
  </Step>
</Steps>

<Note>During the initial `quote` phase of the order the payment status will be `requires-quote`.</Note>

Once the quote phase is completed, the order enters the payment phase.

For most orders the payment phase will begin with the status `awaiting-payment`, which indicates that the order is ready to be paid. It can also begin with `requires-crypto-payer-address` if the payer address is missing.

For the complete, authoritative list of payment statuses and their meanings, see the [Status Codes](/payments/headless/guides/status-codes) page. |

### Setting the Payer Address

The order must know the address that will be sending the crypto payment. This enables Crossmint's payment listeners to associate incoming transactions with the correct order. To update the order with the payer address, call the update API as demonstrated below:

`PATCH` `/api/2022-06-09/orders/<orderId>`

```json theme={null}
{
    "payment": {
        "currency": "eth",
        "method": "base-sepolia",
        "payerAddress": "0x1234abcd…"
    }
}
```

The `payerAddress` is the wallet the user will be sending the payment from. Note that you must send the entire payment object even if the currency and/or method values are not changing.

### Submitting the Payment

When you've fully prepared the order such that the payment status is `awaiting-payment` you'll have everything necessary to request the crypto payment from your user. The details will be returned in the `order.payment.preparation` property.

<Accordion title="Example response">
  ```json theme={null}
  {
    "orderId": "c167db0f-0cb9-4c59-80d3-aface6bcb338",
    "phase": "payment",
    "locale": "en-US",
    "lineItems": [], // removed for brevity
    "quote": // removed for brevity
    "payment": {
      "status": "awaiting-payment",
      "method": "base-sepolia",
      "currency": "eth",
      "preparation": {
        "chain": "base-sepolia",
        "payerAddress": "0x6C3b3225759Cbda68F96378A9F0277B4374f9F06",
        "serializedTransaction": "0x02f9015083014a34238489173700848917387582653d94a105c311fa72b8fb78c992ecbdb8b02ea5bd394d868644e0f88d81b9011e2d2d2d2d2d2d424547494e204d454d4f2d2d2d2d2d2d65794a68624763694f694a49557a49314e694973496e523563434936496b705856434a392e65794a756232356a5a534936496a4e6b5954673159324a6b4c546c6a4e4459744e4459774f4331694d44686a4c5746694e6d557a595746684e4468694d794973496d39795a4756795357526c626e52705a6d6c6c63694936496d4d784e6a646b596a426d4c54426a596a6b744e474d314f5330344d47517a4c57466d59574e6c4e6d4a6a596a4d7a4f434973496d6c68644349364d5463784f446b784d7a63774f48302e75574365534961563642504b6f6935724d7939394c2d4b56303256644d4d343442343934724c4352656f632d2d2d2d2d2d454e44204d454d4f2d2d2d2d2d2dc0"
      }
    }
  }
  ```
</Accordion>

The `order.payment.preparation` property contains details about the chain that Crossmint is expecting the payment to be received on, the payer address, and a `serializedTransaction` that you can use to open a payment request in the user's wallet. See examples of how to parse the response and request transaction confirmation from the user below:

<Tabs>
  <Tab title="EVM">
    ```jsx theme={null}
    import { parseTransaction } from "viem";
    import { useSendTransaction } from "wagmi";

    const { sendTransactionAsync } = useSendTransaction();

    const signAndSendTransaction = async (serializedTransaction) => {
        const txn = parseTransaction(serializedTransaction)

        try {
          const txId = await sendTransactionAsync(txn);
          console.log("Transaction ID:", txId);
        } catch (error) {
          console.error("Error sending transaction:", error);
        }
    };
    ```
  </Tab>

  <Tab title="Solana">
    ```jsx theme={null}
    import bs58 from "bs58";
    import { useConnection, useWallet } from "@solana/wallet-adapter-react";

    const { connection } = useConnection();
    const { sendTransaction } = useWallet();

    const signAndSendTransaction = async (serializedTransaction) => {
        const transaction = Transaction.from(bs58.decode(serializedTransaction));

        try {
           const txId = await sendTransaction(transaction, connection);
           console.log("Transaction ID:", txId);
        } catch (error) {
          console.error("Error sending transaction:", error);
        }
    }
    ```
  </Tab>
</Tabs>

<Warning>
  You should **never** alter the values in the parsed transaction object. Simply parse the transaction object as shown
  in the example above. Changing any of these values may result in Crossmint not being able to validate the payment.
</Warning>

Calling the `signAndSendTransaction` function in the code snippet(s) above will open the user's wallet and enable them to confirm the crypto payment.

### Awaiting Payment Confirmation

<Check>We recommend a polling interval of about 2500ms and never below 500ms.</Check>

<Note>
  You can use client-side or server-side API keys to implement headless checkout. Check the code samples for the type
  of API key you're using in your application.
</Note>

<Tabs>
  <Tab title="Client Side">
    ```tsx theme={null}
    const getOrderPaymentStatus = async () => {
        const apiUrl = "https://staging.crossmint.com/api/2022-06-09";
        try {
            const res = await fetch(`${apiUrl}/orders/${order.orderId}`, {
                method: "GET",
                headers: {
                    "Content-Type": "application/json",
                    "x-api-key": process.env.NEXT_PUBLIC_CROSSMINT_API_KEY,
                    authorization: clientSecret, // saved from response of create order call
                },
            });

            const refreshedOrder = await res.json();

            setOrder(refreshedOrder);

            return refreshedOrder.payment.status;
        } catch (e) {
            console.error(e);
            throw new Error("Failed to fetch order");
        }
    };

    const pollPaymentStatus = async () => {
        const intervalId = setInterval(async () => {
            const status = await getOrderPaymentStatus();
            console.log("payment status: ", status);
            if (status === "completed") {
                clearInterval(intervalId);
            }
        }, 2500);

        // Set a timeout to stop polling after 60 seconds
        setTimeout(() => {
            clearInterval(intervalId);
            console.log("Taking longer than expected...");
        }, 60000);
    };
    ```
  </Tab>

  <Tab title="Server Side">
    <Note>
      The sample code below is from a NextJS application. The `component.tsx` file is simplified to only show the relevant
      logic. The client-side component sends an API request to the application's backend, which then proxies the request
      to Crossmint. This is because the example is using a server-side API key, which requires making requests from a server environment.
    </Note>

    <CodeGroup>
      ```tsx component.tsx (client-side) theme={null}
      const getOrderPaymentStatus = async () => {
          try {
              const res = await fetch(`/orders/${order.orderId}`, {
                  method: "GET",
                  headers: {
                      "Content-Type": "application/json",
                  },
              });

              const refreshedOrder = await res.json();

              setOrder(refreshedOrder);

              return refreshedOrder.payment.status;
          } catch (e) {
              console.error(e);
              throw new Error("Failed to fetch order");
          }
      };

      const pollPaymentStatus = async () => {
          const intervalId = setInterval(async () => {
              try {
                  const status = await getOrderPaymentStatus();
                  console.log("payment status: ", status);
                  if (status === "completed") {
                      clearInterval(intervalId);
                  }
              } catch (e) {
                  clearInterval(intervalId);
                  console.error("Error polling payment status: ", e);
              }
          }, 2500);

          // Set a timeout to stop polling after 60 seconds
          setTimeout(() => {
              clearInterval(intervalId);
              console.log("Taking longer than expected...");
          }, 60000);
      };
      ```

      ```typescript route.ts (server-side) theme={null}
      import { callCrossmintAPI } from "@/app/utils/crossmint";
      import { NextRequest, NextResponse } from "next/server";

      export async function GET(req: NextRequest, { params }: { params: { orderId: string } }) {
          if (params.orderId) {
              const order = await callCrossmintAPI(`/orders/${params.orderId}`, {
                  method: "GET",
              });

              return NextResponse.json(order, { status: 200 });
          } else {
              return NextResponse.json({ error: true, message: "Missing orderId" }, { status: 400 });
          }
      }
      ```

      ```typescript crossmint.ts theme={null}
      const crossmintBaseUrl = process.env.CROSSMINT_API_URL;

      const crossmintAPIHeaders = {
          accept: "application/json",
          "content-type": "application/json",
          "x-api-key": process.env.CROSSMINT_API_KEY!,
      };

      const callCrossmintAPI = async (endpoint: string, options: { method: string; body?: any; params?: any }) => {
          const url = `${crossmintBaseUrl}/${endpoint}`;
          const { body, method } = options;

          const response = await fetch(url, {
              body: body ? JSON.stringify(body) : null,
              method,
              headers: crossmintAPIHeaders,
          });
          const json = await response.json();
          return json;
      };

      export { callCrossmintAPI };
      ```
    </CodeGroup>
  </Tab>
</Tabs>

Once the payment is confirmed, you can move on to the delivery phase of the order lifecycle.

### Handling Refunded Payments

When polling for order status, you may encounter a situation where `payment.status` is `completed` but the order also contains a `payment.refunded` property. This indicates that the payment was initially successful but has since been refunded.

```json theme={null}
{
    "order": {
        "payment": {
            "status": "completed",
            "refunded": {
                "amount": "1.23",
                "currency": "eth"
            }
        }
    }
}
```

The `payment.refunded` object includes the following fields:

* `amount`: The amount that was refunded
* `currency`: The currency of the refund

When you encounter this state, your application should:

1. Display an appropriate message to the user indicating that their payment was refunded
2. Prevent any further actions related to the order (such as delivery expectations)
3. Provide options for the user to place a new order if desired

This state typically occurs when there was an issue with processing the order after payment was received, such as insufficient liquidity for memecoin purchases or compliance issues.


# Delivery Phase
Source: https://docs.crossmint.com/payments/headless/guides/order-lifecycle/delivery-phase

Token delivery phase of the order lifecycle

When the payment phase is completed, the user is guaranteed to receive the items ordered or an automatic refund for any unfulfilled items. Upon payment completion you'll want to display an animation in the UI indicating that the delivery is in-progress. Then poll the GET order API to check on delivery status and update your application UI when delivery status is updated.

<Note>
  You can use client-side or server-side API keys to implement headless checkout. Check the code samples for the type
  of API key you're using in your application.
</Note>

<Check>We recommend a polling interval of about 2500ms and never below 500ms.</Check>

<Tabs>
  <Tab title="Client Side">
    ```tsx theme={null}
    const getOrderDeliveryStatus = async () => {
        const apiUrl = "https://staging.crossmint.com/api/2022-06-09";
        try {
            const res = await fetch(`${apiUrl}/orders/${order.orderId}`, {
                method: "GET",
                headers: {
                    "Content-Type": "application/json",
                    "x-api-key": process.env.NEXT_PUBLIC_CROSSMINT_API_KEY,
                    authorization: clientSecret, // saved from response of create order call
                },
            });

            const refreshedOrder = await res.json();

            setOrder(refreshedOrder);

            return refreshedOrder.lineItems[0].delivery.status;
        } catch (e) {
            console.error(e);
            throw new Error("Failed to fetch order");
        }
    };

    const pollDeliveryStatus = async () => {
        const intervalId = setInterval(async () => {
            try {
                const status = await getOrderDeliveryStatus();
                console.log("delivery status: ", status);
                if (status === "completed") {
                    clearInterval(intervalId);
                }
            } catch (e) {
                clearInterval(intervalId);
                console.error("Error polling delivery status: ", e);
            }
        }, 2500);

        // Set a timeout to stop polling after 60 seconds
        setTimeout(() => {
            clearInterval(intervalId);
            console.log("Taking longer than expected...");
        }, 60000);
    };
    ```
  </Tab>

  <Tab title="Server Side">
    <Note>
      The sample code below is from a NextJS application. The `component.tsx` file is simplified to only show the relevant
      logic. The client-side component sends an API request to the application's backend, which then proxies the request
      to Crossmint. This is because the example is using a server-side API key, which requires making requests from a
      server environment.
    </Note>

    <CodeGroup>
      ```tsx component.tsx (client-side) theme={null}
      const getOrderDeliveryStatus = async () => {
          try {
              const res = await fetch(`/orders/${order.orderId}`, {
                  method: "GET",
                  headers: {
                      "Content-Type": "application/json",
                  },
              });

              const refreshedOrder = await res.json();

              setOrder(refreshedOrder);

              return refreshedOrder.lineItems[0].delivery.status;
          } catch (e) {
              console.error(e);
              throw new Error("Failed to fetch order");
          }
      };

      const pollDeliveryStatus = async () => {
          const intervalId = setInterval(async () => {
              const status = await getOrderDeliveryStatus();
              console.log("delivery status: ", status);
              if (status === "completed") {
                  clearInterval(intervalId);
              }
          }, 2500);

          // Set a timeout to stop polling after 60 seconds
          setTimeout(() => {
              clearInterval(intervalId);
              console.log("Taking longer than expected...");
          }, 60000);
      };
      ```

      ```typescript route.ts (server-side) theme={null}
      import { callCrossmintAPI } from "@/app/utils/crossmint";
      import { NextRequest, NextResponse } from "next/server";

      export async function GET(req: NextRequest, { params }: { params: { orderId: string } }) {
          if (params.orderId) {
              const order = await callCrossmintAPI(`/orders/${params.orderId}`, {
                  method: "GET",
              });

              return NextResponse.json(order, { status: 200 });
          } else {
              return NextResponse.json({ error: true, message: "Missing orderId" }, { status: 400 });
          }
      }
      ```

      ```typescript crossmint.ts theme={null}
      const crossmintBaseUrl = process.env.CROSSMINT_API_URL;

      const crossmintAPIHeaders = {
          accept: "application/json",
          "content-type": "application/json",
          "x-api-key": process.env.CROSSMINT_API_KEY!,
      };

      const callCrossmintAPI = async (endpoint: string, options: { method: string; body?: any; params?: any }) => {
          const url = `${crossmintBaseUrl}/${endpoint}`;
          const { body, method } = options;

          const response = await fetch(url, {
              body: body ? JSON.stringify(body) : null,
              method,
              headers: crossmintAPIHeaders,
          });
          const json = await response.json();
          return json;
      };

      export { callCrossmintAPI };
      ```
    </CodeGroup>
  </Tab>
</Tabs>

### Error Handling

Once the payment has been confirmed, delivery is likely to complete successfully. Before accepting the payment Crossmint simulates the expected transaction, which means that most delivery issues will be prevented before payment is even accepted. Given a successful payment the delivery process will be retried until it completes successfully or determines that delivery is impossible.

The most common cause for a delivery failure is that the item is no longer available. In the case of primary sales this could mean that the collection is sold out. For secondary sales the reason could be that someone else bought the item first.

Your application should be aware of the potential for delivery to fail and provide information to the buyer on what to expect. In the case of multiple items purchased and partial delivery failure you'll need to indicate which items were successfully delivered and which items failed.

<Note>
  Be sure to let your buyer know that in the case of a failed delivery they will be refunded automatically. If they
  have any questions or issues they can reach out to Crossmint support directly for assistance.
</Note>

A receipt will be sent to the buyer as long as their email was included in the order. There are two ways to pass this information. If the recipient is set to an email address, it will be used to send the receipt. In the case that the recipient is set to a `walletAddress` you can include an optional `receiptEmail` property within the payment object.

<CodeGroup>
  ```json Crypto Payment theme={null}
  {
      "payment": {
          "method": "base-sepolia",
          "currency": "eth",
          "payerAddress": "0xabcd1234...",
          "receiptEmail": "user@example.com"
      },
      "recipient": {
          "walletAddress": "0xabcd1234..."
      }
  }
  ```

  ```json Credit Card Payment theme={null}
  {
      "payment": {
          "method": "card",
          "receiptEmail": "user@example.com"
      },
      "recipient": {
          "email": "user@example.com"
      }
  }
  ```
</CodeGroup>


# Quote Phase
Source: https://docs.crossmint.com/payments/headless/guides/order-lifecycle/quote-phase

Initial phase of the order lifecycle

The first phase of the headless checkout process is the quote phase. During this phase, you construct an order that consists of the items being purchased, payment method, locale, and recipient. This will ultimately yield a quote to purchase it.

<Note>It's possible for an order to go from the payment phase back to the quote phase if the quote expires.</Note>

You can initialize an order such that the quote phase is completed in a single API call. Alternatively, you can create a basic order and iteratively update it with locale, recipient, and payment method information. The only information you cannot edit on a quote is the `lineItems` array, which indicate the details of what is being purchased.

<Check>If you need to alter the `lineItems` in an order you must create a new order.</Check>

## Quote status overview

During the quote phase, statuses indicate whether the order has enough information to proceed (like a recipient), and whether the quote is still valid. For the full, authoritative list of quote statuses, see the Status Codes page.

See the full list: [Status Codes](/payments/headless/guides/status-codes).

## Creating the Order

You will create the order via API call. The headless checkout offers support for both client-side or server-side API keys to enable you to build in a way that makes sense for your application.

<Note>
  Orders can be created using a client-side API key, but any subsequent fetches or updates will require passing the
  `clientSecret` returned in the create-order API response as an `authorization` header. This guide is written with
  the expectation of using a server-side API key.
</Note>

<Note>
  For more information on using Crossmint APIs refer to [API keys](/introduction/platform/api-keys) documentation
  page.
</Note>

To create a minimal order, make a `POST` request to the `/api/2022-06-09/orders` endpoint (view [API reference](/api-reference/headless/create-order)). The required properties to create an order are: `payment` and `lineItems`.

<CodeGroup>
  ```json Crypto Payment theme={null}
  {
      "payment": {
          "method": "base-sepolia",
          "currency": "eth",
          "payerAddress": "0x1234abcd..." // optional to create order, but required to proceed to payment phase
      },
      "lineItems": [
          {
              "collectionLocator": "crossmint:_YOUR_COLLECTION_ID_",
              "callData": {
                  "totalPrice": "0.0001"
              }
          }
      ]
  }
  ```

  ```json Credit Card Payment theme={null}
  {
      "payment": {
          "method": "card",
          "receiptEmail": "your-email@example.com"
      },
      "lineItems": [
          {
              "collectionLocator": "crossmint:_YOUR_COLLECTION_ID_",
              "callData": {
                  "totalPrice": "0.0001"
              }
          }
      ]
  }
  ```
</CodeGroup>

The `payment` object indicates the method and currency you intend to make the payment with. For crypto payments, this can be the same chain of the NFT or another chain that the buyer has liquidity on.

For example, buying an NFT on `BASE` chain with `BASE` `ETH`, buying an NFT on Solana with `SOL`, or any cross-chain combination of a [supported chain](/introduction/supported-chains) and currency.

The `payment.method` value for credit card checkouts should be `card` and the `payment.currency` any of the [supported fiat currencies](/payments/headless/guides/localization#currencies-and-languages-available).

The `lineItems` array describes the NFTs being purchased.

#### Collection Locator

The `collectionLocator` within `lineItems` is how you specify the collection within Crossmint.
For primary sales where the NFTs are being minted for the first time, the contract will need to be registered in the Crossmint console.
You can find your `collectionId` within the Token collections tab in the developer console.

#### Token Locator

Alternatively, if this is a secondary sale, and your token is already minted and available on a supported marketplace, you can use a `tokenLocator`, instead of a `collectionLocator`.
***Using a token locator means you do not need to register the collection in the Crossmint console.***

The `tokenLocator` for EVM Chains follows the format `blockchain:contractAddress:tokenId` and for Solana follows the format `blockchain:tokenAddress`.

More information on the `tokenLocator` format can be found in the [marketplaces and launchpads guide](/payments/advanced/marketplaces-and-launchpads).

<Check>
  Remember, you can [view orders within the Developer
  Console](/payments/advanced/testing-tips#reviewing-orders-in-the-developer-console) to help get insight into the
  order process during testing and even after launch.
</Check>

## Updating the Order

All orders require a recipient to progress to the payment phase. You can also optionally add a specific locale, which is used to indicate the language for the email receipt sent to the buyer.

The primary reason you'll update an existing order is when the buyer changes the payment method or currency they'd like to pay with in the UI that you build. To update the order, make a `PATCH` request to the `/api/2022-06-09/orders/<orderId>` endpoint to make these changes and receive a response with updated payment details. View [API reference here](/api-reference/headless/edit-order).

You can update all of these fields at the same time or individually depending on what makes the most sense for your use case.

### Update the Recipient

First, take a look at how to add the recipient to an existing order. The `requires-recipient` state occurs when you initialize a minimal order and do not include a recipient value. Valid options for the recipient property are `email` or `walletAddress`.

When you set an email recipient, the token will be minted to a Crossmint custodial wallet that can be accessed via [www.crossmint.com](https://www.crossmint.com/) (or [staging.crossmint.com](https://staging.crossmint.com) during testing).

You can update the recipient for an existing order as follows:

`PATCH` `/api/2022-06-09/orders/<orderId>`

```json theme={null}
{
    "recipient": {
        "email": "buyer@example.com"
    }
}
```

OR

```json theme={null}
{
    "recipient": {
        "walletAddress": "0x1234abcd…"
    }
}
```

<Warning>
  The wallet address **must** be compatible with the chain the NFT is on. For example, a Solana NFT requires a Solana
  wallet address and an NFT on an EVM chain requires a compatible EVM wallet address.
</Warning>

### Update Chain and/or Currency

To change details about how the buyer will pay for the NFTs you use the same API route as above and pass a new payment object.

<CodeGroup>
  ```json Crypto Payment theme={null}
  {
      "payment": {
          "method": "ethereum-sepolia",
          "currency": "usdc",
          "payerAddress": "0x1234abcd..."
      }
  }
  ```

  ```json Credit Card Payment theme={null}
  {
      "payment": {
          "method": "card",
          "receiptEmail": "your-email@example.com"
      }
  }
  ```
</CodeGroup>

This will return a new response that can be used to prompt the buyer to complete the crypto payment.

<Note>
  Anytime you update the order you must ensure you use the newly returned `payment.preparation` property to proceed
  with the payment process.
</Note>

### Update the Locale

As mentioned above, the `locale` is used to set the language and currency for the email receipt sent to your buyer. The default is `en-US`.

Below is an example of the body you'd pass to update the locale setting:

```json theme={null}
{
    "locale": "es-ES"
}
```

The available locale values are:

`en-US`, `de-DE`, `es-ES`, `fr-FR`, `it-IT`, `ja-JP`, `ko-KR`, `pt-PT`, `ru-RU` `th-TH` `tr-TR` `uk-UA` `vi-VN` `zh-CN` `zh-TW`, `Klingon`

## Quote Expiration

The time before expiration depends on the payment method chosen. Check the `quote.expiresAt` property to determine how long the quote is valid for. Additionally, the `quote.status` property will be set to `expired` if this timeframe is exceeded.

If your quote has expired you'll need to create a new order.


# Payment Methods
Source: https://docs.crossmint.com/payments/headless/guides/payment-methods

Understand the supported payment methods and how to implement them

## Cross-Chain + Crypto Payments

You can easily create or update an order to receive a price quote, enabling your user to pay with crypto they have on the same chain or even liquidity they have on other chains.

There are several considerations you need to keep in mind when building your app to support cross-chain payments. Some recommendations include the following:

* How to test the process out in staging/testnet and then move to production/mainnet
* Filtering down the list of tokens for which the connected wallet has enough balance to cover the purchase
* Ensuring the wallet is set to the same network as the selected payment chain

Refer to the [Order Lifecycle](/payments/headless/guides/order-lifecycle/quote-phase) docs for details about creating and updating orders based on user selections.

<Check>
  For a full list of supported crypto currencies, refer to the [supported
  currencies](/payments/headless/guides/supported-currencies) page.
</Check>

You'll need to build out a UI that enables your buyer to select from the supported currencies, and then update the existing order upon any changes.

<Note>Code example(s) coming soon!</Note>

## Credit Card Payments

The option of accepting credit card payments via headless checkout is also available. For detailed examples of creating and updating orders, refer to the [Order Lifecycle](/payments/headless/guides/order-lifecycle/quote-phase) docs.

### Test Price Limits and Test Credit Cards

When building your applications using the staging environment, you can use various test credit cards numbers to see the entire process end-to-end, without actually having to transact using a real credit card.
Check out the Testing Tips page for more info on [price limits](/payments/advanced/testing-tips#limits-in-staging) and [test card numbers](/payments/advanced/testing-tips#test-credit-card-numbers).


# Physical Product Purchases
Source: https://docs.crossmint.com/payments/headless/guides/physical-good-purchases

How to purchase physical products with crypto using Headless Checkout

Crossmint's Headless Checkout now supports purchasing physical products using a wallet's crypto balance through the `productLocator` parameter. This guide explains how to integrate physical product purchases and handle shipping requirements.

## Physical Address Requirement

When purchasing physical products, a shipping address is required (currently only US addresses are supported). You can provide this in two ways:

### 1. Include Address During Order Creation

```json theme={null}
POST /api/2022-06-09/orders
{
    "recipient": {
        "email": "buyer@example.com",
        "physicalAddress": {
            "name": "John Doe", // required
            "line1": "123 Main St", // required
            "line2": "Apt 4B", // optional
            "city": "San Francisco", // required
            "state": "CA", // required for US addresses
            "postalCode": "94105", // required
            "country": "US" // required - only US is currently supported
        }
    }
}
```

### 2. Update Address After Order Creation

If you create an order without specifying a `physicalAddress`, the quote cannot proceed until a valid shipping address is provided. See the full list of statuses on the <a href="/payments/headless/guides/status-codes">Status Codes</a> page.

To resolve this, update the order with the physical address:

```json theme={null}
PATCH /api/2022-06-09/orders/{orderId}
{
  "recipient": {
    "physicalAddress": {
      "name": "John Doe",      // required
      "line1": "123 Main St",  // required
      "line2": "Apt 4B",       // optional
      "city": "San Francisco", // required
      "state": "CA",           // required for US addresses
      "postalCode": "94105",   // required
      "country": "US"          // required - only US is currently supported
    }
  }
}
```

After providing the physical address, the order status will update and include the necessary `payment.preparation` parameters to proceed with payment.

## Order Status Handling

When purchasing physical products, provide a shipping address up front or update the order after creation. Until a valid address is present, the order cannot proceed to payment preparation. For the complete, authoritative list of statuses and their meanings, see the <a href="/payments/headless/guides/status-codes">Status Codes</a> page.

## Supported Providers

### Amazon

Amazon products can be purchased using either their ASIN or product URL. See the [Amazon Integration Guide](/payments/headless/guides/providers/amazon) for details.

### Shopify

Shopify products can be purchased using the product URL and variant ID. See the [Shopify Integration Guide](/payments/headless/guides/providers/shopify) for details.


# Order Errors
Source: https://docs.crossmint.com/payments/headless/guides/physical-product-order-errors

Common reasons why physical product orders may fail and how to resolve them

When purchasing physical products through Crossmint, your order may fail for various reasons. This guide explains the most common restrictions and requirements for different providers.

## Amazon

Amazon orders through Crossmint have specific requirements that must be met for successful processing. If your Amazon order fails, it may be due to one of the following restrictions:

### 1. Item must be sold by Amazon or a verified third-party seller

Only products sold directly by Amazon or through verified third-party sellers on the Amazon marketplace are supported. Items from unverified sellers or those with questionable seller ratings may be rejected.

### 2. Item must have standard shipping options available

The product must support standard shipping methods. Items that require special shipping arrangements, expedited delivery only, or have shipping restrictions may not be available for purchase.

### 3. Item must be a physical product (not digital goods or services)

Only physical products that can be shipped are supported. The following types of items are **not supported**:

* Digital downloads (software, music, ebooks)
* Digital gift cards
* Services or subscriptions
* Virtual products

### 4. Item must not be from specialty Amazon programs

Products from the following Amazon specialty programs are **not supported**:

* **Amazon Fresh** - Fresh grocery delivery service
* **Amazon Pantry** - Bulk household items program
* **Amazon Pharmacy** - Prescription medications and health products
* **Subscribe & Save** - Subscription-only items that require recurring delivery

## Need Help?

If you continue to experience issues after checking these requirements, please [contact support](https://portal.usepylon.com/crossmint/forms/contact-support) with:

* The specific product URL or identifier you're trying to purchase
* The complete error message you received
* Your shipping address details (city, state, country)

This information will help us quickly identify and resolve the issue with your order.


# Plan Your Solution
Source: https://docs.crossmint.com/payments/headless/guides/plan-your-solution

Detailed integration guide to build out a fully custom digital asset checkout experience

The Headless Checkout suite of APIs offers the most sophisticated tooling available to build fully custom experiences for your users. This guide will walk you through the entire integration process in a logical order. The first step is to take a few minutes to plan out your solution.

## Client or Server Approach

Depending on how your application is architected, you may want to use server-side or client-side API keys. Check out the [client or server guide](/payments/headless/guides/client-or-server) for more info.

## Decide on Payment Methods

The Headless Checkout supports cross-chain crypto payments and credit cards. Decide if you want to enable both credit card and crypto payments, and which cross-chain tokens should be available.

### Cross-Chain Payments

Enable your users to pay for digital assets directly with crypto or with liquidity they have available on other chains by leveraging the cross-chain payments support.

Check the [cross-chain payments](/payments/headless/guides/payment-methods#cross-chain-payments) section for more in-depth guidance.

### Credit Card Payments

You can also use headless checkout to initiate credit card orders for your buyers.

Check the [credit card payments](/payments/headless/guides/payment-methods#credit-card-payments) section for more in-depth guidance.

## Staging or Production

In most cases, it makes sense to start the integration process in the staging environment where all features are available and free to try. You can find more information about [Staging and Production environments here](/introduction/platform/staging-vs-production).

<Check>
  Headless checkout requires enablement by the Customer Success Engineering team in production. [Contact
  Sales](https://www.crossmint.com/contact/sales) if your don't already have a CSE assigned.
</Check>

## Create or Import Your Collection in the Console

For NFTs, you will need to have a collection that your users can purchase NFTs from. You can deploy a collection directly from the Crossmint Developer Console or import a contract you've deployed elsewhere. Check these guides for more details on creating or importing collections.

* [Create a Collection](/payments/guides/create-collection)
* [Import a Collection](/payments/guides/register-collection)

Once you have a collection created or imported, you'll have a `collectionId`, which is necessary to create orders.

## Create Your API Key

With the above steps completed, you're ready to create an API key to use for your project.

1. Login to the developer console where your collection was created in the previous step
2. If you're on the collection detail view, navigate back to the home page of the console
   <Frame type="simple">
     <img alt="how to get back to home page" />
   </Frame>
3. Click the "Integrate" tab and select the "API Keys" section on top

Before creating an API key, you'll need to decide on server-side vs client-side implementation. You can find some more info in the [Client or Server Guide](/payments/headless/guides/client-or-server).

## Next Steps

You're ready to move on to implementing the Headless Checkout in your application!


# Production Launch
Source: https://docs.crossmint.com/payments/headless/guides/production-launch

Follow this checklist to ensure you are ready for production launch with Headless Checkout

## From Staging to Production with Headless Checkout

<Check>
  Headless checkout in production requires enablement by the Customer Success Engineering team. [Contact Crossmint's
  team](https://www.crossmint.com/contact/sales) to get access.
</Check>

<Snippet />

***

### Launch Checklist

1. Change all environment URLs from `staging.crossmint.com/api/2022-06-09` to `www.crossmint.com/api/2022-06-09`.
2. Change your API keys to the production versions. *Ensure your production API key has the appropriate scopes enabled, such as `orders.create`, and that all authorized domains and mobile bundle identifiers are properly configured.*
3. Update your collection ID to the production one.
4. As needed, change your passed-in props to be production ready (e.g. email, `payment`, `lineItems`).

<Accordion title="See Code Example">
  <CodeGroup>
    ```javascript {2,6,20} Production theme={null}
    // Using the REST API
    fetch("https://www.crossmint.com/api/2022-06-09/orders", {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-api-key": "YOUR_PROD_API_KEY"
      },
      body: JSON.stringify({
        "recipient": {
          "email": "steve@gmail.com"
        },
        "locale": "en-US",
        "payment": {
          "receiptEmail": "steve@gmail.com",
          "method": "ethereum",
          "currency": "eth",
          "payerAddress": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e"
        },
        "lineItems": [
          {
            "collectionLocator": "crossmint:YOUR_PROD_COLLECTION_ID",
            "callData": {
              "totalPrice": "0.25",
              "quantity": 1
            }
          }
        ]
      })
    });
    ```

    ```javascript {2,6,20} Staging theme={null}
    // Using the REST API
    fetch("https://staging.crossmint.com/api/2022-06-09/orders", {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-api-key": "YOUR_STAGING_API_KEY"
      },
      body: JSON.stringify({
        "recipient": {
          "email": "test@crossmint.com"
        },
        "locale": "en-US",
        "payment": {
          "receiptEmail": "test@crossmint.com",
          "method": "ethereum-sepolia",
          "currency": "eth",
          "payerAddress": "0x1234_payer_address"
        },
        "lineItems": [
          {
            "collectionLocator": "crossmint:YOUR_STAGING_COLLECTION_ID",
            "callData": {
              "totalPrice": "0.001",
              "quantity": 1
            }
          }
        ]
      })
    });
    ```
  </CodeGroup>
</Accordion>


# Amazon Integration
Source: https://docs.crossmint.com/payments/headless/guides/providers/amazon

How to enable crypto purchases of Amazon products using Headless Checkout

This guide explains how to integrate Amazon product purchases using the Headless Checkout API.

## Product Locator Format

When creating an order for an Amazon product, use the `productLocator` parameter with either the Amazon ASIN or product URL:

```json theme={null}
// Amazon ASIN
{
    "lineItems": [
        {
            "productLocator": "amazon:B01DFKC2SO"
        }
    ]
}

// Amazon Product URL
{
    "lineItems": [
        {
            "productLocator": "amazon:https://www.amazon.com/dp/B01DFKC2SO"
        }
    ]
}
```

## Example Flow

<Steps>
  <Step title="Create the order">
    * Specify the receipient's email
    * Specify their shipping information
    * Specify the payment method used
    * Specify the product locator

    <Check>
      For a full list of supported currencies, refer to the [supported
      currencies](/payments/headless/guides/supported-currencies) page.
    </Check>

    ```json theme={null}
    POST /api/2022-06-09/orders
    {
      "recipient": {
        "email": "buyer@example.com",
        "physicalAddress": {
          "name": "John Doe",      // required
          "line1": "123 Main St",  // required
          "city": "San Francisco", // required
          "state": "CA",           // required for US addresses
          "postalCode": "94105",   // required
          "country": "US"          // required - only US is currently supported
        }
      },
      "payment": {
        "method": "ethereum-sepolia",
        "currency": "eth"
      },
      "lineItems": [
        {
          "productLocator": "amazon:B01DFKC2SO"
        }
      ]
    }
    ```
  </Step>

  <Step title="Check order status">
    With all requied information provided, the order's response will include payment preparation details, as shown below.

    ```json theme={null}
    {
        "order": {
            "orderId": "...",
            "quote": {
                "status": "valid",
                ...
            },
            "payment": {
                "preparation": {
                    ...  // Payment details will be present here
                }
            }
        }
    }
    ```
  </Step>
</Steps>

## Additional Information

* Monitor order statuses through the [Developer Console](https://www.crossmint.com/console)
* Review the [Order Lifecycle guide](/payments/headless/guides/order-lifecycle/quote-phase) for detailed status handling
* Check [this guide](/payments/headless/guides/payment-methods) for details on supported currencies and payment methods


# Shopify Integration
Source: https://docs.crossmint.com/payments/headless/guides/providers/shopify

How to enable crypto purchases of Shopify products using Headless Checkout

This guide explains how to integrate Shopify product purchases using the Headless Checkout API.

## Product Locator Format

When creating an order for a Shopify product, use the `productLocator` parameter with the Shopify product URL and variant ID:

```json theme={null}
{
    "lineItems": [
        {
            "productLocator": "shopify:https://www.gymshark.com/products/gymshark-arrival-5-shorts-black-ss22:39786362601674"
        }
    ]
}
```

The format for the product locator is `shopify:<product-url>:<variant-id>`, where:

* `shopify:` is the prefix identifying this as a Shopify product
* `<product-url>` is the full URL to the product page
* `<variant-id>` is the unique variant ID for the specific product option (size, color, etc.)

## Example Flow

<Steps>
  <Step title="Create the order">
    * Specify the recipient's email
    * Specify their shipping information
    * Specify the payment method used
    * Specify the product locator

    <Check>
      For a full list of supported currencies, refer to the [supported
      currencies](/payments/headless/guides/supported-currencies) page.
    </Check>

    ```json theme={null}
    POST /api/2022-06-09/orders
    {
      "recipient": {
        "email": "buyer@example.com",
        "physicalAddress": {
          "name": "John Doe",      // required
          "line1": "123 Main St",  // required
          "city": "San Francisco", // required
          "state": "CA",           // required for US addresses
          "postalCode": "94105",   // required
          "country": "US"          // required - only US is currently supported
        }
      },
      "payment": {
        "method": "ethereum-sepolia",
        "currency": "eth"
      },
      "lineItems": [
        {
          "productLocator": "shopify:https://www.gymshark.com/products/gymshark-arrival-5-shorts-black-ss22:39786362601674"
        }
      ]
    }
    ```
  </Step>

  <Step title="Check order status">
    With all required information provided, the order's response will include payment preparation details, as shown below.

    ```json theme={null}
    {
        "order": {
            "orderId": "...",
            "quote": {
                "status": "valid",
                ...
            },
            "payment": {
                "preparation": {
                    ...  // Payment details will be present here
                }
            }
        }
    }
    ```
  </Step>
</Steps>

## Additional Information

* Monitor order statuses through the [Developer Console](https://www.crossmint.com/console)
* Review the [Order Lifecycle guide](/payments/headless/guides/order-lifecycle/quote-phase) for detailed status handling
* Check [this guide](/payments/headless/guides/payment-methods) for details on supported currencies and payment methods
* **Note:** Delivery destinations are limited to regions supported by the Shopify store itself. The ability to ship to a specific address depends on the merchant's shipping configuration.


# Specify Recipient
Source: https://docs.crossmint.com/payments/headless/guides/specify-recipient

Select where purchased items should be delivered in Headless Checkout

<Snippet />

## Specifying the Recipient

For Headless Checkout, you specify the recipient when creating or updating an order.

### Recipient by Email

When specifying a recipient by email, Crossmint will automatically create a secure custodial wallet on the fly for that email address:

<Tabs>
  <Tab title="Create Order">
    ```json {4} theme={null}
    POST /api/2022-06-09/orders
    {
      "recipient": {
        "email": "user@example.com" // Email address of the recipient
      },
      "locale": "en-US",
      "payment": {
        "method": "ethereum-sepolia",
        "currency": "eth",
        "payerAddress": "0x1234abcd...",
        "receiptEmail": "user@example.com"
      },
      "lineItems": [
        {
          "collectionLocator": "crossmint:cosdahdasda",
          "callData": {
            "totalPrice": "0.0001",
            "quantity": 1
          }
        }
      ]
    }
    ```
  </Tab>

  <Tab title="Edit Order">
    ```json {4} theme={null}
    PATCH /api/2022-06-09/orders/{orderId}
    {
      "recipient": {
        "email": "user@example.com" // Email address of the recipient
      }
    }
    ```
  </Tab>
</Tabs>

The recipient will be able to access their purchased items by logging into their Crossmint wallet in [staging](https://staging.crossmint.com/user/collection) or [mainnet](https://www.crossmint.com/user/collection).

### Recipient by Wallet Address

To deliver items directly to a specific blockchain wallet address:

<Tabs>
  <Tab title="Create Order">
    <CodeGroup>
      ```json {4} EVM theme={null}
      POST /api/2022-06-09/orders
      {
        "recipient": {
          "walletAddress": "0x1234567890abcdef1234567890abcdef12345678" // For EVM chains
        },
        "locale": "en-US",
        "payment": {
          "method": "ethereum-sepolia",
          "currency": "eth",
          "payerAddress": "0x1234abcd...",
          "receiptEmail": "user@example.com" // Required when using wallet address
        },
        "lineItems": [
          {
            "collectionLocator": "crossmint:_YOUR_EVM_COLLECTION_",
            "callData": {
              "totalPrice": "0.0001",
              "quantity": 1
            }
          }
        ]
      }
      ```

      ```json {4} Solana theme={null}
      POST /api/2022-06-09/orders
      {
        "recipient": {
          "walletAddress": "5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty" // For Solana
        },
        "locale": "en-US",
        "payment": {
          "method": "solana",
          "currency": "sol",
          "payerAddress": "5FHne...",
          "receiptEmail": "user@example.com" // Required when using wallet address
        },
        "lineItems": [
          {
            "collectionLocator": "crossmint:_YOUR_SOLANA_COLLECTION_",
            "callData": {
              "totalPrice": "0.0001",
              "quantity": 1
            }
          }
        ]
      }
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Edit Order">
    <CodeGroup>
      ```json {4} EVM theme={null}
      PATCH /api/2022-06-09/orders/{orderId}
      {
        "recipient": {
          "walletAddress": "0x1234567890abcdef1234567890abcdef12345678" // For EVM chains
        }
      }
      ```

      ```json {4} Solana theme={null}
      PATCH /api/2022-06-09/orders/{orderId}
      {
        "recipient": {
          "walletAddress": "5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty" // For Solana
        }
      }
      ```
    </CodeGroup>
  </Tab>
</Tabs>

<Note>
  If specifying a recipient by wallet address, ensure the address is valid for the chain your collection is on, which
  may differ from the chain the payment is performed on.
</Note>

### Physical Product Recipients

<Snippet />

When purchasing physical products, providing a physical address is required. If you don't provide it in the initial order, you can update the order it later:

<Tabs>
  <Tab title="Create Order">
    ```json {5-13, 20} theme={null}
    POST /api/2022-06-09/orders
    {
      "recipient": {
        "email": "buyer@example.com", // Email address of the recipient
        "physicalAddress": {
          "name": "John Doe",
          "line1": "123 Main St",
          "line2": "Apt 4B", // optional
          "city": "San Francisco",
          "state": "CA",
          "postalCode": "94105",
          "country": "US"
        }
      },
      "locale": "en-US",
      "payment": {
        "method": "ethereum-sepolia",
        "currency": "eth",
        "payerAddress": "0x1234abcd...",
        "receiptEmail": "buyer@example.com" // Required for physical products
      },
      "lineItems": [
        {
          "collectionLocator": "crossmint:cosdahdasda",
          "callData": {
            "totalPrice": "0.0001",
            "quantity": 1
          }
        }
      ]
    }
    ```
  </Tab>

  <Tab title="Edit Order">
    ```json {4-12} theme={null}
    PATCH /api/2022-06-09/orders/{orderId}
    {
      "recipient": {
        "physicalAddress": {
          "name": "John Doe",
          "line1": "123 Main St",
          "line2": "Apt 4B", // optional
          "city": "San Francisco",
          "state": "CA",
          "postalCode": "94105",
          "country": "US"
        }
      }
    }
    ```
  </Tab>
</Tabs>

<Note>
  If you create an order with a physical product without specifying a `physicalAddress`, the quote cannot proceed
  until a physical address is provided. After providing the physical address, the order status will update and include
  the necessary `payment.preparation` parameters to proceed with payment. See the full list of statuses on the
  <a href="/payments/headless/guides/status-codes">Status Codes</a> page and learn more about payment preparation in the
  <a href="/payments/headless/guides/order-lifecycle/crypto-payment-phase">payment phase documentation</a>.
</Note>


# Status Codes
Source: https://docs.crossmint.com/payments/headless/guides/status-codes

Guide to understanding the status codes returned from the Headless Checkout APIs

Crossmint's headless checkout includes status codes for multiple aspects of the checkout process. Using status codes lets you build detailed user experiences and UIs that inform about the status of the payment process and delivery of their purchase.

There is the top level `order.phase` and then there are sub-statuses for `quote`, `payment`, and `delivery`.

## Quote statuses

* `item-unavailable` — No items in the order are available for purchase at the current time
* `valid` — The quote is valid
* `expired` — The quote has expired and needs to be refreshed
* `requires-recipient` — The order is missing recipient information (email or wallet address)

## Payment statuses

* `requires-quote` — The order is still in the quote phase
* `requires-crypto-payer-address` — A crypto wallet address needs to be provided for the payment
* `requires-email` — An email is required to proceed (typically for card payments or receipts)
* `requires-kyc` — The buyer must complete KYC verification to proceed
* `manual-kyc` — KYC requires manual review; the buyer will be notified of the outcome
* `failed-kyc` — KYC verification failed and the buyer cannot proceed
* `crypto-payer-insufficient-funds` — The specified payer address cannot cover the purchase
* `crypto-payer-insufficient-funds-for-gas` — The payer address cannot cover the required network fees
* `awaiting-payment` — Ready to submit the payment
* `in-progress` — Payment processing is underway
* `completed` — Payment completed; the order proceeds to delivery/completion

## Delivery statuses

* `awaiting-payment` — Delivery not started because payment is not yet complete
* `in-progress` — Delivery is being processed
* `failed` — Delivery failed; affected items will be refunded automatically
* `completed` — Delivery completed successfully


# Supporting Your Customers
Source: https://docs.crossmint.com/payments/headless/guides/supporting-your-customers

Support your customers facing issues with the checkout process

As an enterprise working with Crossmint, you receive priority customer support. Consequently, customer issues can be escalated to the Crossmint team.

## Information to pass onto Crossmint

When escalating customer issues to the Crossmint team, please ensure to pass on the following details, as it makes troubleshooting easier:

* **Email Address**: The email address they are using to purchase the digital asset.
* **Website URL**: The URL of the website they are trying to purchase the digital asset from.
* **Order Id**: The Order Id of the initiated payment.
* **Collection Id**: The Collection Id of the collection on Crossmint.
* **Project Id**: The Project Id of the project on Crossmint.

## Additional items to check

* You can review the **Orders tab** to check the status of the checkout.
* If you are the dev reporting the error, please share the sample code as well.

<Tip>
  If nothing works and you are unable to troubleshoot the issue, you can redirect them to Crossmint's support
  [here](https://help.crossmint.com/hc/en-us/requests/new/?utm_source=docs).
</Tip>


# Overview
Source: https://docs.crossmint.com/payments/headless/overview

Create fully custom checkout experiences

For general information about Crossmint's Payments product, see the [introduction](/payments/introduction). This guide will focus on the features specific to the headless checkout.

## When is the Headless Checkout the best fit?

* **You want to build the entire user experience**
* **You want to use Crossmint checkout outside of a browser environment** (e.g. native mobile app, game, VR headset, etc.)
* **You are okay spending more time developing your own UX**

## Introduction

Crossmint's headless checkout API is a set of REST APIs that allow you to integrate credit card and cross-chain crypto payments inside your app with full control of the user experience.

It is the most customizable version of the Crossmint suite of payments products, which allows anyone to buy digital assets with familiar payment methods (credit card, crypto on any chain independent on where the asset lives) with the same backend, but allowing full UI customizability and deep integration with your app's UX.

<Tabs>
  <Tab title="In-app purchases">
    <Frame type="simple">
      <img alt="In-app purchases example" />
    </Frame>
  </Tab>

  <Tab title="Ticketing solutions">
    <Frame type="simple">
      <img alt="Ticketing solutions example" />
    </Frame>
  </Tab>

  <Tab title="Custom web3app UIs">
    <Frame type="simple">
      <img alt="Custom web3app UI example" />
    </Frame>
  </Tab>

  <Tab title="and many more...">
    <div>Wherever your imagination takes you...</div>
  </Tab>
</Tabs>

## Get Started

<CardGroup>
  <Card title="Pay with Crypto Quickstart" icon="hive" href="/payments/headless/quickstarts/crypto">
    Build a custom Pay with Crypto checkout experience for your digital assets
  </Card>

  <Card title="Pay with Card - NFT - Quickstart" icon="bolt" href="/payments/headless/quickstarts/credit-card-nft">
    Build a custom credit-card checkout experience
  </Card>

  <Card title="Pay with USDC Quickstart" icon="circle-dollar" href="/payments/headless/quickstarts/paying-usdc">
    Build a USDC checkout in 5 minutes (great for AI agents)
  </Card>

  <Card title="Pay for Card - Memecoins - Quickstart" icon="coin-front" href="/payments/headless/quickstarts/credit-card-memecoin-cko">
    Sell memecoins quickly with a credit card checkout
  </Card>
</CardGroup>

<Card title="Talk to an expert" icon="message" href="https://www.crossmint.com/contact/sales">
  Contact our sales team for advanced support.
</Card>

## Advanced Topics

<CardGroup>
  <Card title="Marketplaces & Launchpads" icon="cart-shopping" href="/payments/advanced/marketplaces-and-launchpads" />

  <Card title="Headless Status Codes" icon="temperature-empty" href="/payments/headless/guides/status-codes" />

  <Card title="Bring your own Collection" icon="file-import" href="/payments/guides/register-collection" />

  <Card title="Webhooks" icon="bars-progress" href="/payments/advanced/webhooks" />
</CardGroup>


# Pay with Card - Memecoins
Source: https://docs.crossmint.com/payments/headless/quickstarts/credit-card-memecoin-cko

Create a fully customized memecoin checkout experience that accepts credit cards

<Snippet />

## Introduction

This guide will show you how to accept credit card payments using Crossmint's Headless Checkout API for memecoin sales. You'll learn how to:

* Set up credit card payments for Solana memecoin purchases in JavaScript
* Implement a checkout UI
* Track order status and delivery

<Tip>
  For a faster, embedded checkout solution with minimal setup time, see our [embedded memecoin
  quickstart](/payments/embedded/quickstarts/credit-card-memecoin).
</Tip>

<Snippet />

<Snippet />

<Snippet />

## Headless Memecoin Checkout

The headless checkout API allows complete control over your checkout experience, including:

* Custom UI components and styling
* Custom payment flow sequences
* Integrated analytics and tracking
* Custom error handling and retry logic
* Branded confirmation pages

### Create an Order

The first step in the headless checkout process is to create an order. An order is an object datastructure that represents an intent to purchase in Crossmint's systems. This guide will create a basic order, and then update it with required info step-by-step.

<Note>
  You can also create the entire order in one API call if the necessary information is available at the time of order
  creation. This can be used for custom "one-click-checkout" experiences, should you wish to make them.
</Note>

**Endpoint:** `POST` `https://www.crossmint.com/api/2022-06-09/orders`

Refer to the complete **create order** API reference [here](/api-reference/headless/create-order).

<Note>
  Memecoins are now testable in staging using the xmeme token (`7EivYFyNfgGj8xbUymR7J4LuxUHLKRzpLaERHLvi7Dgu`). All
  other token purchases will fail in staging. For production launch with other tokens, contact our sales team.
</Note>

Use the JavaScript code snippet below to create a starting point for your order. Alternatively, use the API playground to explore and create your own order.

<CodeGroup>
  ```javascript JavaScript theme={null}
  const apiKey = "your-server-api-key"; // CHANGE THIS TO YOUR SERVER API KEY
  const tokenId = "solana:7EivYFyNfgGj8xbUymR7J4LuxUHLKRzpLaERHLvi7Dgu"; // xmeme token for staging
  const deliveryAddress = "your-solana-wallet-address"; // CHANGE THIS TO YOUR RECEIVING SOLANA WALLET ADDRESS
  const receiptEmail = "your-email@example.com"; // CHANGE THIS TO YOUR EMAIL

  const options = {
      method: "POST",
      headers: {
          "x-api-key": apiKey,
          "Content-Type": "application/json",
      },
      body: JSON.stringify({
          lineItems: [
              {
                  tokenLocator: tokenId, // Token address in format solana:tokenAddress (e.g., solana:7EivYFyNfgGj8xbUymR7J4LuxUHLKRzpLaERHLvi7Dgu for xmeme token)
                  executionParameters: {
                      mode: "exact-in", // The execution method for the order. It tells Crossmint to operate in buying fungibles mode
                      amount: "1", // default currency USD
                      maxSlippageBps: "500", // Optional, or else default autogenerated slippage will be applied
                  },
              },
          ],
          payment: {
              method: "card",
              receiptEmail: receiptEmail,
          },
          recipient: {
              walletAddress: deliveryAddress,
          },
      }),
  };

  fetch("https://staging.crossmint.com/api/2022-06-09/orders", options)
      .then((response) => response.json())
      .then((response) => console.log(JSON.stringify(response, null, 2)))
      .catch((err) => console.error(err));
  ```

  ```json JSON theme={null}
  {
      "lineItems": [
          {
              "tokenLocator": "solana:tokenAddress",
              "executionParameters": {
                  "mode": "exact-in",
                  "amount": "1",
                  "maxSlippageBps": "500"
              }
          }
      ],
      "payment": {
          "method": "card",
          "receiptEmail": "receiptEmail"
      },
      "recipient": {
          "walletAddress": "deliveryAddress"
      }
  }
  ```

  For more details on tokenLocator formatting and other item selection options, see the [item selection page](/payments/headless/guides/item-selection#json-item-selection-examples).
</CodeGroup>

<Accordion title="Example Response">
  ```json theme={null}
  {
    "clientSecret": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJvcmRlcklkZW50aWZpZXIiOiJlZDM0YTU3OS03ZmJjLTQ1MDktYjhkOC05ZTYxOTU0Y2Q1NTUiLCJpYXQiOjE3Mzk0MDI3NjEsImV4cCI6MTczOTQ4OTE2MX0.8AU0Y31lJhnQD2-vAXEZp3ZeMSyh_Wdm9An02Z5AW0M",
    "order": {
      "orderId": "ed34a579-7fbc-4509-b8d8-9e61954cd555",
      "phase": "payment",
      "locale": "en-US",
      "lineItems": [
        {
          "chain": "solana",
          "metadata": {
            "name": "xmeme",
            "description": "Token xmeme from the contract: 7EivYFyNfgGj8xbUymR7J4LuxUHLKRzpLaERHLvi7Dgu",
            "imageUrl": "https://arweave.net/VQrPjACwnQRmxdKBTqNwPiyo65x7LAT773t8Kd7YBzw"
          },
          "quote": {
            "status": "valid",
            "charges": {
              "unit": {
                "amount": "35.73",
                "currency": "usd"
              }
            },
            "totalPrice": {
              "amount": "1",
              "currency": "usd"
            },
            "quantityRange": {
              "lowerBound": "0.0265905",
              "upperBound": "0.0293895"
            }
          },
          "delivery": {
            "status": "awaiting-payment",
            "recipient": {
              "locator": "solana:BuWmGweapdysxU5VuUdi1RGoc4ibDG7TNirWjRtqF995",
              "walletAddress": "your-solana-wallet-address"
            }
          },
          "executionMode": "exact-in",
          "maxSlippageBps": "500",
          "executionParams": {
            "mintHash": "7EivYFyNfgGj8xbUymR7J4LuxUHLKRzpLaERHLvi7Dgu",
            "mode": "exact-in",
            "amount": "1",
            "maxSlippageBps": "500"
          }
        }
      ],
      "quote": {
        "status": "valid",
        "quotedAt": "2025-02-12T23:26:00.397Z",
        "expiresAt": "2025-02-12T23:26:30.397Z",
        "totalPrice": {
          "amount": "1",
          "currency": "usd"
        }
      },
      "payment": {
        "status": "awaiting-payment",
        "method": "basis-theory",
        "currency": "usd",
        "preparation": {},
        "receiptEmail": "test@example.com"
      }
    }
  }
  ```
</Accordion>

Note the following parameters in the request body:

* `maxSlippageBps`: Optional, or else default autogenerated slippage will be applied
* `receiptEmail`: Required for credit card payments to deliver receipt
* `executionParameters.mode`: The execution method for the order. "exact-out" is for NFTs, "exact-in" is for fungible tokens

### Render the Crossmint Embedded Component

After creating an order, you'll need to render the Crossmint Embedded Component to collect payment information. This secure, embeddable UI component lets you accept payment methods, validates input, and handles errors:

```javascript theme={null}
import { CrossmintEmbeddedCheckout, CrossmintProvider } from "@crossmint/client-sdk-react-ui";

export function MyCheckoutPage({ clientSecret, order, recipientWalletAddress, receiptEmail }) {
  return (
    <div className="w-full">
      <CrossmintProvider apiKey="<YOUR CLIENT SIDE KEY>">
        <CrossmintEmbeddedCheckout 
          recipient={{ walletAddress: recipientWalletAddress}}
          clientSecret={clientSecret}
          orderId={order.orderId}
          payment={{
            crypto: {
                enabled: false,
            },
            fiat: {
                enabled: true,
            },
            defaultMethod: "fiat",
            receiptEmail: receiptEmail,
          }}
          appearance={{
              rules: {
                  DestinationInput: {
                      display: "hidden",
                  },
                  ReceiptEmailInput: {
                      display: "hidden",
                  },
              },
          }} />
      </CrossmintProvider>
    </div>
  );
}
```

<Tip>
  The `CrossmintEmbeddedCheckout` component is highly customizable. You can adjust colors, styling, layout, and behavior to match your brand. Learn more in our [UI customization guide](/payments/embedded/guides/ui-customization).
</Tip>

### Poll for Status Updates

After making the payment, you'll need to poll the [Get Order API](/api-reference/headless/get-order) to check on the delivery status and present this information to your user.

**Endpoint:** `GET` `https://staging.crossmint.com/api/2022-06-09/orders/<orderId>`

Refer to the complete **get order** API reference [here](/api-reference/headless/get-order).

**Example Response:**

```json theme={null}
{
    "id": "order_xyz",
    "status": "completed",
    "phases": {
        "quote": { "status": "completed" },
        "payment": { "status": "completed" },
        "delivery": { "status": "completed", "details": "Memecoins delivered to specified wallet" }
    }
}
```

### Handling Refunded Payments

When polling for order status, you may encounter a situation where `payment.status` is `completed` but the order also contains a `payment.refunded` property. This indicates that the payment was initially successful but has since been refunded.

```json theme={null}
{
    "order": {
        "payment": {
            "status": "completed",
            "refunded": {
                "amount": "1.00",
                "currency": "usd",
                "txId": "0x1234abcd...",
                "chain": "ethereum"
            }
        }
    }
}
```

The `payment.refunded` object includes the following fields:

* `amount`: The amount that was refunded
* `currency`: The currency of the refund
* `txId`: The on-chain transaction ID the refund was sent in
* `chain`: The blockchain where the refund transaction occurred

When you encounter this state, your application should:

1. Display an appropriate message to the user indicating that their payment was refunded
2. Provide the transaction ID (`txId`) so users can verify the refund on-chain
3. Prevent any further actions related to the order (such as delivery expectations)
4. Provide options for the user to place a new order if desired

This state typically occurs when there was an issue with processing the order after payment was received, such as insufficient liquidity for memecoin purchases or compliance issues.

🎉 Congratulations! You've successfully set up your headless memecoin checkout. Check out the [Next Steps](#next-steps) section below to learn how to customize your integration.

<Snippet />

## Next Steps

<CardGroup>
  <Card title="Design Your UI" icon="paintbrush" href="/payments/headless/guides/design-your-ui">
    Learn how to design your headless checkout experience
  </Card>

  <Card title="Handle Webhooks" icon="bell" href="/payments/advanced/webhooks">
    Implement webhook handling for order updates
  </Card>
</CardGroup>

<Snippet />

## Refreshing Orders

For memecoin checkout, the order expiration is 1 minute. The Crossmint Embedded Checkout will automatically refresh the order for you when the time comes. Alternatively, you can either create a new order or use the refresh quote API:

```javascript theme={null}
async refreshOrder(orderId, clientSecret) {
  try {
    const ancestorOrigins = typeof window !== 'undefined' && window.location?.ancestorOrigins
      ? Array.from(window.location.ancestorOrigins)
      : [];

    const response = await this.callApi(`2022-06-09/orders/${orderId}/refresh`, "POST", {}, {
      "authorization": `${clientSecret}`,
      "x-ancestor-origins": JSON.stringify(ancestorOrigins)
    });

    const parsed = await response.json();
    return parsed;
  } catch (error) {
    console.error("Error refreshing quote:", error);
    throw error;
  }
}
```

<Snippet />


# Pay with Card - NFTs
Source: https://docs.crossmint.com/payments/headless/quickstarts/credit-card-nft

Create a fully customized checkout experience with credit cards.

<Snippet />

## Introduction

In this quickstart you'll learn how to accept credit card payments (including Apple and Google Pay) using Crossmint's headless APIs to purchase an NFT on the `polygon-amoy` testnet

## Prerequisites

<Snippet />

## Integration Steps

<Snippet />

### 1. Create an Order

<Snippet />

```json theme={null}
{
    "payment": {
        "method": "card",
    },
    "lineItems": [
        {
            "collectionLocator": "crossmint:<collectionId>", // Use the collectionId you created in the Prerequisites section
            "callData": {
                "totalPrice": "0.0001"
            }
        }
    ]
}
```

<Accordion title="Example Response">
  ```json theme={null}
  {
    "clientSecret": "_removed_",
    "order": {
      "orderId": "cc40e6af-f8dc-4ac2-8e26-d91a32f271cf",
      "phase": "quote",
      "locale": "en-US",
      "lineItems": [
        {
          "chain": "polygon-amoy",
          "quantity": 1,
          "callData": {
            "quantity": 1
          },
          "metadata": {
            "name": "Headless Demo",
            "description": "NFT Checkout Demo",
            "imageUrl": "https://utfs.io/f/cd8545b7-3410-4fcd-988d-cd11951ed53c-g287ok.png"
          },
          "quote": {
            "status": "requires-recipient",
            "charges": {
              "unit": {
                "amount": "0.000169004",
                "currency": "eth"
              }
            },
            "totalPrice": {
              "amount": "0.000169004",
              "currency": "eth"
            }
          },
          "delivery": {
            "status": "awaiting-payment"
          }
        }
      ],
      "quote": {
        "status": "requires-recipient",
        "quotedAt": "_DATE_",
        "expiresAt": "_DATE_",
        "totalPrice": {
          "amount": "0.000169004",
          "currency": "eth"
        }
      },
      "payment": {
        "status": "requires-quote",
        "method": "basis-theory",
        "preparation": {},
      }
    }
  }
  ```
</Accordion>

<Snippet />

### 2. Update the Order with Recipient

<Snippet />

<Warning>
  Legally, for card payments, **an email *must* be specified** in order to deliver a receipt to your user, either in
  `recipient.email` or in `payment.receiptEmail`. If one is not specified, the API will not return the fields
  necessary to collect the user's payment.
</Warning>

<Tabs>
  <Tab title="Email recipient">
    ```json theme={null}
    {
        "recipient": {
            "email": "test@example.com"
        }
    }
    ```
  </Tab>

  <Tab title="Wallet recipient with receipt email">
    ```json theme={null}
    {
        "recipient": {
            "walletAddress": "0xabcd1234..."
        },
        "payment": {
            "method": "card", // When updating the payment, you must pass the complete object
            "receiptEmail": "test@example.com"
        }
    }
    ```
  </Tab>
</Tabs>

### 3. Render the Crossmint Embedded Component

After creating an order, you'll need to render the Crossmint Embedded Component to collect payment information. This secure, embeddable UI component lets you accept payment methods, validates input, and handles errors:

```tsx theme={null}
import { CrossmintEmbeddedCheckout, CrossmintProvider } from "@crossmint/client-sdk-react-ui";

export function MyCheckoutPage({ clientSecret, order, recipientWalletAddress, receiptEmail }) {
  return (
    <div className="w-full">
      <CrossmintProvider apiKey="<YOUR CLIENT SIDE KEY>">
        <CrossmintEmbeddedCheckout 
          recipient={{ walletAddress: recipientWalletAddress}}
          clientSecret={clientSecret}
          orderId={order.orderId}
          payment={{
            crypto: {
                enabled: false,
            },
            fiat: {
                enabled: true,
            },
            defaultMethod: "fiat",
            receiptEmail: receiptEmail,
          }}
          appearance={{
              rules: {
                  DestinationInput: {
                      display: "hidden",
                  },
                  ReceiptEmailInput: {
                      display: "hidden",
                  },
              },
          }} />
      </CrossmintProvider>
    </div>
  );
}
```

<Tip>
  The `CrossmintEmbeddedCheckout` component is highly customizable. You can adjust colors, styling, layout, and behavior to match your brand. Learn more in our [UI customization guide](/payments/embedded/guides/ui-customization).
</Tip>

### 4. Poll for Status Updates

<Snippet />

## Next Steps

<Snippet />


# Pay with Other Crypto
Source: https://docs.crossmint.com/payments/headless/quickstarts/crypto

Create a fully customized checkout experience with crypto payments.

## Introduction

In this quickstart you'll learn how to accept multiple different cryptocurrencies as payment using Crossmint's headless APIs, to purchase an NFT on the `polygon-amoy` testnet.

## Prerequisites

<Snippet />

If you are choosing to do this quickstart in your own console or IDE, consider you will need to have a way to prompt and sign crypto payments, like using Metamask.

### External Prerequisites

* Your crypto wallet of choice - Metamask, Coinbase Wallet, etc.
* A small balance of testnet currency in whichever cryptocurrency you would like to pay with
  * [Ethereum, Base, Polygon](https://www.alchemy.com/faucets) - note that some of these faucets require a minimum of 0.1 ETH on mainnet, to prevent abuse
  * [Solana devnet](https://solana.com/developers/guides/getstarted/solana-token-airdrop-and-faucets)

## Integration Steps

This quickstart will primarily focus on the API calls necessary to implement headless checkout in your project. You will also need to build out the frontend experience for your users.

### 1. Create an Order

<Snippet />

<Tabs>
  <Tab title="Pay with ETH">
    ```json theme={null}
    {
        "payment": {
            "method": "base-sepolia",
            "currency": "eth",
            "payerAddress": "0xabcd1234..."
        },
        "lineItems": [
            {
                "collectionLocator": "crossmint:<collectionId>",
                "callData": {
                    "totalPrice": "0.0001"
                }
            }
        ]
    }
    ```
  </Tab>

  <Tab title="Pay with ERC20s">
    ```json theme={null}
    {
        "payment": {
            "method": "base-sepolia",
            "currency": "usdc" | "degen" | "brett" | ... ,
            "payerAddress": "0xabcd1234..."
        },
        "lineItems": [
            {
                "collectionLocator": "crossmint:<collectionId>",
                "callData": {
                    "totalPrice": "0.0001"
                }
            }
        ]
    }
    ```
  </Tab>

  <Tab title="Pay with SOL">
    ```json theme={null}
    {
        "payment": {
            "method": "solana",
            "currency": "sol",
            "payerAddress": "7NxpS1cMZ8..."
        },
        "lineItems": [
            {
                "collectionLocator": "crossmint:<collectionId>",
                "callData": {
                    "totalPrice": "0.0001"
                }
            }
        ]
    }
    ```
  </Tab>

  <Tab title="Pay with SPLs">
    ```json theme={null}
    {
        "payment": {
            "method": "solana",
            "currency": "usdc" | "bonk" | ... ,
            "payerAddress": "7NxpS1cMZ8..."
        },
        "lineItems": [
            {
                "collectionLocator": "crossmint:<collectionId>",
                "callData": {
                    "totalPrice": "0.0001"
                }
            }
        ]
    }
    ```
  </Tab>

  <Tab title="Pay with MATIC">
    ```json theme={null}
    {
        "payment": {
            "method": "polygon-amoy",
            "currency": "matic",
            "payerAddress": "0xabcd1234..."
        },
        "lineItems": [
            {
                "collectionLocator": "crossmint:<collectionId>",
                "callData": {
                    "totalPrice": "0.0001"
                }
            }
        ]
    }
    ```
  </Tab>
</Tabs>

<Accordion title="Example Response">
  ```json theme={null}
  {
    "clientSecret": "_removed_",
    "order": {
      "orderId": "cc40e6af-f8dc-4ac2-8e26-d91a32f271cf",
      "phase": "quote",
      "locale": "en-US",
      "lineItems": [
        {
          "chain": "polygon-amoy",
          "quantity": 1,
          "callData": {
            "quantity": 1
          },
          "metadata": {
            "name": "Headless Demo",
            "description": "NFT Checkout Demo",
            "imageUrl": "https://utfs.io/f/cd8545b7-3410-4fcd-988d-cd11951ed53c-g287ok.png"
          },
          "quote": {
            "status": "requires-recipient",
            "charges": {
              "unit": {
                "amount": "0.000169004",
                "currency": "eth"
              }
            },
            "totalPrice": {
              "amount": "0.000169004",
              "currency": "eth"
            }
          },
          "delivery": {
            "status": "awaiting-payment"
          }
        }
      ],
      "quote": {
        "status": "requires-recipient",
        "quotedAt": "_DATE_",
        "expiresAt": "_DATE_",
        "totalPrice": {
          "amount": "0.000169004",
          "currency": "eth"
        }
      },
      "payment": {
        "status": "requires-quote"
      }
    }
  }
  ```
</Accordion>

<Note>
  In the requests above the `payerAddress` has been included, however if your user has not yet connected their wallet
  you may omit this field, allow them to connect their wallet after creating the order, and submit the `payerAddress`
  at a later time.
</Note>

<Snippet />

### 2. Update the Order with Recipient

<Snippet />

<Tabs>
  <Tab title="Email recipient">
    ```json theme={null}
    {
        "recipient": {
            "email": "test@example.com"
        }
    }
    ```
  </Tab>

  <Tab title="Wallet recipient">
    ```json theme={null}
    {
        "recipient": {
            "walletAddress": "0xabcd1234..."
        }
    }
    ```
  </Tab>
</Tabs>

<Note>
  Notice you only need to pass the object that your are updating, in this case, `recipient`. You can also update
  multiple properties in the same call. Available properties for update include `recipient`, `locale`, and the
  `payment` object.
</Note>

<Note>
  If specifying a recipient by wallet address, ensure the address is valid for the chain your **collection** is on,
  which may differ from the chain the **payment is being performed** on.
</Note>

<Accordion title="Example Response">
  ```json theme={null}
  {
    "orderId": "cc40e6af-f8dc-4ac2-8e26-d91a32f271cf",
    "phase": "payment",
    "locale": "en-US",
    "lineItems": [
      {
        "chain": "polygon-amoy",
        "quantity": 1,
        "callData": {
          "quantity": 1
        },
        "metadata": {
          "name": "Headless Demo",
          "description": "NFT Checkout Demo",
          "imageUrl": "https://utfs.io/f/cd8545b7-3410-4fcd-988d-cd11951ed53c-g287ok.png"
        },
        "quote": {
          "status": "valid",
          "charges": {
            "unit": {
              "amount": "0.0001681558",
              "currency": "eth"
            }
          },
          "totalPrice": {
            "amount": "0.0001681558",
            "currency": "eth"
          }
        },
        "delivery": {
          "status": "awaiting-payment"
        }
      }
    ],
    "payment": {
      "status": "awaiting-payment",
      "preparation": {
        "method": "crypto",
        "chain": "base-sepolia",
        "payerAddress": "0x6C3b3225759Cbda68F96378A9F0277B4374f9F06",
        "serializedTransaction": "0x02f9012683aa36a744848917370085080992ce6c82629c94a105c311fa72b8fb78c992ecbdb8b02ea5bd394d869a9d359ca000b8f465794a68624763694f694a49557a49314e694973496e523563434936496b705856434a392e65794a756232356a5a534936496a4d3559544e6d4d444d334c544d7a4e6d51744e4441305a5331684d6a45774c575268593249335957526b5a4456694e794973496d39795a4756795357526c626e52705a6d6c6c63694936496d4e6a4e44426c4e6d466d4c5759345a474d744e47466a4d6930345a5449324c5751354d57457a4d6d59794e7a466a5a694973496d6c68644349364d5463784e546b334f54557a4e33302e662d4949646c653375314c58634c7845765438754e336d74786370764a686f31384a5a4b76483768456659c0"
      }
    }
  }
  ```

  <Warning>
    Notice at the bottom, the new `serializedTransaction` property. This is a unique identifier let's Crossmint know exactly which order you are updating.
    Anytime you update an order you ***must*** use the returned `serializedTransaction` property.
  </Warning>
</Accordion>

### 3. Show Purchase Preview to User

Now, after you've told Crossmint systems what you want, and you have passed a valid place to send the NFT, Crossmint will return a quote with prices for the desired items
Within the returned response, you'll find the `lineItems` array which contains the metadata and a quote for each line item. Within a quote, a detailed breakdown of its charges can be found.

<Tabs>
  <Tab title="Preview Screenshot">
    <Frame type="simple">
      <img alt="preview purchase screenshot" />
    </Frame>
  </Tab>

  <Tab title="Code Example">
    <Note>
      If you are developing in an IDE or in terminal, the returned `lineitems` may be stuck in an \[Object], or be in a
      hard-to-understand object format. You can make this human-readable for yourself by adding `JSON.stringify(response)`
    </Note>

    ```jsx theme={null}
    <div class="flex flex-col justify-start w-full mb-5 item">
        <div class="flex w-full items-center justify-start border-b border-[#E7E9ED] py-2">
            <div class="flex items-center justify-between w-full">
                <div class="flex items-center">
                    <img src="{order.lineItems[0].metadata.image}" class="flex w-10 h-10 mr-4 rounded-md" />
                    <div class="flex flex-col items-start justify-start">
                        <h3 class="font-medium">{order.lineItems[0].metadata.name}</h3>
                        <p class="text-sm text-text-secondary">{order.lineItems[0].metadata.description.slice(0, 20)}</p>
                    </div>
                </div>
                <div class="flex flex-col">
                    <p>Unit: {order.lineItems[0].quote.charges["unit"].amount}</p>
                    <p>Gas: {order.lineItems[0].quote.charges?.["gas"]?.amount}</p> // Gas charge may not be defined, depending
                    on the collection's chain
                </div>
            </div>
        </div>
        <div class="flex w-full flex-col items-center justify-start gap-y-0.5 pt-2">
            <div class="flex items-center justify-between w-full">
                <p class="text-sm font-medium text-text-primary">Total price</p>
                <span class="text-sm font-medium text-text-primary">
                    {order.quote.totalPrice.amount} {order.quote.totalPrice.currency}
                </span>
            </div>
        </div>
    </div>
    ```
  </Tab>

  <Tab title="lineItems Example">
    ```json theme={null}
    {
        // some properties removed for brevity
        "order": {
            "lineItems": [
                {
                    "chain": "polygon-amoy",
                    "quantity": 1,
                    "callData": {
                        "quantity": 1
                    },
                    "metadata": {
                        "name": "Headless Demo",
                        "description": "NFT Checkout Demo",
                        "imageUrl": "https://utfs.io/f/cd8545b7-3410-4fcd-988d-cd11951ed53c-g287ok.png"
                    },
                    "quote": {
                        "status": "valid",
                        "charges": {
                            "unit": {
                                "amount": "0.000169004",
                                "currency": "eth"
                            }
                        },
                        "totalPrice": {
                            "amount": "0.000169004",
                            "currency": "eth"
                        }
                    },
                    "delivery": {
                        "status": "awaiting-payment"
                    }
                }
            ]
        }
    }
    ```
  </Tab>
</Tabs>

### 4. Request Payment from User

You now need to request crypto payment from the user.

You will use the `serializedTransaction` returned in the purchase preview from the previous step. The `serializedTransaction` needs to be structured into a transaction object, which can then be passed to a crypto payment prompter, like viem's `sendTransaction` or wagmi's `sendTransactionAsync`.

Whichever method you use, it should open the user's default wallet extension in the browser and allow the user to complete the cross-chain payment.

<Check>
  If you've followed along this far you can simply paste the `serializedTransaction` property returned in your
  previous API call into the app below. This will allow you to sign and send the transaction.
</Check>

<Tabs>
  <Tab title="Send EVM Payment">
    <Frame type="simple">
      <iframe />
    </Frame>
  </Tab>

  <Tab title="Send Solana Payment">
    <Warning>
      Ensure your wallet is connected to the **devnet** network, otherwise your funds may be lost!
    </Warning>

    <Frame type="simple">
      <iframe />
    </Frame>
  </Tab>

  <Tab title="Code Example">
    ```tsx theme={null}
    "use client";

    import { ConnectButton } from "@rainbow-me/rainbowkit";
    import { useState } from "react";
    import { parseTransaction } from "viem"; // Refer to their documentation details to make viem work for your needs
    import { useSendTransaction } from "wagmi"; // Refer to their documentation details to make wagmi work for your needs

    export default function Home() {
        const { data: hash, isPending, sendTransactionAsync } = useSendTransaction();

        const signAndSendTransaction = async () => {
            const serializedTxn = "0x_your_serialized_transaction_response";
            const txn = parseTransaction(serializedTxn || "0x");

            await sendTransactionAsync({
                to: txn.to as `0x${string}`,
                value: BigInt(txn.value ? txn.value.toString() : "0"),
                data: txn.data as `0x${string}`,
                chainId: txn.chainId,
            });
        };
        return <button onClick={() => signAndSendTransaction()}>Send Transaction</button>;
    }
    ```
  </Tab>

  <Tab title="Full Repository Example">
    For a deeper example, refer to the repository linked below, which is the exact code running in the App tab.

    <Card title="headless-sendpayment" icon="github" href="https://github.com/crossmint/headless-sendpayment">
      Refer to the full repo for complete code examples
    </Card>
  </Tab>
</Tabs>

### 5. Poll for Status Updates

<Snippet />

## Next Steps

<Snippet />


# Pay with USDC
Source: https://docs.crossmint.com/payments/headless/quickstarts/paying-usdc

Buy or sell any tokenized asset with USDC, in an API call

## Introduction

This guide will show you how to quickly buy or sell any tokenized asset (NFT) with USDC, using Crossmint's headless APIs.

## Prerequisites

<Snippet />

## External prerequisites

<Steps>
  <Step icon="circle-dot" title="Wallet">
    Crypto wallet supporting USDC - [Metamask](https://metamask.io/), [Phantom](https://phantom.app/), [Coinbase Wallet](https://wallet.coinbase.com), etc.
  </Step>

  <Step icon="circle-dot" title="Testnet Balance">
    A small balance of **USDC** testnet currency in your wallet on the **Base-sepolia** network.

    Get testnet USDC here:

    * [Crossmint USDC Faucet (Base-sepolia)](https://usdc-faucet.vercel.app/)

    <Warning>
      The above faucet provides both USDC and USDXM. This quickstart uses USDC by default, but you can also use USDXM (see contract address below).
    </Warning>

    <Note>
      USDXM is a test token that represents USDC. It has the same behavior as USDC. In production, you'll use real USDC instead.
    </Note>

    **Adding USDC to MetaMask:**

    * Import the token to MetaMask:
      1. Open MetaMask and click "Import tokens"
      2. For USDC: Use the official USDC contract address from Circle `0x036CbD53842c5426634e7929541eC2318f3dCF7e`
      3. For USDXM: Use the USDXM contract address `0x14196F08a4Fa0B66B7331bC40dd6bCd8A1dEeA9F`
      4. Click Import
      5. Refresh your wallet
  </Step>
</Steps>

## Create an order and pay with USDC

<Steps>
  <Step title="Setup your environment">
    Clone the quickstart repo:

    ```bash theme={null}
    git clone https://github.com/Crossmint/headless-pay-usdc.git
    ```

    Navigate to the project directory:

    ```bash theme={null}
    cd headless-pay-usdc
    ```

    Install the dependencies:

    ```bash theme={null}
    pnpm i
    ```
  </Step>

  <Step title="Set keys in .env">
    Set the following keys in the `.env` file:

    ```bash theme={null}
    CROSSMINT_API_KEY="<your-api-key>"
    COLLECTION_ID="<your-collection-id>"
    PAYER_ADDRESS="<your-payer-address>"
    EMAIL_ADDRESS="<your-email-address>"
    ```

    * `CROSSMINT_API_KEY`, `COLLECTION_ID` are found from the [Developer Console](https://staging.crossmint.com/console/). See [Prerequisites](#prerequisites)
    * `PAYER_ADDRESS` is your wallet address that contains USDC.
    * `EMAIL_ADDRESS` is where you'll receive your NFT in a new Crossmint wallet that you can access later.
  </Step>

  <Step title="Create order with USDC payment">
    Run the application:

    ```bash theme={null}
    pnpm dev
    ```

    This will:

    1. Create an order that is waiting for a **USDC** payment on the **Base-sepolia** network
    2. Return the **serializedTransaction**, which will be used in the next step
    3. Poll the status of the order until it is complete

    <Frame type="simple">
      <img alt="Serialized transaction" />
    </Frame>
  </Step>

  <Step title="Receive Payment">
    1. Copy the `serializedTransaction` returned in the previous step and paste it below
    2. Connect to your USDC wallet that was specified in the `.env` file
    3. Send the transaction

    <Frame type="simple">
      <iframe />
    </Frame>
  </Step>

  <Step title="Status of order">
    The code will poll for the status of the order until it is marked as complete.
    You should see it changing from "payment" to "delivery" and finally to "completed".

    <Info>
      You will also see the final order details, including the transaction hash, in your terminal.
    </Info>

    <Frame type="simple">
      <img alt="Order status" />
    </Frame>
  </Step>
</Steps>

## Access your NFT

Once the order is complete, you will receive an email with a link to the purchased item, which can be viewed in the Crossmint website.

<Info>
  You can also access your NFT by logging in to your Crossmint wallet at
  [crossmint.com](https://staging.crossmint.com/user/collection) with the email address you specified in the `.env`
  file.
</Info>

## Understanding the code

### Creating an order

The order creation process involves sending a POST request to Crossmint's API with the necessary payment and recipient details. Let's break down the key components:

```ts src/createOrder.ts theme={null}
import { API_KEY, API_URL, COLLECTION_ID, EMAIL_ADDRESS, PAYER_ADDRESS } from "./utils";


export async function createOrder() {
    const payload = {
        recipient: {
            email: EMAIL_ADDRESS, // Replace with actual recipient wallet address
        },
        payment: {
            method: "base-sepolia",
            currency: "usdc",
            payerAddress: PAYER_ADDRESS,
        },
        lineItems: [
            {
                collectionLocator: `crossmint:${COLLECTION_ID}`
            },
        ],
    };
    ...
}
```

#### Key parameters explained

* **recipient**: Specifies where to deliver the tokenized asset

  * `email`: The email address where the tokenized asset will be delivered in a Crossmint wallet.
    Instead of an email, a `walletAddress` field can be used to deliver the asset to a specific wallet address.

* **payment**: Defines how the payment will be made

  * `method`: The blockchain network (`base-sepolia` for testnet)
  * `currency`: The payment currency (`usdc`)
  * `payerAddress`: The wallet address that will send the USDC payment

* **lineItems**: Specifies what is being purchased
  * `collectionLocator`: Identifies the collection

#### API request

```ts src/createOrder.ts theme={null}
    const response = await fetch(`${API_URL}/api/2022-06-09/orders`, {
        method: "POST",
        headers: {
            "Content-Type": "application/json",
            "x-api-key": API_KEY,
        },
        body: JSON.stringify(payload),
    });
```

The API request:

* Sends a POST request to Crossmint's order endpoint
* Includes your API key for authentication
* Sends the order data as JSON in the request body

#### Response handling

```ts src/createOrder.ts theme={null}
    if (!response.ok) {
        throw new Error(`Failed to create order: ${response.status} ${response.statusText}`);
    }
    const jsonResponse = await response.json();
    return {
        "clientSecret": jsonResponse["clientSecret"], // Used for order authentication
        "order": jsonResponse["order"] // Contains the order details
    }
```

The response includes:

* `clientSecret`: A unique token used for authenticating subsequent requests for this order
* `order`: The order details including the order ID and status

For more details on creating orders via the headless API, see the [Create Order API Reference](/api-reference/headless/create-order).

### Polling an order

The order status polling process involves periodically checking the order's status until it's completed. Let's examine how this works:

```ts src/getOrder.ts theme={null}
import { API_KEY, API_URL } from "./utils";

export async function getOrder(orderId: string) {
    const response = await fetch(`${API_URL}/api/2022-06-09/orders/${orderId}`, {
        method: "GET",
        headers: {
            "Content-Type": "application/json",
            "x-api-key": API_KEY, // API authentication
        }
    });
    if (!response.ok) {
        throw new Error(`Failed to create order: ${response.status} ${response.statusText}`);
    }
    return response.json();
}
```

#### Get order function explained

* Takes `orderId` as parameter
* Makes a GET request to fetch the current state of the order
* Uses API key for authentication
* Returns the order details as JSON

```ts src/getOrder.ts theme={null}
export async function pollOrder(orderId: string) {
    while (true) {
        const order = await getOrder(orderId);
        console.log(`Current order status: \x1b[33m${order.phase}\x1b[0m`);
        if (order.phase === "completed") {
            return order;
        }
        await new Promise(resolve => setTimeout(resolve, 3000));
    }
}
```

#### Poll order function explained

* Continuously checks the order status every 3 seconds.
* Prints the current phase of the order
* Possible order phases include:
  * `payment`: Waiting for or processing payment
  * `delivery`: NFT is being delivered
  * `completed`: Order is successfully completed
* Returns the final order details when completed

The 3-second polling interval helps prevent rate limiting while still providing timely updates. Adjust this value based on your needs.

For more details on polling for order status, see the [Get Order API Reference](/api-reference/headless/get-order).

<Warning>
  Always implement proper error handling, retry mechanisms, and asynchronous polling in production environments to
  handle network issues or API interruptions.
</Warning>


# Overview
Source: https://docs.crossmint.com/payments/introduction

Allow your users to buy onchain assets using any payment method

Crossmint enables seamless in-app checkout experiences that minimize onboarding friction and maximize conversion.

With Checkout, users can buy memecoins, closed-loop tokens, NFTs, and other assets with debit cards, credit cards, Apple Pay, Google Pay, and stablecoins. Learn more about the types of assets that can be supported <a href="https://help.crossmint.com/articles/8719615099-which-tokens-are-supported-with-crossmint-checkout#supported-assets">here</a>.

Checkout works across all non-sanctioned geographies, requires no KYC, includes built-in chargeback protection, and has market-leading approval rates.

## See It in Action

The video below showcases Embedded Checkout for memecoins on <a href="https://fomo.family/">FOMO</a>, highlighting a seamless mobile onboarding experience with Apple Pay.

<video />

## Key Features

<CardGroup>
  <Card title="Available globally" icon="globe">
    Support for any non-sanctioned geo.
  </Card>

  <Card title="No KYC required" icon="passport">
    No ID checks during onboarding.
  </Card>

  <Card title="95-98% Approval Rate" icon="greater-than">
    Compared to 55% industry benchmark.
  </Card>

  <Card title="Chargeback Protection" icon="shield">
    Crossmint handles disputed transactions.
  </Card>

  <Card title="AML Monitoring" icon="fingerprint">
    Dedicated team of anti-fraud experts.
  </Card>

  <Card title="Analytics dashboards" icon="chart-line">
    Tools to measure and troubleshoot faster.
  </Card>
</CardGroup>

## Ways to Integrate

<CardGroup>
  <Card title="Hosted" icon="toggle-on" href="/payments/pay-button/quickstart">
    Checkout hosted on a pop-up, opened from your app or site.
  </Card>

  <Card title="Embedded" icon="object-group" href="/payments/embedded/quickstarts/credit-card-nft">
    Embed checkout in your app or site with full UI control.
  </Card>

  <Card title="Headless" icon="code" href="/payments/headless/quickstarts/credit-card-nft">
    Buy or sell via an API, best suited for agents or deep UI customization.
  </Card>
</CardGroup>

<Note>Crossmint generally recommends to use Embedded Checkout. It yields experiences that feel completely native while handling PSP orchestration and error management, and offering better approval rates.</Note>

## Get started

<CardGroup>
  <Card title="Plan Your Integration" icon="gear" href="/payments/plan-your-solution" />
</CardGroup>

## FAQs

<AccordionGroup>
  <Accordion title="What's the difference between the Checkout and the Onramp?">
    The *checkout* is used when a user is buying a specific item — like an NFT, memecoin, or product — with fiat or crypto. It's a direct purchase of a specific item.

    The *onramp* is used when a user wants to fund their wallet with crypto — without buying a specific item. Think of it as topping up a balance instead of making a purchase.

    Use *checkout* when selling something. Use *onramp* when your users need crypto to spend later.

    The checkout has no KYC, is available on any region non-sanctioned by OFAC, and offers the best UX and conversion rate. The onramp requires KYC and some geographical limitations apply.
  </Accordion>

  <Accordion title="Should I use embedded or headless checkout?">
    Embedded is the best solution for most teams. It offers embeddable iframe / mobile components which feel native and allow for customizability. Integration takes minutes, as the SDK orchestrates all integrations with payment processors, different states, and errors.
  </Accordion>

  <Accordion title="Which memecoins can be supported?">
    Our team continuously monitors market activity and proactively whitelists eligible memecoins across all of our partners. As of the last update, the Checkout supported memecoins representing around \~80% of the memecoin trading volume in the previous 24 hours.

    You may also request reviews for specific tokens at any time. Review timelines and throughput depend on your SaaS plan and request volume, and we'll always do our best to accommodate. If requests become too frequent relative to transaction volume, we may ask you to upgrade to a higher plan to continue supporting custom review requests.
  </Accordion>

  <Accordion title="How does settlement of payments and assets work?">
    Crossmint settles payments instantly with sellers directly via the smart contract, in the native currency specified
    on the contract. Assets are sent directly into the wallet of the buyer, without intermediation by Crossmint.
  </Accordion>

  <Accordion title="What happens if a buyer charges back their credit card?">
    You don't have to worry about chargeback risk. Crossmint will take on the risk and manage disputes directly with the bank.
  </Accordion>

  <Accordion title="Who pays for gas fees?">
    ### With Crossmint's contracts

    Managed Collections have two options for fees:

    **1. Buyer pays fees** - The buyer (your customer) pays the price of the asset you set in console, plus applicable fees. The Seller (you, the creator) receives the price set in console (aka *the payout*).

    **2. Seller pays fees** - The buyer pays the exact price of the asset set in console. You receive the set asset price, minus applicable fees.

    To access this setting in the Crossmint Console, go to your managed collection, click on "Payments" and then "Settings".
    Here you will find the "Who pays the fees?" switch, which allows you to set the payer of fees for your collection. You can update and save this setting at any time.

    * The total fees per transaction are the same in either option.
    * Managed collections are Buyer pays by default.

    ### With imported contracts

    Imported collections are only compatible with the "Buyer pays fees" option.
  </Accordion>

  <Accordion title="What happens if a transaction fails?">
    Crossmint places an authorization hold on the user's card before initiating the transaction. Funds are only captured once the transaction is successfully completed. If the transaction fails, the hold is released and the user is not charged.
  </Accordion>

  <Accordion title="Does Crossmint support primaries and secondaries (marketplaces)?">
    Crossmint supports primary and secondary sales for closed-loop tokens and [NFTs](/payments/advanced/marketplaces-and-launchpads). For memecoins, Crossmint only supports secondary sales.
  </Accordion>

  <Accordion title="What's the pricing model?">
    For more information, <a href="https://www.crossmint.com/contact/sales">contact sales</a>.
  </Accordion>
</AccordionGroup>


# Localization
Source: https://docs.crossmint.com/payments/pay-button/customize/localization

Customize the language and currency displayed on checkout

<Snippet />

## How to Adjust the Currency and Language

To customize the language use the property `locale` and for currency, set `defaultCurrency`. Here's an example:

```tsx {3,16} theme={null}
<CrossmintProvider apiKey="_YOUR_CLIENT_API_KEY_">
    <CrossmintHostedCheckout
        locale="es-ES" // Change locale to Spanish
        lineItems={{
            collectionLocator: "crossmint:_YOUR_COLLECTION_ID_",
            callData: {
                // your callData args
            },
        }}
        payment={{
            crypto: {
                enabled: true,
            },
            fiat: {
                enabled: true,
                defaultCurrency: "eur", // Change default currency to be Euro
            },
        }}
    />
</CrossmintProvider>
```


# React Hooks
Source: https://docs.crossmint.com/payments/pay-button/guides/hooks

Learn how to use React hooks to control and customize the Hosted Checkout UI

<Snippet />

<Snippet />

## Complete Example

Here's a full example showing how to implement a custom checkout experience:

```tsx theme={null}
import {
    CrossmintProvider,
    CrossmintCheckoutProvider,
    CrossmintHostedCheckout,
    useCrossmintCheckout,
} from "@crossmint/client-sdk-react-ui";

function CheckoutPage() {
    return (
        <CrossmintProvider apiKey="YOUR_API_KEY">
            <CrossmintCheckoutProvider>
                <CrossmintHostedCheckout
                    lineItems={{
                        collectionLocator: "crossmint:your-collection-id",
                        callData: {
                            totalPrice: "0.001",
                            quantity: 1,
                        },
                    }}
                    payment={{
                        crypto: { enabled: true },
                        fiat: { enabled: true },
                    }}
                />
                <CheckoutStatus />
            </CrossmintCheckoutProvider>
        </CrossmintProvider>
    );
}

function CheckoutStatus() {
    const { order } = useCrossmintCheckout();

    if (!order) {
        return <div>Loading...</div>;
    }

    switch (order.phase) {
        case "completed":
            return <div>Purchase complete!</div>;
        case "delivery":
            return <div>Delivering your NFTs...</div>;
        case "payment":
            return <div>Processing payment...</div>;
        case "quote":
            return <div>Preparing your order...</div>;
    }
}
```

<Snippet />

## Related Resources

* [UI Customization](/payments/pay-button/guides/ui-customization)
* [Payment Methods](/payments/pay-button/guides/payment-methods)
* [Order Lifecycle](/payments/headless/guides/order-lifecycle)
* [Testing Tips](/payments/advanced/testing-tips)


# Item Selection
Source: https://docs.crossmint.com/payments/pay-button/guides/item-selection

Specify which items to purchase with Hosted Checkout

The Hosted Checkout (Pay Button) allows you to specify which items your users can purchase using the `lineItems` property. This guide explains how to configure item selection for different asset types.

<Snippet />

## Item Selection Examples

<CodeGroup>
  ```tsx collectionLocator theme={null}
  <CrossmintProvider apiKey="_YOUR_CLIENT_API_KEY_">
      <CrossmintHostedCheckout
          lineItems={{
              collectionLocator: "crossmint:_YOUR_COLLECTION_ID_", // Crossmint managed collection
              // collectionLocator: "crossmint:_YOUR_COLLECTION_ID_:_TEMPLATE_ID_", // With specific template
              callData: {
                  totalPrice: "5.00",
                  quantity: 1, // matches your contract's parameter name
              },
          }}
      />
  </CrossmintProvider>
  ```

  ```tsx collectionLocator - imported contract theme={null}
  <CrossmintProvider apiKey="_YOUR_CLIENT_API_KEY_">
      <CrossmintHostedCheckout
          lineItems={{
              collectionLocator: "ethereum:0x71c7656ec7ab88b098defb751b7401b5f6d897", // External collection registered in Crossmint Console
              callData: {
                  totalPrice: "5.00",
                  quantity: 1, // matches your contract's parameter name
                  // For external contracts, you might need additional parameters such as:
                  // _amount: 1, // if your mint function uses _amount instead of quantity
                  // tokenId: "123", // if your contract requires a specific tokenId
                  // metadata: "ipfs://...", // if your contract accepts metadata
              },
          }}
      />
  </CrossmintProvider>
  ```

  ```tsx Solana theme={null}
  <CrossmintHostedCheckout
      lineItems={{
          tokenLocator: "solana:7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU",
          callData: {
              totalPrice: "0.1",
              buyerCreatorRoyaltyPercent: 100, // Required for Solana
          },
      }}
  />
  ```

  ```tsx tokenLocator - EVM theme={null}
  <CrossmintProvider apiKey="_YOUR_CLIENT_API_KEY_">
      <CrossmintHostedCheckout
          lineItems={{
              tokenLocator: "ethereum:0x71c7656ec7ab88b098defb751b7401b5f6d897:1234", // <blockchain>:<contractAddress>:<tokenId>
              callData: {
                  totalPrice: "25.00", // Only totalPrice is required for token purchases
                  // For external EVM contracts, you might need additional parameters:
                  // _amount: 1, // if your contract uses _amount instead of quantity
                  // tokenId: "1234", // if your contract requires explicit tokenId
                  // metadata: "ipfs://...", // if your contract accepts metadata
              },
          }}
      />
  </CrossmintProvider>
  ```

  ```tsx tokenLocator - Solana theme={null}
  <CrossmintProvider apiKey="_YOUR_CLIENT_API_KEY_">
      <CrossmintHostedCheckout
          lineItems={{
              tokenLocator: "solana:7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU", // <blockchain>:<tokenAddress>
              callData: {
                  totalPrice: "25.00",
                  buyerCreatorRoyaltyPercent: 100, // Required for Solana
              },
          }}
      />
  </CrossmintProvider>
  ```

  ```tsx productLocator theme={null}
  <CrossmintProvider apiKey="_YOUR_CLIENT_API_KEY_">
      <CrossmintHostedCheckout
          lineItems={{
              productLocator: "amazon:B01DFKC2SO", // Amazon ASIN
              // productLocator: "amazon:https://www.amazon.com/dp/B01DFKC2SO", // Amazon URL
              // productLocator: "shopify:https://your-store.myshopify.com/products/product-name:123456789", // Shopify
          }}
      />
  </CrossmintProvider>
  ```
</CodeGroup>

<Snippet />

<Snippet />

<Snippet />

## Order Status Tracking

The Pay Button cannot use webhooks for order status tracking because it operates in a separate window. Therefore, you'll need to implement polling to check order status through alternative methods. See the [Order Status Guide](/payments/pay-button/guides/order-status) for more information on tracking order completion in pay button.


# Order Status
Source: https://docs.crossmint.com/payments/pay-button/guides/order-status

Track order status with Hosted Checkout

Since Hosted Checkout opens in a separate window, you can't use `useCrossmintCheckout` to track order status. Instead, you have three options:

## 1. Using Callback Functions

```tsx theme={null}
<CrossmintHostedCheckout
    lineItems={{
        collectionLocator: "crossmint:_YOUR_COLLECTION_ID_",
        callData: {
            totalPrice: "0.001",
            quantity: 1,
        },
    }}
    appearance={{
        display: "new-tab", // or "overlay"
        overlay: {
            enabled: true,
        },
    }}
    onSuccess={(orderId) => {
        // Handle successful order
        console.log("Order completed:", orderId);
    }}
    onFailure={(error) => {
        // Handle failed order
        console.error("Order failed:", error);
    }}
/>
```

## 2. Using Event Listeners

```tsx theme={null}
useEffect(() => {
    const handleMessage = (event: MessageEvent) => {
        if (event.data.type === "crossmint:checkout:completed") {
            console.log("Order completed:", event.data.orderId);
        }
    };

    window.addEventListener("message", handleMessage);
    return () => window.removeEventListener("message", handleMessage);
}, []);
```

## 3. Using Order Status API

For real-time order status updates, you can use the [Order Status API](/payments/pay-button/guides/order-status) to check the status of an order programmatically.


# Configure Payment Options
Source: https://docs.crossmint.com/payments/pay-button/guides/payment-methods

Customize the payment methods available to users

## Payment Methods Supported

<CardGroup>
  <Card title="Debit & Credit cards" icon="credit-card" />

  <Card title="Apple & Google Pay" icon="mobile" />

  <Card title="Cross-chain crypto" icon="coins" />
</CardGroup>

<Note>
  Buyers can purchase digital assets with any cryptocurrency. For example, they can pay for an asset on Optimism chain
  with mainnet ETH. This is done real time without bridging and lower gas fees.
</Note>

## Configure Payment Settings

You can configure payment preferences using the `payment` prop:

```tsx theme={null}
<CrossmintHostedCheckout
    payment={{
        // Enable/disable payment types
        fiat: {
            enabled: true,
            defaultCurrency: "usd", // Set preferred fiat currency
        },
        crypto: {
            enabled: true,
            defaultChain: "polygon", // Set preferred blockchain
            defaultCurrency: "matic", // Set preferred crypto
        },
        // Optional: Set default payment method
        defaultMethod: "fiat", // Options: "fiat" or "crypto"
        // Optional: Set receipt email
        receiptEmail: "buyer@example.com",
    }}
/>
```

### Fiat Payment Options

Configure fiat payment settings:

```tsx theme={null}
payment={{
  fiat: {
    enabled: true,
    defaultCurrency: "usd"
  }
}}
```

### Crypto Payment Options

Configure crypto payment preferences:

```tsx theme={null}
payment={{
  crypto: {
    enabled: true,
    defaultChain: "polygon", // Set preferred blockchain
    defaultCurrency: "matic" // Set preferred crypto currency
  }
}}
```

<Info>
  You will be paid in the currency expected by your registered mint function, regardless of how the buyer pays.
</Info>


# Production Launch
Source: https://docs.crossmint.com/payments/pay-button/guides/production-launch

Follow this checklist to ensure you are ready for production launch with Pay Button

## From Staging to Production with Pay Button

<Snippet />

***

### Launch Checklist

1. Change your API keys to the production versions. Ensure your production API key has the appropriate scopes enabled, such as `orders.create`.
2. Update your collection ID to the production one.
3. As needed, change your passed-in props to be production ready (e.g. make `email`, `payment`, `lineItems` programmatically filled).

<Accordion title="See Code Example">
  <CodeGroup>
    ```jsx {(1, 4)} Production theme={null}
    <CrossmintProvider apiKey="YOUR_PROD_API_KEY">
        <CrossmintPayButton
            lineItems={{
                collectionLocator: `crossmint:YOUR_PROD_COLLECTION_ID`,
                callData: {
                    totalPrice: "0.25",
                    quantity: 1,
                },
            }}
            payment={{
                crypto: { enabled: true },
                fiat: {
                    enabled: true,
                    defaultCurrency: "usd",
                },
            }}
        />
    </CrossmintProvider>
    ```

    ```jsx {(1, 4)} Staging theme={null}
    <CrossmintProvider apiKey="YOUR_STAGING_API_KEY">
        <CrossmintPayButton
            lineItems={{
                collectionLocator: `crossmint:YOUR_STAGING_COLLECTION_ID`,
                callData: {
                    totalPrice: "0.001",
                    quantity: 1,
                },
            }}
            payment={{
                crypto: { enabled: true },
                fiat: {
                    enabled: true,
                    defaultCurrency: "usd",
                },
            }}
        />
    </CrossmintProvider>
    ```
  </CodeGroup>
</Accordion>


# Specify Recipient
Source: https://docs.crossmint.com/payments/pay-button/guides/specify-recipient

Select where purchased items should be delivered in Hosted Checkout

<Snippet />

## Specifying the Recipient

For Hosted Checkout, you specify the recipient by adding a `recipient` object to your checkout component. The recipient can be specified by email, wallet address, or physical address for physical products.

### Recipient by Email

When specifying a recipient by email, Crossmint will automatically create a secure custodial wallet on the fly for that email address:

```jsx React {3-5} theme={null}
<CrossmintProvider apiKey="YOUR_API_KEY">
    <CrossmintHostedCheckout
        recipient={{
            email: "user@example.com",
        }}
        lineItems={{
            collectionLocator: `crossmint:YOUR_COLLECTION_ID`,
            callData: {
                totalPrice: "0.0001",
                quantity: 1,
            },
        }}
        payment={{
            crypto: { enabled: true },
            fiat: { enabled: true },
        }}
    >
        Buy with Crossmint
    </CrossmintHostedCheckout>
</CrossmintProvider>
```

The recipient will be able to access their purchased items by logging into their Crossmint wallet in [staging](https://staging.crossmint.com/user/collection) or [mainnet](https://www.crossmint.com/user/collection).

### Recipient by Wallet Address

To deliver items directly to a specific blockchain wallet address:

```jsx React {3-6} theme={null}
<CrossmintProvider apiKey="YOUR_API_KEY">
    <CrossmintHostedCheckout
        recipient={{
            walletAddress: "0x1234567890abcdef1234567890abcdef12345678", // For EVM chains
            // walletAddress: "5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty", // For Solana
        }}
        lineItems={{
            collectionLocator: `crossmint:YOUR_COLLECTION_ID`,
            callData: {
                totalPrice: "0.0001",
                quantity: 1,
            },
        }}
        payment={{
            crypto: { enabled: true },
            fiat: { enabled: true },
        }}
    />
</CrossmintProvider>
```

### Physical Product Recipients

<Snippet />

When purchasing physical products, you can specify a physical address for delivery:

```jsx React {3-13} theme={null}
<CrossmintProvider apiKey="YOUR_API_KEY">
    <CrossmintHostedCheckout
        recipient={{
            email: "user@example.com",
            physicalAddress: {
                name: "John Doe",
                line1: "123 Main St",
                line2: "Apt 4B", // optional
                city: "San Francisco",
                state: "CA",
                postalCode: "94105",
                country: "US",
            },
        }}
        projectId="YOUR_PROJECT_ID"
        collectionId="YOUR_COLLECTION_ID"
        environment="staging"
        mintConfig={{
            totalPrice: "0.0001",
            quantity: 1,
        }}
    />
</CrossmintProvider>
```


# Customize the Button UI
Source: https://docs.crossmint.com/payments/pay-button/guides/ui-customization

Modify the payment button and checkout experience to match your website's style

You can customize both the payment button and the checkout modal appearance using the `appearance` prop.

## Button Customization

### Theme Options

The button can be styled using predefined themes:

```tsx theme={null}
<CrossmintHostedCheckout
    appearance={{
        theme: {
            button: "light", // Options: "light", "dark", "crossmint"
        },
    }}
/>
```

### Custom Colors

Customize the button's accent color:

```tsx theme={null}
<CrossmintHostedCheckout
    appearance={{
        variables: {
            colors: {
                accent: "#FF0000", // Your custom color
            },
        },
    }}
/>
```

## Checkout Experience Customization

### Display Mode

Choose how the checkout appears:

```tsx theme={null}
<CrossmintHostedCheckout
    appearance={{
        display: "popup", // Options: "popup", "new-tab", "same-tab"
    }}
/>
```

### Theme

Set the checkout interface theme:

```tsx theme={null}
<CrossmintHostedCheckout
    appearance={{
        theme: {
            checkout: "dark", // Options: "light", "dark"
        },
    }}
/>
```

### Overlay Options

Control the modal overlay behavior:

```tsx theme={null}
<CrossmintHostedCheckout
    appearance={{
        overlay: {
            enabled: false, // Disable the dark overlay behind the modal
        },
    }}
/>
```

## Complete Styling Example

Here's an example combining multiple customization options:

```tsx theme={null}
<CrossmintHostedCheckout
    appearance={{
        theme: {
            button: "light",
            checkout: "dark",
        },
        variables: {
            colors: {
                accent: "#FF0000",
            },
        },
        display: "popup",
        overlay: {
            enabled: true,
        },
    }}
    // ... other props
/>
```

<Note>
  The appearance configuration allows you to: - Customize button and checkout themes independently - Set custom accent
  colors - Control how the checkout displays (popup/tab) - Manage overlay behavior
</Note>


# Overview
Source: https://docs.crossmint.com/payments/pay-button/overview

Add a button to your site which opens the checkout in a pop-up or new tab

<Frame type="simple">
  <img alt="Crossmint Hosted Checkout Demo" />
</Frame>

<Info>
  The hosted variant of checkout is only available for React applications. If you're using a different framework like
  Vite or React Native, you can use the [Headless version](/payments/headless/overview) instead.
</Info>

For general information about Crossmint's Payments product, see the [introduction](/payments/introduction). This guide
will focus on the features specific to the Hosted modality.

## When is Hosted Checkout the best fit?

* **You want to launch quickly and don't need deep customization or a fully native user experience**.

## Get Started

<CardGroup>
  <Card title="Quickstart" icon="bolt" href="/payments/pay-button/quickstart">
    Start selling digital assets in 5 minutes.
  </Card>

  <Card title="Talk to an expert" icon="message" href="https://www.crossmint.com/contact/sales">
    Contact our sales team for advanced support.
  </Card>

  <Card title="Join the Community" icon="users" href="https://t.me/crossmintdevs">
    Connect with other developers in our Telegram group.
  </Card>
</CardGroup>

## Advanced Topics

<CardGroup>
  <Card title="Marketplaces & Launchpads" icon="cart-shopping" href="/payments/advanced/marketplaces-and-launchpads" />

  <Card title="SDK Reference" icon="gear" href="/payments/embedded/reference/react" />

  <Card title="Purchasing Multiple Assets" icon="rectangle-vertical-history" href="/payments/pay-button/guides/item-selection#multiple-item-orders" />

  <Card title="Bring your own Collection" icon="file-import" href="/payments/guides/register-collection" />

  <Card title="USDC Contracts" icon="circle-dollar" href="/payments/advanced/usdc-support" />

  <Card title="Checkout Localization" icon="globe" href="/payments/pay-button/customize/localization" />

  <Card title="Webhooks" icon="bars-progress" href="/payments/advanced/webhooks" />

  <Card title="Testing Tips" icon="flask" href="/payments/advanced/testing-tips" />
</CardGroup>


# Quickstart ⚡
Source: https://docs.crossmint.com/payments/pay-button/quickstart

Accept payments in under 5 min by just adding a button to your frontend

<Frame type="simple">
  <img alt="Hosted Checkout Demo" />
</Frame>

## Introduction

In this guide, you will create a web app with Next.js which allows customers to buy digital assets with credit card and
crypto payments using Crossmint's hosted checkout. We will add a button that opens a checkout hosted in a pop-up or new
tab.

<Snippet />

<Snippet />

### Basic Integration

This quickstart guide focuses on NFT Collections/Drops (primary sales), but Crossmint also supports marketplace integrations.

<Steps>
  <Step title="Add environment variables">
    Create `.env.local` in your project root:

    ```sh theme={null}
    NEXT_PUBLIC_CLIENT_API_KEY="_YOUR_CLIENT_API_KEY_"    # From API Keys page
    NEXT_PUBLIC_COLLECTION_ID="_YOUR_COLLECTION_ID_"      # From Collection details page
    ```
  </Step>

  <Step title="Create the checkout page">
    Create `/src/app/page.tsx` with:

    ```tsx theme={null}
    "use client";

    import { CrossmintProvider, CrossmintHostedCheckout } from "@crossmint/client-sdk-react-ui";

    export default function Home() {
        const clientApiKey = process.env.NEXT_PUBLIC_CLIENT_API_KEY as string;
        const collectionId = process.env.NEXT_PUBLIC_COLLECTION_ID as string;

        return (
            <CrossmintProvider apiKey={clientApiKey}>
                <CrossmintHostedCheckout
                    lineItems={{
                        collectionLocator: `crossmint:${collectionId}`,
                        callData: {
                            totalPrice: "0.001",
                            quantity: 1,
                        },
                    }}
                    payment={{
                        crypto: { enabled: true },
                        fiat: { enabled: true },
                    }}
                />
            </CrossmintProvider>
        );
    }
    ```
  </Step>

  <Step title="Run your app">
    Navigate to the directory your package.json is to run the app

    ```bash theme={null}
    cd hosted-checkout/crossmint-hosted-checkout-demo
    ```

    <Snippet />
  </Step>
</Steps>

### (Optional) Advanced Integration

Need purchase tracking, multiple line items, or more customization? Here's a complete setup with additional features:

<Tabs>
  <Tab title="For NFT Collections/Drops">
    ```tsx theme={null}
    "use client";

    import { useEffect } from "react";
    import {
        CrossmintProvider,
        CrossmintCheckoutProvider,
        CrossmintHostedCheckout,
        useCrossmintCheckout,
    } from "@crossmint/client-sdk-react-ui";

    // Component with purchase tracking
    function Checkout() {
        const { order } = useCrossmintCheckout();
        const collectionId = process.env.NEXT_PUBLIC_COLLECTION_ID as string;

        useEffect(() => {
            if (order && order.phase === "completed") {
                console.log("Purchase completed!");
                // Handle successful purchase
            }
        }, [order]);

        return (
            <CrossmintHostedCheckout
                lineItems={[
                    {
                        collectionLocator: `crossmint:${collectionId}`,
                        callData: {
                            totalPrice: "0.001",
                            quantity: 1,
                        },
                    },
                    {
                        collectionLocator: `crossmint:${collectionId}`,
                        callData: {
                            totalPrice: "0.002",
                            quantity: 2,
                        },
                    },
            ]}
            appearance={{
                display: "new-tab", // Open in a new tab
                overlay: {
                    enabled: false, // Disable overlay
                },
                theme: {
                    button: "dark", // Dark button theme
                    checkout: "dark", // Dark checkout theme
                },
            }}
            payment={{
                crypto: {
                    enabled: true,
                    defaultChain: "polygon", // Set preferred blockchain
                    defaultCurrency: "matic", // Set preferred crypto
                },
                fiat: {
                    enabled: true,
                    defaultCurrency: "usd", // Set preferred fiat currency
                },
                receiptEmail: "receipt@example.com", // Optional: Set receipt email
            }}
            recipient={{
                email: "buyer@example.com", // Digital assets will be delivered to this email's wallet
                // Or use walletAddress: "0x..." for direct delivery
            }}
            locale="en-US" // Set interface language
        />
    );

    }

    // Main component with providers
    export default function Home() {
        const clientApiKey = process.env.NEXT_PUBLIC_CLIENT_API_KEY as string;

        return (
            <div className="flex flex-col items-center justify-start min-h-screen p-6">
                <CrossmintProvider apiKey={clientApiKey}>
                    <CrossmintCheckoutProvider>
                        <Checkout />
                    </CrossmintCheckoutProvider>
                </CrossmintProvider>
            </div>
        );
    }
    ```
  </Tab>

  <Tab title="For Marketplaces">
    ```tsx theme={null}
    "use client";

    import { useEffect } from "react";
    import {
        CrossmintProvider,
        CrossmintCheckoutProvider,
        CrossmintHostedCheckout,
        useCrossmintCheckout,
    } from "@crossmint/client-sdk-react-ui";

    // Component with purchase tracking
    function Checkout() {
        const { order } = useCrossmintCheckout();

        useEffect(() => {
            if (order && order.phase === "completed") {
                console.log("Purchase completed!");
                // Handle successful purchase
            }
        }, [order]);

        return (
            <CrossmintHostedCheckout
                lineItems={[
                    {
                        // For Solana NFTs
                        tokenLocator: "solana:4oDd...x6NC",
                        callData: {
                            totalPrice: "0.1",
                            buyerCreatorRoyaltyPercent: 100
                        }
                    },
                    {
                        // For EVM NFTs (Ethereum, Polygon, etc)
                        tokenLocator: "ethereum:0xbC...307e:7777",
                        callData: {
                            totalPrice: "0.2"
                        }
                    }
                ]}
                appearance={{
                    display: "new-tab", // Open in a new tab
                    overlay: {
                        enabled: false, // Disable overlay
                    },
                    theme: {
                        button: "dark", // Dark button theme
                        checkout: "dark", // Dark checkout theme
                    },
                }}
                payment={{
                    crypto: {
                        enabled: true,
                        defaultChain: "solana", // Set preferred blockchain
                        defaultCurrency: "sol", // Set preferred crypto
                    },
                    fiat: {
                        enabled: true,
                        defaultCurrency: "usd", // Set preferred fiat currency
                    },
                }}
                locale="en-US" // Set interface language
            />
        );
    }

    // Main component with providers
    export default function Home() {
        const clientApiKey = process.env.NEXT_PUBLIC_CLIENT_API_KEY as string;

        return (
            <div className="flex flex-col items-center justify-start min-h-screen p-6">
                <CrossmintProvider apiKey={clientApiKey}>
                    <CrossmintCheckoutProvider>
                        <Checkout />
                    </CrossmintCheckoutProvider>
                </CrossmintProvider>
            </div>
        );
    }
    ```
  </Tab>
</Tabs>

<Note>
  This advanced example showcases: - Multiple NFTs in one checkout - Purchase status tracking - Preferred payment
  methods and currencies - Email-based digital asset delivery - Language settings Learn more in our guides: - [Payment
  Methods](/payments/pay-button/guides/payment-methods) - [Multi-purchases](/payments/pay-button/guides/item-selection#multiple-item-orders)

  * [React Hooks](/payments/pay-button/guides/hooks)
</Note>

### Testing Your Integration

This demo uses the staging environment:

* Use [test credit cards](/payments/advanced/testing-tips#test-credit-card-numbers) for payments
* Get test USDC from our [faucet](/payments/advanced/testing-tips#getting-test-tokens)
* Check [price limits](/payments/advanced/testing-tips#limits-in-staging) for staging

## All Set!

You've successfully integrated a hosted checkout with credit card and crypto payment methods!

<Frame type="simple">
  <img />
</Frame>

<Note>
  Remember this demo is built on staging, so the digital assets will show up on the testnets. To launch on production,
  check the [production launch checklist](/payments/advanced/production-launch). You will need to contact
  [Sales](https://www.crossmint.com/contact/sales) to enable the embedded checkout on production.
</Note>

## Next Steps

### Customize the UI and Behavior Further

<CardGroup>
  <Card title="UI Customization" icon="paintbrush" href="/payments/pay-button/guides/ui-customization">
    Learn how to customize the look and feel of the checkout button
  </Card>

  <Card title="Payment Methods" icon="credit-card" href="/payments/pay-button/guides/payment-methods">
    Configure available payment options for your users
  </Card>

  <Card title="React Hooks" icon="code" href="/payments/pay-button/guides/hooks">
    Use React hooks to build custom checkout experiences
  </Card>
</CardGroup>

### Advanced Topics

<CardGroup>
  <Card title="SDK Reference" icon="gear" href="/payments/embedded/reference/react" />

  <Card title="Launch in Production" icon="ship" href="/payments/advanced/production-launch" />

  <Card title="Localization" icon="globe" href="/payments/pay-button/customize/localization" />

  <Card title="Multi-purchases" icon="cart-plus" href="/payments/pay-button/guides/item-selection#multiple-item-orders" />

  <Card title="Marketplaces" icon="store" href="/payments/advanced/marketplaces-and-launchpads" />

  <Card title="Testing Tips" icon="flask" href="/payments/advanced/testing-tips" />
</CardGroup>


# React
Source: https://docs.crossmint.com/payments/pay-button/reference/react

React SDK reference for Hosted Checkout component properties

## Properties

<ResponseField name="lineItems" type="object | array">
  Specifies the assets to purchase. Can be a single item or array of items.

  <Accordion title="lineItems properties">
    <ResponseField name="collectionLocator" type="string">
      Collection identifier in one of these formats:

      * `crossmint:<_YOUR_COLLECTION_ID_>[:_TEMPLATE_ID_]` - For collections created in Crossmint Console
        * Template ID is optional and requires template minting to be enabled
        * If template minting is disabled and a template ID is provided, the mint will select a template randomly
      * `<blockchain>:<contract-address>` - For collections using direct contract addresses (e.g., `polygon-amoy:0xF3d2d7b5666f579DcE385b2d53c54AB1b09Ef563`)

      <Note>
        When using template minting, append the templateId to the collection locator: `crossmint:collectionId:templateId`.
        Template minting must be enabled in the Crossmint Console or the mint will select a template randomly.
        See the [Mint to Specific Template guide](/payments/advanced/mint-to-specific-template) for details on enabling template minting and error handling.
      </Note>
    </ResponseField>

    <ResponseField name="tokenLocator" type="string">
      For secondary sales (buying existing assets). Token identifier in one of these formats:

      * EVM chains: `<blockchain>:<contractAddress>:<tokenId>`
      * Solana: `<blockchain>:<tokenAddress>`

      <Note>Using `tokenLocator` doesn't require registering the collection in Crossmint Console.</Note>

      <Warning>Use either `collectionLocator` (for primary sales) or `tokenLocator` (for secondary sales), not both.</Warning>
    </ResponseField>

    <ResponseField name="callData" type="object">
      Arguments passed to your contract's mint function:

      ```solidity Solidity theme={null}
      // Example mint function
      function mint(
        address to,  // Auto-filled by Crossmint
        uint256 quantity,
        uint256 totalPrice
      ) public payable {
        // ...
      }
      ```

      <Warning>Parameter names must match your contract's function arguments exactly.</Warning>

      <Check>Do not pass the recipient argument (e.g. `to`) in callData. Crossmint handles this automatically.</Check>
    </ResponseField>
  </Accordion>
</ResponseField>

<ResponseField name="payment" type="object">
  Configuration for payment methods.

  <Accordion title="payment properties">
    <ResponseField name="crypto" type="object">
      Crypto payment settings:

      ```tsx theme={null}
      {
        enabled: true,  // Enable/disable crypto payments
        defaultChain?: string, // Optional: e.g., "ethereum", "polygon", "solana"
        defaultCurrency?: string // Optional: e.g., "eth", "usdc"
      }
      ```

      <Note>
        For the complete list of supported chains, see [Supported Chains](/introduction/supported-chains).
      </Note>
    </ResponseField>

    <ResponseField name="fiat" type="object">
      Card & wallet payment settings:

      ```tsx theme={null}
      {
        enabled: true,  // Enable/disable fiat payments
        defaultCurrency?: string  // Optional: e.g., "usd", "eur", "gbp"
      }
      ```

      <Note>
        Crossmint supports multiple fiat currencies. Contact our [support team](https://help.crossmint.com) for the complete list of available currencies.
      </Note>
    </ResponseField>

    <ResponseField name="receiptEmail" type="string">
      Optional email address where purchase receipt will be sent
    </ResponseField>

    <ResponseField name="defaultMethod" type="string">
      Sets the default payment tab: `fiat` or `crypto`
    </ResponseField>
  </Accordion>
</ResponseField>

<ResponseField name="recipient" type="object">
  Delivery details for the assets. You must specify either email OR wallet address, not both:

  <Accordion title="recipient properties">
    <ResponseField name="email" type="string">
      Assets delivered to user's Crossmint wallet linked to this email
    </ResponseField>

    <ResponseField name="walletAddress" type="string">
      Assets delivered directly to this blockchain address
    </ResponseField>
  </Accordion>

  When not provided, user will be prompted during checkout.
</ResponseField>

<ResponseField name="locale" type="string">
  Sets the checkout interface language.

  `en-US` `de-DE` `es-ES` `fr-FR` `it-IT` `ja-JP` `ko-KR` `pt-PT` `ru-RU` `th-TH` `tr-TR` `uk-UA` `vi-VN` `zh-CN` `zh-TW` `Klingon`
</ResponseField>

<ResponseField name="appearance" type="object">
  Customization options for the hosted checkout. See our [UI Customization guide](/payments/pay-button/guides/ui-customization) for complete details.

  **Notable appearance options:**

  * Display mode: `display: "popup" | "new-tab"` (default: "popup")
  * Background overlay: `overlay.enabled: false` to disable the gray background
  * Button theme: `theme.button: "light" | "dark" | "crossmint"` (default: "light")
  * Checkout theme: `theme.checkout: "light" | "dark"` (default: "light")
</ResponseField>


# Plan Your Integration
Source: https://docs.crossmint.com/payments/plan-your-solution

Walk through key decisions to design your Crossmint Checkout integration

Crossmint Checkout supports multiple asset types and integration modalities. This guide helps you make key decisions for your integration.

## 1. Select the asset type you're selling

<CardGroup>
  <Card title="Memecoins" icon="coins" />

  <Card title="Closed-loop tokens" icon="rotate" />

  <Card title="NFTs" icon="hexagon-vertical-nft" />
</CardGroup>

Learn more about the types of assets that can be supported <a href="https://help.crossmint.com/articles/8719615099-which-tokens-are-supported-with-crossmint-checkout#supported-assets">here</a>.

## 2. Choose an integration modality

Crossmint checkout can be integrated into your application in three different ways, ranging from a bare metal headless
API with maximum UI flexibility, to a low-code hosted solution.

| Modality                                                       | Description                                                                                              | Integration Complexity    | Supported Platforms | Recommended For                                                                         |
| :------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------- | :------------------------ | :------------------ | :-------------------------------------------------------------------------------------- |
| [Headless](/payments/headless/overview)                        | Buy or sell using a REST API. Puts additional work on your side.                                         | \~500 Lines of Code (LOC) | Everywhere          | Best suited for backend flows and platforms not natively supported by other modalities. |
| [Embedded (strongly recommended)](/payments/embedded/overview) | Embed a checkout natively within your app. Handles orchestration, errors, and has better approval rates. | \~100 LOC                 | React, WebView      | E-commerce sites, token marketplaces, embedded finance                                  |
| [Hosted](/payments/pay-button/overview)                        | Add a button to your app that opens a checkout in a separate tab or window.                              | \~10 LOC                  | Web                 | One-off integrations for an event, quick prototypes                                     |

<Note>Embedded Checkout is generally recommended. It yields experiences that feel completely native while handling PSP orchestration and error management, and offering better approval rates.</Note>

## 3. Choose payment method(s)

You can choose multiple options from the following payment methods to include. Consider the following as you decide:

* Is your audience crypto-native or mainstream consumers familiar with fiat payments?
* What level of optionality do you want to enable? Adding many methods may add complexity during a user's checkout flow.

| Payment Method           | Description                                                                      | Best For                                   |
| :----------------------- | :------------------------------------------------------------------------------- | :----------------------------------------- |
| **Debit & Credit Cards** | All major credit cards supported - Visa, Mastercard, American Express, and more. | Mainstream consumers, global accessibility |
| **Apple & Google Pay**   | Check out in under 30 seconds with faster payment methods.                       | Mobile-first users, quick transactions     |
| **Stablecoins**          | Pay with USDC, USDT, and other stablecoins for lower transaction fees.           | Crypto-native users, lower fees            |
| **Cross-Chain Crypto**   | Pay with any token, on any chain.                                                | Multi-chain users, existing crypto holders |

<Note>Stablecoins and cross-chain crypto not supported for memecoin checkout.</Note>

## 4. (For NFTs only) Do you need to create or import an existing collection?

**Choose one:** Do you want to create a new NFT collection or import an existing one?

<CardGroup>
  <Card title="Create New" icon="plus" href="/payments/guides/create-collection">
    Use our templates in the Console
  </Card>

  <Card title="Import Existing" icon="download" href="/payments/guides/register-collection">
    Connect your deployed smart contract
  </Card>
</CardGroup>

## Get Started

<CardGroup>
  <Card title="Hosted Checkout" icon="toggle-on" href="/payments/pay-button/overview">
    Launch a Crossmint-hosted checkout page in a pop-up
  </Card>

  <Card title="Embedded Checkout" icon="object-group" href="/payments/embedded/overview">
    Import Crossmint checkout components in your application
  </Card>

  <Card title="Headless" icon="code" href="/payments/headless/overview">
    Buy or sell via an API, best suited for agents or deep UI customization
  </Card>
</CardGroup>


# ContractMetadataService
Source: https://docs.crossmint.com/sdk-reference/credentials/classes/ContractMetadataService



Service for retrieving and managing contract metadata.

## Constructors

### new ContractMetadataService()

> **new ContractMetadataService**(`chain`): [`ContractMetadataService`](./ContractMetadataService)

Initializes a new instance of the ContractMetadataService.

#### Parameters

| Parameter | Type                                 | Description                |
| --------- | ------------------------------------ | -------------------------- |
| `chain`   | [`VCChain`](../type-aliases/VCChain) | The blockchain to be used. |

#### Returns

[`ContractMetadataService`](./ContractMetadataService)

#### Defined in

[verifiableCredentialsSDK/presentation/contractMetadata.ts:20](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/presentation/contractMetadata.ts#L20)

## Properties

| Property | Type                                 | Description                                       | Defined in                                                                                                                                                                                                                    |
| -------- | ------------------------------------ | ------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `chain`  | [`VCChain`](../type-aliases/VCChain) | The blockchain on which the contract is deployed. | [verifiableCredentialsSDK/presentation/contractMetadata.ts:14](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/presentation/contractMetadata.ts#L14) |

## Methods

### getContractMetadata()

> **getContractMetadata**(`contractAddress`): `Promise`\<`any`>

Retrieves metadata for a given contract.

#### Parameters

| Parameter         | Type     | Description                  |
| ----------------- | -------- | ---------------------------- |
| `contractAddress` | `string` | The address of the contract. |

#### Returns

`Promise`\<`any`>

The metadata object or `null` if the contractURI call returns null.

#### Throws

Will throw an error if the retrieval process fails.

#### Defined in

[verifiableCredentialsSDK/presentation/contractMetadata.ts:31](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/presentation/contractMetadata.ts#L31)

***

### getContractsWithCredentialMetadata()

> **getContractsWithCredentialMetadata**(`collections`): `Promise`\<[`CredentialsCollection`](../interfaces/CredentialsCollection)\[]>

Retrieves metadata for multiple contracts and filters those that are verifiable credentials collections.

#### Parameters

| Parameter     | Type                                        | Description                                            |
| ------------- | ------------------------------------------- | ------------------------------------------------------ |
| `collections` | [`Collection`](../interfaces/Collection)\[] | An array of collections containing contract addresses. |

#### Returns

`Promise`\<[`CredentialsCollection`](../interfaces/CredentialsCollection)\[]>

A promise that resolves to an array of collections with valid verifiable credential metadata.

#### Throws

Will continue to the next collection if an error occurs during metadata retrieval.

#### Defined in

[verifiableCredentialsSDK/presentation/contractMetadata.ts:48](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/presentation/contractMetadata.ts#L48)


# CredentialService
Source: https://docs.crossmint.com/sdk-reference/credentials/classes/CredentialService



Service for managing and retrieving verifiable credentials from different sources. By default, it includes procedures for IPFS and Crossmint, but additional procedures can be added by the user.

* CredentialService().getById(credentialId: string) : Fetches the credential from crossmint using the credentialId.
* CredentialService().getCredential(collection: CredentialsCollection, tokenId: string) : Fetches the credential from the source that matches the storage location of the credential.

## Remarks

To use the Crossmint procedure, a Crossmint API key with the `credentials.read` scope must be set.

## Extends

* `CredentialService`

## Constructors

### new CredentialService()

> **new CredentialService**(`retrievalProcedures`): [`CredentialService`](./CredentialService)

#### Parameters

| Parameter             | Type                              |
| --------------------- | --------------------------------- |
| `retrievalProcedures` | `CredentialRetrievalProcedure`\[] |

#### Returns

[`CredentialService`](./CredentialService)

#### Overrides

`CredentialServiceRaw.constructor`

#### Defined in

[presentation/getCredential.ts:100](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/presentation/getCredential.ts#L100)

## Properties

| Property              | Type                              | Inherited from                             | Defined in                                                                                                                                                                                                              |
| --------------------- | --------------------------------- | ------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `retrievalProcedures` | `CredentialRetrievalProcedure`\[] | `CredentialServiceRaw.retrievalProcedures` | [verifiableCredentialsSDK/presentation/getCredential.ts:45](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/presentation/getCredential.ts#L45) |

## Methods

### getById()

> **getById**(`credentialId`): `Promise`\<`null` | [`VerifiableCredentialType`](../type-aliases/VerifiableCredentialType)>

Retrieves a verifiable credential from Crossmint using its credential ID.

#### Parameters

| Parameter      | Type     | Description                           |
| -------------- | -------- | ------------------------------------- |
| `credentialId` | `string` | The ID of the credential to retrieve. |

#### Returns

`Promise`\<`null` | [`VerifiableCredentialType`](../type-aliases/VerifiableCredentialType)>

A promise that resolves to a `VerifiableCredentialType` or `null` if the credential is not found.

#### Throws

Will throw an error if the credential retrieval fails.

#### Defined in

[presentation/getCredential.ts:112](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/presentation/getCredential.ts#L112)

***

### getCredential()

> **getCredential**(`collection`, `tokenId`): `Promise`\<[`VerifiableCredentialType`](../type-aliases/VerifiableCredentialType)>

Retrieves a Verifiable Credential from a given collection and token ID.

This function finds the appropriate retrieval procedure based on the collection's metadata and uses it to fetch the credential.

#### Parameters

| Parameter    | Type                                                           | Description                                                       |
| ------------ | -------------------------------------------------------------- | ----------------------------------------------------------------- |
| `collection` | [`CredentialsCollection`](../interfaces/CredentialsCollection) | The `CredentialsCollection` containing the credential's metadata. |
| `tokenId`    | `string`                                                       | The token ID of the credential to retrieve.                       |

#### Returns

`Promise`\<[`VerifiableCredentialType`](../type-aliases/VerifiableCredentialType)>

A promise that resolves to a `VerifiableCredentialType`.

#### Throws

Will throw an error if the collection is not a verifiable credential collection or if the retrieval endpoint is unsupported.

#### Inherited from

`CredentialServiceRaw.getCredential`

#### Defined in

[verifiableCredentialsSDK/presentation/getCredential.ts:65](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/presentation/getCredential.ts#L65)


# CrossmintDecrypt
Source: https://docs.crossmint.com/sdk-reference/credentials/classes/CrossmintDecrypt



Class for decrypting verifiable credentials that have been encrypted with the `VerifiableCredentialEncryptionType.CROSSMINT_RECOVERABLE` encryption type.

This class uses a provided signature callback to authenticate the user and decrypt the credential.
To use the Crossmint decrypt endpoint, an API key with the `credentials.decrypt` scope must be provided.

## Constructors

### new CrossmintDecrypt()

> **new CrossmintDecrypt**(`userAddress`, `signCallback`, `authService`): [`CrossmintDecrypt`](./CrossmintDecrypt)

#### Parameters

| Parameter      | Type                                            |
| -------------- | ----------------------------------------------- |
| `userAddress`  | `string`                                        |
| `signCallback` | (`wallet`, `challenge`) => `Promise`\<`string`> |
| `authService`  | [`WalletAuthService`](./WalletAuthService)      |

#### Returns

[`CrossmintDecrypt`](./CrossmintDecrypt)

#### Defined in

[decryption/wallet.ts:25](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/decryption/wallet.ts#L25)

## Properties

| Property       | Type                                                                | Description                                                          | Defined in                                                                                                                                          |
| -------------- | ------------------------------------------------------------------- | -------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
| `signCallback` | (`wallet`: `string`, `challenge`: `string`) => `Promise`\<`string`> | A callback function that signs the challenge with the user's wallet. | [decryption/wallet.ts:24](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/decryption/wallet.ts#L24) |
| `userAddress`  | `string`                                                            | -                                                                    | [decryption/wallet.ts:16](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/decryption/wallet.ts#L16) |

## Methods

### decrypt()

> **decrypt**(`credential`): `Promise`\<[`VerifiableCredential`](../interfaces/VerifiableCredential)>

Decrypts an encrypted verifiable credential.

This method validates the decrypted data to ensure it is a valid verifiable credential.

#### Parameters

| Parameter    | Type                                                                           | Description                                     |
| ------------ | ------------------------------------------------------------------------------ | ----------------------------------------------- |
| `credential` | [`EncryptedVerifiableCredential`](../interfaces/EncryptedVerifiableCredential) | The encrypted verifiable credential to decrypt. |

#### Returns

`Promise`\<[`VerifiableCredential`](../interfaces/VerifiableCredential)>

A promise that resolves to a `VerifiableCredential`.

#### Throws

Will throw an error if the decrypted data is not a valid verifiable credential.

#### Defined in

[decryption/wallet.ts:52](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/decryption/wallet.ts#L52)


# CrossmintMetamaskDecrypt
Source: https://docs.crossmint.com/sdk-reference/credentials/classes/CrossmintMetamaskDecrypt



Class for decrypting verifiable credentials encrypted with the `VerifiableCredentialEncryptionType.CROSSMINT_RECOVERABLE` encryption type using Metamask.

This class uses Metamask to prompt the user to sign a message to decrypt the credential.
If you want to use a different signature method, refer to the `CrossmintDecrypt` class.
To use the Crossmint decrypt endpoint, an API key with the `credentials.decrypt` scope must be provided.

## Constructors

### new CrossmintMetamaskDecrypt()

> **new CrossmintMetamaskDecrypt**(`metamask`): [`CrossmintMetamaskDecrypt`](./CrossmintMetamaskDecrypt)

#### Parameters

| Parameter  | Type              |
| ---------- | ----------------- |
| `metamask` | `MetamaskService` |

#### Returns

[`CrossmintMetamaskDecrypt`](./CrossmintMetamaskDecrypt)

#### Defined in

[decryption/wallet.ts:69](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/decryption/wallet.ts#L69)

## Methods

### decrypt()

> **decrypt**(`credential`, `wallet`?): `Promise`\<[`VerifiableCredential`](../interfaces/VerifiableCredential)>

Decrypts an encrypted verifiable credential using Metamask.

This method prompts the user via Metamask to sign the necessary message for decrypting the credential.

#### Parameters

| Parameter    | Type                                                                           | Description                                                                                                     |
| ------------ | ------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------- |
| `credential` | [`EncryptedVerifiableCredential`](../interfaces/EncryptedVerifiableCredential) | The encrypted verifiable credential to decrypt.                                                                 |
| `wallet`?    | `string`                                                                       | (Optional) The user's wallet address. If not provided, the connected wallet address from Metamask will be used. |

#### Returns

`Promise`\<[`VerifiableCredential`](../interfaces/VerifiableCredential)>

A promise that resolves to a `VerifiableCredential`.

#### Throws

Will throw an error if decryption fails or if Metamask is not properly configured.

#### Defined in

[decryption/wallet.ts:84](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/decryption/wallet.ts#L84)


# Lit
Source: https://docs.crossmint.com/sdk-reference/credentials/classes/Lit



Lit class for decrypting verifiable credentials that have been encrypted with the
VerifiableCredentialEncryptionType.DECENTRALIZED\_LIT encryption type.

## Extends

* `Lit`

## Constructors

### new Lit()

> **new Lit**(`network`, `capacityDelegationAuthSig`?, `debug`?): [`Lit`](./Lit)

Creates an instance of the Lit class for decrypting verifiable credentials.

#### Parameters

| Parameter                    | Type                                       | Default value | Description                                                                                                                                                                                                                                                  |
| ---------------------------- | ------------------------------------------ | ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `network`                    | `"habanero"` \| `"manzano"` \| `"cayenne"` | `undefined`   | The network on which the credentials are encrypted (use CredentialMetadata.encryption.details.network).                                                                                                                                                      |
| `capacityDelegationAuthSig`? | `AuthSig`                                  | `undefined`   | The capacity delegation signature used to pay for decrypting the credentials. If not provided, the Crossmint signature will be used. To use the Crossmint delegation signature, the user must have provided an API key with the `credentials.decrypt` scope. |
| `debug`?                     | `boolean`                                  | `false`       | If true, enables debug mode for additional logging.                                                                                                                                                                                                          |

#### Returns

[`Lit`](./Lit)

#### Overrides

`LitRaw.constructor`

#### Defined in

[decryption/lit.ts:27](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/decryption/lit.ts#L27)

## Methods

### connect()

> **connect**(): `Promise`\<`LitNodeClient`>

#### Returns

`Promise`\<`LitNodeClient`>

#### Inherited from

`LitRaw.connect`

#### Defined in

[verifiableCredentialsSDK/encryption/lit.ts:50](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/encryption/lit.ts#L50)

***

### decrypt()

> **decrypt**(`credential`): `Promise`\<[`VerifiableCredential`](../interfaces/VerifiableCredential)>

Decrypts a verifiable credential that has been encrypted with the Lit protocol.
The user will be prompted to sign a message to decrypt the credential.

#### Parameters

| Parameter    | Type                                                                           | Description                                     |
| ------------ | ------------------------------------------------------------------------------ | ----------------------------------------------- |
| `credential` | [`EncryptedVerifiableCredential`](../interfaces/EncryptedVerifiableCredential) | The encrypted verifiable credential to decrypt. |

#### Returns

`Promise`\<[`VerifiableCredential`](../interfaces/VerifiableCredential)>

A promise that resolves to the decrypted verifiable credential.

#### Overrides

`LitRaw.decrypt`

#### Defined in

[decryption/lit.ts:49](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/decryption/lit.ts#L49)


# WalletAuthService
Source: https://docs.crossmint.com/sdk-reference/credentials/classes/WalletAuthService



Service for handling wallet-based authentication and decryption with Crossmint.

The `WalletAuthService` class provides methods to retrieve a challenge for wallet authentication and to decrypt credentials using that challenge.

## Constructors

### new WalletAuthService()

> **new WalletAuthService**(): [`WalletAuthService`](./WalletAuthService)

#### Returns

[`WalletAuthService`](./WalletAuthService)

## Methods

### decrypt()

> **decrypt**(`credential`, `challenge`, `signature`, `userAddress`): `Promise`\<`any`>

Decrypts an encrypted verifiable credential using a signed challenge.

This method sends the signed challenge, the user's address, and the encrypted credential to Crossmint for decryption.

#### Parameters

| Parameter     | Type                                                                           | Description                                                 |
| ------------- | ------------------------------------------------------------------------------ | ----------------------------------------------------------- |
| `credential`  | [`EncryptedVerifiableCredential`](../interfaces/EncryptedVerifiableCredential) | The encrypted verifiable credential to decrypt.             |
| `challenge`   | `string`                                                                       | The challenge that was signed by the user's wallet.         |
| `signature`   | `string`                                                                       | The signature of the challenge signed by the user's wallet. |
| `userAddress` | `string`                                                                       | The blockchain address of the user requesting decryption.   |

#### Returns

`Promise`\<`any`>

A promise that resolves to the decrypted data.

#### Throws

Will throw an error if the decryption request fails or if the response is invalid.

#### Defined in

[services/walletAuth.ts:57](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/services/walletAuth.ts#L57)

***

### getChallenge()

> **getChallenge**(`userAddress`): `Promise`\<`string`>

Retrieves a challenge nonce for wallet authentication.

This method requests a challenge from Crossmint that can be signed by the user's wallet to authenticate the user.

#### Parameters

| Parameter     | Type     | Description                                                  |
| ------------- | -------- | ------------------------------------------------------------ |
| `userAddress` | `string` | The blockchain address of the user requesting the challenge. |

#### Returns

`Promise`\<`string`>

A promise that resolves to a string representing the challenge to sign.

#### Throws

Will throw an error if the challenge request fails or if the response is invalid.

#### Defined in

[services/walletAuth.ts:20](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/services/walletAuth.ts#L20)


# VerifiableCredentialEncryptionType
Source: https://docs.crossmint.com/sdk-reference/credentials/enumerations/VerifiableCredentialEncryptionType



VerifiableCredentialEncryptionType defines the types of encryption used for the credentials.

## Enumeration Members

### CROSSMINT\_RECOVERABLE

> **CROSSMINT\_RECOVERABLE**: `"crossmint-recoverable"`

Wallet based encryption that is recoverable via Crossmint.

#### Defined in

[verifiableCredentialsSDK/types/collection.ts:114](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/collection.ts#L114)

***

### DECENTRALIZED\_LIT

> **DECENTRALIZED\_LIT**: `"decentralized-lit"`

Decentralized encryption using the Lit protocol.

#### Defined in

[verifiableCredentialsSDK/types/collection.ts:109](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/collection.ts#L109)

***

### NONE

> **NONE**: `"none"`

No encryption applied to the verifiable credentials.

#### Defined in

[verifiableCredentialsSDK/types/collection.ts:104](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/collection.ts#L104)


# getCredentialNFTFromLocator
Source: https://docs.crossmint.com/sdk-reference/credentials/functions/getCredentialNFTFromLocator



> **getCredentialNFTFromLocator**(`locator`): `Promise`\<`object`>

Retrieves a Verifiable Credential NFT from a locator.

This function performs the following steps:

1. Parses the locator string to extract NFT details.
2. Verifies that the NFT belongs to a supported Verifiable Credentials chain.
3. Fetches the NFT's metadata and verifies it belongs to a Verifiable Credentials collection.
4. Returns the NFT and the corresponding credentials collection.

## Parameters

| Parameter | Type     | Description                                                                                                                                        |
| --------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
| `locator` | `string` | The locator string of the credential, formatted as "chain:contractAddress:tokenId" (e.g., "polygon:0x1B887669437644aA348c518844660ef8d63bd643:1"). |

## Returns

`Promise`\<`object`>

An object containing:

* `collection`: The collection that the NFT belongs to, including the credential metadata.
* `nft`: The NFT with its metadata.

### collection

> **collection**: [`CredentialsCollection`](../interfaces/CredentialsCollection)

### nft

> **nft**: `NftWithMetadata` = `vcNft`

## Throws

Will throw an error if the NFT is not on a supported Verifiable Credentials chain or if the NFT is not associated with a Verifiable Credentials collection.

## Defined in

[verifiableCredentialsSDK/presentation/nftByLocator.ts:25](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/presentation/nftByLocator.ts#L25)


# getCredentialNfts
Source: https://docs.crossmint.com/sdk-reference/credentials/functions/getCredentialNfts



> **getCredentialNfts**(`chain`, `wallet`, `filters`): `Promise`\<[`CredentialsCollection`](../interfaces/CredentialsCollection)\[]>

Get all the NFTs of a given user that are verifiable credentials
To use this method an api key with the `credentials.read` scope must have been provided.

## Parameters

| Parameter | Type                                                 | Description                                                                          |
| --------- | ---------------------------------------------------- | ------------------------------------------------------------------------------------ |
| `chain`   | [`VCChain`](../type-aliases/VCChain)                 | Chain to get the NFTs from                                                           |
| `wallet`  | `string`                                             | Wallet address of the user                                                           |
| `filters` | [`CredentialFilter`](../interfaces/CredentialFilter) | Filters to select only desired credentials (i.e. credential type, credential issuer) |

## Returns

`Promise`\<[`CredentialsCollection`](../interfaces/CredentialsCollection)\[]>

* List CredentialsCollection that match the filters each containing a list of nfts

## Defined in

[presentation/getCredentialNfts.ts:18](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/presentation/getCredentialNfts.ts#L18)


# isCredentialType
Source: https://docs.crossmint.com/sdk-reference/credentials/functions/isCredentialType



> **isCredentialType**(`obj`): `obj is VerifiableCredentialType`

Checks if an object is of type `VerifiableCredential` or `EncryptedVerifiableCredential`.

## Parameters

| Parameter | Type  | Description          |
| --------- | ----- | -------------------- |
| `obj`     | `any` | The object to check. |

## Returns

`obj is VerifiableCredentialType`

`true` if the object is of type `VerifiableCredential` or `EncryptedVerifiableCredential`, otherwise `false`.

## Defined in

[verifiableCredentialsSDK/types/utils.ts:35](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/utils.ts#L35)


# isEncryptedVerifiableCredential
Source: https://docs.crossmint.com/sdk-reference/credentials/functions/isEncryptedVerifiableCredential



> **isEncryptedVerifiableCredential**(`credential`): `credential is EncryptedVerifiableCredential`

Checks if an object is an `EncryptedVerifiableCredential`.

## Parameters

| Parameter    | Type                                                                   | Description                     |
| ------------ | ---------------------------------------------------------------------- | ------------------------------- |
| `credential` | [`VerifiableCredentialType`](../type-aliases/VerifiableCredentialType) | The credential object to check. |

## Returns

`credential is EncryptedVerifiableCredential`

`true` if the object is a valid `EncryptedVerifiableCredential`, otherwise `false`.

## Throws

Will throw an error if the object does not have a valid structure for a verifiable credential.

## Defined in

[verifiableCredentialsSDK/types/utils.ts:93](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/utils.ts#L93)


# isVcChain
Source: https://docs.crossmint.com/sdk-reference/credentials/functions/isVcChain



> **isVcChain**(`chain`): `chain is VCChain`

Checks if a string is a valid and supported chain for VCs.

## Parameters

| Parameter | Type     | Description                |
| --------- | -------- | -------------------------- |
| `chain`   | `string` | The chain string to check. |

## Returns

`chain is VCChain`

`true` if the string is a valid `VCChain`, otherwise `false`.

## Defined in

[verifiableCredentialsSDK/types/utils.ts:111](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/utils.ts#L111)


# isVerifiableCredential
Source: https://docs.crossmint.com/sdk-reference/credentials/functions/isVerifiableCredential



> **isVerifiableCredential**(`credential`): `credential is VerifiableCredential`

Checks if an object is a `VerifiableCredential`.

## Parameters

| Parameter    | Type                                                                   | Description                     |
| ------------ | ---------------------------------------------------------------------- | ------------------------------- |
| `credential` | [`VerifiableCredentialType`](../type-aliases/VerifiableCredentialType) | The credential object to check. |

## Returns

`credential is VerifiableCredential`

`true` if the object is a valid `VerifiableCredential`, otherwise `false`.

## Defined in

[verifiableCredentialsSDK/types/utils.ts:55](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/utils.ts#L55)


# verifyCredential
Source: https://docs.crossmint.com/sdk-reference/credentials/functions/verifyCredential



> **verifyCredential**(`credential`): `Promise`\<`object`>

Verify a Verifiable Credential

This function checks the validity of a given Verifiable Credential (VC) by performing several checks:

1. Ensures the `validUntil` date is a valid ISO string and not expired.
2. Verifies the cryptographic proof attached to the credential.
3. Checks if the associated NFT has been revoked (burned).

## Parameters

| Parameter    | Type                                                         | Description                     |
| ------------ | ------------------------------------------------------------ | ------------------------------- |
| `credential` | [`VerifiableCredential`](../interfaces/VerifiableCredential) | the credential object to verify |

## Returns

`Promise`\<`object`>

* `error`: A string with the error message if the credential is invalid, or `undefined` if the credential is valid.
* `validVC`: A boolean indicating if the credential is valid.

### error

> **error**: `string` | `undefined`

### validVC

> **validVC**: `boolean`

## Throws

Will throw an error if `validUntil` is present and is not a valid ISO string or if the date is invalid.

## Defined in

[verifiableCredentialsSDK/verification/verify.ts:22](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/verification/verify.ts#L22)


# Collection
Source: https://docs.crossmint.com/sdk-reference/credentials/interfaces/Collection



Collection represents a generic collection of NFTs.

## Extended by

* [`CredentialsCollection`](./CredentialsCollection)

## Properties

### chain

> **chain**: [`VCChain`](../type-aliases/VCChain)

The blockchain chain on which the contract is deployed.

#### Defined in

[verifiableCredentialsSDK/types/collection.ts:21](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/collection.ts#L21)

***

### contractAddress

> **contractAddress**: `string`

Address of the contract associated with the collection.

#### Defined in

[verifiableCredentialsSDK/types/collection.ts:16](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/collection.ts#L16)

***

### metadata

> **metadata**: `any`

Metadata associated with the collection.

#### Defined in

[verifiableCredentialsSDK/types/collection.ts:26](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/collection.ts#L26)

***

### nfts

> **nfts**: [`VCNFT`](./VCNFT)\[]

List of NFTs within the collection.

#### Defined in

[verifiableCredentialsSDK/types/collection.ts:11](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/collection.ts#L11)


# CredentialFilter
Source: https://docs.crossmint.com/sdk-reference/credentials/interfaces/CredentialFilter



CredentialFilter defines the criteria for filtering credentials.

## Properties

### issuers?

> `optional` **issuers**: `string`\[]

List of issuers to filter by.

#### Example

```ts theme={null}
["did:polygon-amoy:0x1B887669437644aA348c518844660ef8d63bd643"];
```

#### Defined in

[verifiableCredentialsSDK/types/credentialFilter.ts:9](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/credentialFilter.ts#L9)

***

### types?

> `optional` **types**: `string`\[]

List of accepted credential types.

#### Example

```ts theme={null}
["driving_license", "crossmint:e62564a7-06eb-4f65-b389-eb3b7a4f6f98:userAge"];
```

#### Defined in

[verifiableCredentialsSDK/types/credentialFilter.ts:15](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/credentialFilter.ts#L15)


# CredentialMetadata
Source: https://docs.crossmint.com/sdk-reference/credentials/interfaces/CredentialMetadata



CredentialMetadata represents credentials-specific metadata inside the contract metadata.

## Properties

### credentialsEndpoint

> **credentialsEndpoint**: `string`

Endpoint to fetch the credentials.

#### Defined in

[verifiableCredentialsSDK/types/collection.ts:70](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/collection.ts#L70)

***

### encryption

> **encryption**: [`VerifiableCredentialEncryption`](./VerifiableCredentialEncryption)

Specifies the encryption type used for the credentials in the collection.

#### Defined in

[verifiableCredentialsSDK/types/collection.ts:65](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/collection.ts#L65)

***

### issuerDid

> **issuerDid**: `string`

The DID (Decentralized Identifier) of the issuer of the credentials for this collection.

#### Defined in

[verifiableCredentialsSDK/types/collection.ts:75](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/collection.ts#L75)

***

### type

> **type**: `string`\[]

Specifies the types of credentials in the collection.

#### Defined in

[verifiableCredentialsSDK/types/collection.ts:60](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/collection.ts#L60)


# CredentialsCollection
Source: https://docs.crossmint.com/sdk-reference/credentials/interfaces/CredentialsCollection



CredentialsCollection represents a collection of credential NFTs.

## Extends

* [`Collection`](./Collection)

## Properties

### chain

> **chain**: [`VCChain`](../type-aliases/VCChain)

The blockchain chain on which the contract is deployed.

#### Inherited from

[`Collection`](./Collection).[`chain`](./Collection#chain)

#### Defined in

[verifiableCredentialsSDK/types/collection.ts:21](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/collection.ts#L21)

***

### contractAddress

> **contractAddress**: `string`

Address of the contract associated with the collection.

#### Inherited from

[`Collection`](./Collection).[`contractAddress`](./Collection#contractaddress)

#### Defined in

[verifiableCredentialsSDK/types/collection.ts:16](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/collection.ts#L16)

***

### metadata

> **metadata**: `VCContractMetadata`

Metadata of the contract, including credential-specific metadata.

#### Overrides

[`Collection`](./Collection).[`metadata`](./Collection#metadata)

#### Defined in

[verifiableCredentialsSDK/types/collection.ts:40](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/collection.ts#L40)

***

### nfts

> **nfts**: [`VCNFT`](./VCNFT)\[]

List of NFTs within the collection.

#### Inherited from

[`Collection`](./Collection).[`nfts`](./Collection#nfts)

#### Defined in

[verifiableCredentialsSDK/types/collection.ts:11](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/collection.ts#L11)


# EncryptedVerifiableCredential
Source: https://docs.crossmint.com/sdk-reference/credentials/interfaces/EncryptedVerifiableCredential



## Properties

### id

> **id**: `string`

#### Defined in

[verifiableCredentialsSDK/types/verifiableCredential.ts:18](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/verifiableCredential.ts#L18)

***

### payload

> **payload**: `string`

#### Defined in

[verifiableCredentialsSDK/types/verifiableCredential.ts:19](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/verifiableCredential.ts#L19)


# VCNFT
Source: https://docs.crossmint.com/sdk-reference/credentials/interfaces/VCNFT



## Properties

### chain

> **chain**: [`VCChain`](../type-aliases/VCChain)

#### Defined in

[verifiableCredentialsSDK/types/nft.ts:4](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/nft.ts#L4)

***

### contractAddress

> **contractAddress**: `string`

#### Defined in

[verifiableCredentialsSDK/types/nft.ts:5](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/nft.ts#L5)

***

### tokenId

> **tokenId**: `string`

#### Defined in

[verifiableCredentialsSDK/types/nft.ts:6](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/nft.ts#L6)


# VerifiableCredential
Source: https://docs.crossmint.com/sdk-reference/credentials/interfaces/VerifiableCredential



## Properties

### @context

> **@context**: `string`\[]

#### Defined in

[verifiableCredentialsSDK/types/verifiableCredential.ts:13](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/verifiableCredential.ts#L13)

***

### credentialSubject

> **credentialSubject**: `any`

#### Defined in

[verifiableCredentialsSDK/types/verifiableCredential.ts:5](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/verifiableCredential.ts#L5)

***

### description?

> `optional` **description**: `string`

#### Defined in

[verifiableCredentialsSDK/types/verifiableCredential.ts:8](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/verifiableCredential.ts#L8)

***

### id

> **id**: `string`

#### Defined in

[verifiableCredentialsSDK/types/verifiableCredential.ts:4](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/verifiableCredential.ts#L4)

***

### issuer

> **issuer**: `object`

#### id

> **id**: `string`

#### Defined in

[verifiableCredentialsSDK/types/verifiableCredential.ts:10](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/verifiableCredential.ts#L10)

***

### name?

> `optional` **name**: `string`

#### Defined in

[verifiableCredentialsSDK/types/verifiableCredential.ts:7](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/verifiableCredential.ts#L7)

***

### nft

> **nft**: [`VCNFT`](./VCNFT)

#### Defined in

[verifiableCredentialsSDK/types/verifiableCredential.ts:9](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/verifiableCredential.ts#L9)

***

### proof?

> `optional` **proof**: `object`

#### Index Signature

\[`key`: `string`]: `any`

#### proofValue

> **proofValue**: `string`

#### Defined in

[verifiableCredentialsSDK/types/verifiableCredential.ts:14](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/verifiableCredential.ts#L14)

***

### type

> **type**: `string`\[]

#### Defined in

[verifiableCredentialsSDK/types/verifiableCredential.ts:11](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/verifiableCredential.ts#L11)

***

### validFrom

> **validFrom**: `string`

#### Defined in

[verifiableCredentialsSDK/types/verifiableCredential.ts:12](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/verifiableCredential.ts#L12)

***

### validUntil?

> `optional` **validUntil**: `string`

#### Defined in

[verifiableCredentialsSDK/types/verifiableCredential.ts:6](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/verifiableCredential.ts#L6)


# VerifiableCredentialEncryption
Source: https://docs.crossmint.com/sdk-reference/credentials/interfaces/VerifiableCredentialEncryption



VerifiableCredentialEncryption defines the encryption settings for verifiable credentials collection.

## Properties

### details?

> `optional` **details**: `LitEncryptionDetails`

Optional additional details about the encryption useful for decryption.

#### Defined in

[verifiableCredentialsSDK/types/collection.ts:90](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/collection.ts#L90)

***

### type

> **type**: [`VerifiableCredentialEncryptionType`](../enumerations/VerifiableCredentialEncryptionType)

Specifies the type of encryption used for the verifiable credentials.

#### Defined in

[verifiableCredentialsSDK/types/collection.ts:85](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/collection.ts#L85)


# Introduction
Source: https://docs.crossmint.com/sdk-reference/credentials/introduction



The Verifiable Credentials Client SDK is a powerful tool for managing verifiable credentials. It simplifies several key processes, making it easier to work with these credentials.

<Note> NOTE: The SDK can be used also server-side.</Note>

You can download the SDK from [here](https://www.npmjs.com/package/@crossmint/client-sdk-verifiable-credentials).

The SDK assists with the following processes:

* **Verification**: The SDK provides a straightforward method to verify any given credential.

* **Presentation**: By inputting a user's wallet address, the SDK allows you to retrieve all credentials issued to that address. It also provides a filtering option for easy navigation through the credentials.

* **Decryption**: In case of encrypted credentials, the SDK enables you to decrypt a credential for a specific user interacting with the lit protocol.

Generate a client-side-api-key from the Crossmint console: Go to the `Developers -> API Keys` tab, click on `New API Key` in the `Client-side keys` section, and select the scopes `credentials.read` and `credentials.decrypt`.

```typescript theme={null}
import { CrossmintAPI } from "@crossmint/verifiable-credentials";

CrossmintAPI.init("<api_key>");
```

## SDK Reference Table of Contents

### Classes

* [ContractMetadataService](./classes/ContractMetadataService)
* [CredentialService](./classes/CredentialService)
* [CrossmintDecrypt](./classes/CrossmintDecrypt)
* [CrossmintMetamaskDecrypt](./classes/CrossmintMetamaskDecrypt)
* [Lit](./classes/Lit)
* [WalletAuthService](./classes/WalletAuthService)

### Interfaces

* [Collection](./interfaces/Collection)
* [CredentialFilter](./interfaces/CredentialFilter)
* [CredentialMetadata](./interfaces/CredentialMetadata)
* [CredentialsCollection](./interfaces/CredentialsCollection)
* [EncryptedVerifiableCredential](./interfaces/EncryptedVerifiableCredential)
* [VCNFT](./interfaces/VCNFT)
* [VerifiableCredential](./interfaces/VerifiableCredential)
* [VerifiableCredentialEncryption](./interfaces/VerifiableCredentialEncryption)

### Type Aliases

* [ChainRPCConfig](./type-aliases/ChainRPCConfig)
* [VCChain](./type-aliases/VCChain)
* [VerifiableCredentialType](./type-aliases/VerifiableCredentialType)

### Variables

* [VCChain](./variables/VCChain)
* [crossmintAPI](./variables/crossmintAPI)
* [crossmintRetrievalProcedure](./variables/crossmintRetrievalProcedure)
* [ipfsRetrievalProcedure](./variables/ipfsRetrievalProcedure)

### Functions

* [getCredentialNFTFromLocator](./functions/getCredentialNFTFromLocator)
* [getCredentialNfts](./functions/getCredentialNfts)
* [isCredentialType](./functions/isCredentialType)
* [isEncryptedVerifiableCredential](./functions/isEncryptedVerifiableCredential)
* [isVcChain](./functions/isVcChain)
* [isVerifiableCredential](./functions/isVerifiableCredential)
* [verifyCredential](./functions/verifyCredential)

### Enumerations

* [VerifiableCredentialEncryptionType](./enumerations/VerifiableCredentialEncryptionType)


# ChainRPCConfig
Source: https://docs.crossmint.com/sdk-reference/credentials/type-aliases/ChainRPCConfig



> **ChainRPCConfig**: `Record`\<[`VCChain`](./VCChain), `string`>

ChainRPCConfig is a mapping of blockchain chains to their respective RPC endpoints.

## Example

```ts theme={null}
const config: ChainRPCConfig = {
    polygon: "https://polygon.llamarpc.com/",
};
```

## Defined in

[verifiableCredentialsSDK/types/chain.ts:17](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/chain.ts#L17)


# VCChain
Source: https://docs.crossmint.com/sdk-reference/credentials/type-aliases/VCChain



> **VCChain**: *typeof* [`VCChain`](../variables/VCChain)\[keyof *typeof* [`VCChain`](../variables/VCChain)]

## Defined in

[verifiableCredentialsSDK/types/chain.ts:1](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/chain.ts#L1)


# VerifiableCredentialType
Source: https://docs.crossmint.com/sdk-reference/credentials/type-aliases/VerifiableCredentialType



> **VerifiableCredentialType**: [`VerifiableCredential`](../interfaces/VerifiableCredential) | [`EncryptedVerifiableCredential`](../interfaces/EncryptedVerifiableCredential)

VerifiableCredentialType
A wrapper type for VerifiableCredential and EncryptedVerifiableCredential

## Defined in

[verifiableCredentialsSDK/types/verifiableCredential.ts:26](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/verifiableCredential.ts#L26)


# VCChain
Source: https://docs.crossmint.com/sdk-reference/credentials/variables/VCChain



> `const` **VCChain**: `object`

## Type declaration

### POLYGON

> `readonly` **POLYGON**: `"polygon"` = `"polygon"`

### POLYGON\_AMOY

> `readonly` **POLYGON\_AMOY**: `"polygon-amoy"` = `"polygon-amoy"`

### POLY\_AMOY

> `readonly` **POLY\_AMOY**: `"poly-amoy"` = `"poly-amoy"`

## Defined in

[verifiableCredentialsSDK/types/chain.ts:1](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/types/chain.ts#L1)


# crossmintAPI
Source: https://docs.crossmint.com/sdk-reference/credentials/variables/crossmintAPI



> `const` **crossmintAPI**: `CrossmintAPI`

Crossmint API singleton, used to init the SDK
To use the SDK you must call `init` before any other method

## Example

```typescript theme={null}
crossmintAPI.init(
 "your-api-key",
 config: \{
   environment: "staging",
   ipfsGateways: ["https://ipfs.io"], // Optional, a list of defualt ones is provided
   ipfsTimeout: 5000, // ms, Optional, default is 10 seconds
   blockchainRpcs: \{...\} // Optional, default rpcs for polygon are provided
 \}
)

## Defined in

[crossmintAPI.ts:124](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/crossmintAPI.ts#L124)
```


# crossmintRetrievalProcedure
Source: https://docs.crossmint.com/sdk-reference/credentials/variables/crossmintRetrievalProcedure



> `const` **crossmintRetrievalProcedure**: `CredentialRetrievalProcedure`

Crossmint retrieval procedure for credentials stored in Crossmint.

This procedure uses the Crossmint API to fetch credentials and matches all credentials that are stored in Crossmint.

## Remarks

This procedure requires a Crossmint API key with the `credentials.read` scope.

## Defined in

[presentation/getCredential.ts:83](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/presentation/getCredential.ts#L83)


# ipfsRetrievalProcedure
Source: https://docs.crossmint.com/sdk-reference/credentials/variables/ipfsRetrievalProcedure



> `const` **ipfsRetrievalProcedure**: `CredentialRetrievalProcedure`

Default retrieval procedure for ipfs, can be overridden by the user.
Will match all credentials with a retrieval endpoint starting with ipfs\://
Will use the ipfs gataways provided in SDK init to fetch the credential

## Defined in

[verifiableCredentialsSDK/presentation/getCredential.ts:34](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/client/verifiable-credentials/src/verifiableCredentialsSDK/presentation/getCredential.ts#L34)


# AndroidCrossmintTEE
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/classes/android-crossmint-tee

Kotlin Class

**Class**

```kotlin theme={null}
class AndroidCrossmintTEE : CrossmintTEE
```

## Properties

### isHandshakeCompleted

```kotlin theme={null}
open override val isHandshakeCompleted: Boolean
```

Indicates whether the handshake with the TEE service has been completed. Handshake must be completed before performing cryptographic operations.

### isOTPRequired

```kotlin theme={null}
open override val isOTPRequired: StateFlow<Boolean>
```

Observable state indicating whether the OTP prompt should be shown.

## Functions

### awaitReady

```kotlin theme={null}
open suspend override fun awaitReady()
```

Blocks continuation until a successful TEE load has completed. This method must be called before any signing operations.

### cancelOTP

```kotlin theme={null}
open override fun cancelOTP()
```

Resets isOTPRequired to emit false

### getWebView

```kotlin theme={null}
fun getWebView(): WebView?
```

### performHandshake

```kotlin theme={null}
open suspend override fun performHandshake(): Result<Unit, TEEError>
```

Performs the TEE handshake protocol. This is called automatically by load().

### provideOTP

```kotlin theme={null}
open override fun provideOTP(code: String)
```

Provides the OTP code from the user to the TEE flow.

### signTransaction

```kotlin theme={null}
open suspend override fun signTransaction(messageBytes: String, keyType: String, encoding: String, otp: String): Result<String, TEEError>
```


# AndroidWebViewBridge
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/classes/android-web-view-bridge

Kotlin Class

**Class**

```kotlin theme={null}
class AndroidWebViewBridge(context: Context, logger: Logger = Deps.logger) : WebViewBridge
```

## Constructors

```kotlin theme={null}
constructor(context: Context, logger: Logger = Deps.logger)
```

## Properties

### isLoaded

```kotlin theme={null}
open override val isLoaded: StateFlow<Boolean>
```

### messages

```kotlin theme={null}
open override val messages: SharedFlow<WebViewMessage>
```

## Functions

### getWebView

```kotlin theme={null}
fun getWebView(): WebView?
```

### loadUrl

```kotlin theme={null}
open suspend override fun loadUrl(url: String, timeout: Duration)
```

### reset

```kotlin theme={null}
open override fun reset()
```

### sendMessage

```kotlin theme={null}
open suspend override fun sendMessage(message: String)
```


# ApiKeyEnvironmentPrefix
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/classes/api-key-environment-prefix

Kotlin Class

**Class**

```kotlin theme={null}
class ApiKeyEnvironmentPrefix
```

## Entries

### DEVELOPMENT

### STAGING

### PRODUCTION

## Properties

### entries

```kotlin theme={null}
val entries: EnumEntries<ApiKeyEnvironmentPrefix>
```

Returns a representation of an immutable list of all enum entries, in the order they're declared.

### name

```kotlin theme={null}
val name: String
```

### ordinal

```kotlin theme={null}
val ordinal: Int
```

### value

```kotlin theme={null}
val value: String
```

## Functions

### valueOf

```kotlin theme={null}
fun valueOf(value: String): ApiKeyEnvironmentPrefix
```

Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)

### values

```kotlin theme={null}
fun values(): Array<ApiKeyEnvironmentPrefix>
```

Returns an array containing the constants of this enum type, in the order they're declared.


# Type
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/classes/api-key-type

Kotlin Class

**Class**

```kotlin theme={null}
class Type
```

## Entries

### CLIENT

### SERVER

## Properties

### entries

```kotlin theme={null}
val entries: EnumEntries<ApiKey.Type>
```

Returns a representation of an immutable list of all enum entries, in the order they're declared.

### name

```kotlin theme={null}
val name: String
```

### ordinal

```kotlin theme={null}
val ordinal: Int
```

## Functions

### valueOf

```kotlin theme={null}
fun valueOf(value: String): ApiKey.Type
```

Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)

### values

```kotlin theme={null}
fun values(): Array<ApiKey.Type>
```

Returns an array containing the constants of this enum type, in the order they're declared.


# ApiKeyUsageOriginPrefix
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/classes/api-key-usage-origin-prefix

Kotlin Class

**Class**

```kotlin theme={null}
class ApiKeyUsageOriginPrefix
```

## Entries

### CLIENT

### SERVER

## Properties

### entries

```kotlin theme={null}
val entries: EnumEntries<ApiKeyUsageOriginPrefix>
```

Returns a representation of an immutable list of all enum entries, in the order they're declared.

### name

```kotlin theme={null}
val name: String
```

### ordinal

```kotlin theme={null}
val ordinal: Int
```

### value

```kotlin theme={null}
val value: String
```

## Functions

### valueOf

```kotlin theme={null}
fun valueOf(value: String): ApiKeyUsageOriginPrefix
```

Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)

### values

```kotlin theme={null}
fun values(): Array<ApiKeyUsageOriginPrefix>
```

Returns an array containing the constants of this enum type, in the order they're declared.


# AuthSessionStore
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/classes/auth-session-store

Kotlin Class

**Class**

```kotlin theme={null}
class AuthSessionStore : SessionStore
```

## Constructors

```kotlin theme={null}
constructor()
```

## Functions

### clear

```kotlin theme={null}
open suspend override fun clear()
```

### token

```kotlin theme={null}
open suspend override fun token(): AuthToken?
```

### update

```kotlin theme={null}
open suspend override fun update(token: AuthToken?)
```


# ChainType
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/classes/chain-type

Kotlin Class

**Class**

```kotlin theme={null}
class ChainType
```

## Entries

### EVM

Ethereum Virtual Machine compatible chains

### SOLANA

Solana blockchain

### STELLAR

Stellar blockchain

### UNKNOWN

Unknown or unsupported chain type

## Properties

### chainName

```kotlin theme={null}
val chainName: String
```

### entries

```kotlin theme={null}
val entries: EnumEntries<ChainType>
```

Returns a representation of an immutable list of all enum entries, in the order they're declared.

### name

```kotlin theme={null}
val name: String
```

### ordinal

```kotlin theme={null}
val ordinal: Int
```

## Functions

### valueOf

```kotlin theme={null}
fun valueOf(value: String): ChainType
```

Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)

### values

```kotlin theme={null}
fun values(): Array<ChainType>
```

Returns an array containing the constants of this enum type, in the order they're declared.


# CheckoutEnvironment
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/classes/checkout-environment

Kotlin Class

**Class**

```kotlin theme={null}
class CheckoutEnvironment
```

## Entries

### STAGING

### PRODUCTION

## Properties

### entries

```kotlin theme={null}
val entries: EnumEntries<CheckoutEnvironment>
```

Returns a representation of an immutable list of all enum entries, in the order they're declared.

### name

```kotlin theme={null}
val name: String
```

### ordinal

```kotlin theme={null}
val ordinal: Int
```

## Functions

### valueOf

```kotlin theme={null}
fun valueOf(value: String): CheckoutEnvironment
```

Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)

### values

```kotlin theme={null}
fun values(): Array<CheckoutEnvironment>
```

Returns an array containing the constants of this enum type, in the order they're declared.


# EncodingError
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/classes/checkout-error-encoding-error

Kotlin Class

**Class**

```kotlin theme={null}
class EncodingError(message: String, cause: Throwable? = null) : CheckoutError
```

## Constructors

```kotlin theme={null}
constructor(message: String, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open val cause: Throwable?
```

### message

```kotlin theme={null}
open val message: String?
```


# InvalidConfiguration
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/classes/checkout-error-invalid-configuration

Kotlin Class

**Class**

```kotlin theme={null}
class InvalidConfiguration(message: String) : CheckoutError
```

## Constructors

```kotlin theme={null}
constructor(message: String)
```

## Properties

### cause

```kotlin theme={null}
open val cause: Throwable?
```

### message

```kotlin theme={null}
open val message: String?
```


# NotImplemented
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/classes/checkout-error-not-implemented

Kotlin Class

**Class**

```kotlin theme={null}
class NotImplemented(message: String) : CheckoutError
```

## Constructors

```kotlin theme={null}
constructor(message: String)
```

## Properties

### cause

```kotlin theme={null}
open val cause: Throwable?
```

### message

```kotlin theme={null}
open val message: String?
```


# Crossmint
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/classes/crossmint

Kotlin Class

**Class**

```kotlin theme={null}
class Crossmint
```

## Constructors

```kotlin theme={null}
constructor()
```


# CrossmintAuthManager
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/classes/crossmint-auth-manager

Kotlin Class

**Class**

```kotlin theme={null}
class CrossmintAuthManager
```

## Properties

### authState

```kotlin theme={null}
val authState: StateFlow<Result>
```

## Functions

### authenticateWithToken

```kotlin theme={null}
suspend fun authenticateWithToken(token: Result): Result<Unit, Result>
```

### getJWT

```kotlin theme={null}
open suspend fun getJWT(): String?
```

### logout

```kotlin theme={null}
suspend fun logout()
```

### sendOtp

```kotlin theme={null}
suspend fun sendOtp(email: String): Result<Result, Result>
```

### verifyOtp

```kotlin theme={null}
suspend fun verifyOtp(email: String, code: String): Result<Result, Result>
```


# CrossmintSDK
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/classes/crossmint-sdk

Kotlin Class

**Class**

```kotlin theme={null}
class CrossmintSDK
```

## Properties

### apiKey

```kotlin theme={null}
val apiKey: Result
```

### authManager

```kotlin theme={null}
val authManager: Result
```

### configuration

```kotlin theme={null}
val configuration: Result
```

### crossmintWallets

```kotlin theme={null}
val crossmintWallets: Result
```

### isOTPRequired

```kotlin theme={null}
val isOTPRequired: Flow<Boolean>
```

### isStaging

```kotlin theme={null}
val isStaging: Boolean
```

## Functions

### cancelTransaction

```kotlin theme={null}
suspend fun cancelTransaction()
```

### submit

```kotlin theme={null}
suspend fun submit(otp: String)
```


# EncryptedSharedPreferenceStorage
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/classes/encrypted-shared-preference-storage

Kotlin Class

**Class**

```kotlin theme={null}
class EncryptedSharedPreferenceStorage(context: Context) : SessionStore
```

## Constructors

```kotlin theme={null}
constructor(context: Context)
```

## Functions

### clear

```kotlin theme={null}
open suspend override fun clear()
```

### token

```kotlin theme={null}
open suspend override fun token(): AuthToken?
```

### update

```kotlin theme={null}
open suspend override fun update(token: AuthToken?)
```


# Environment
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/classes/environment

Kotlin Class

**Class**

```kotlin theme={null}
class Environment
```

## Entries

### DEVELOPMENT

### STAGING

### PRODUCTION

## Properties

### entries

```kotlin theme={null}
val entries: EnumEntries<Environment>
```

Returns a representation of an immutable list of all enum entries, in the order they're declared.

### name

```kotlin theme={null}
val name: String
```

### ordinal

```kotlin theme={null}
val ordinal: Int
```

### value

```kotlin theme={null}
val value: String
```

## Functions

### valueOf

```kotlin theme={null}
fun valueOf(value: String): Environment
```

Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)

### values

```kotlin theme={null}
fun values(): Array<Environment>
```

Returns an array containing the constants of this enum type, in the order they're declared.


# FallbackPolicy
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/classes/fallback-policy

Kotlin Class

**Class**

```kotlin theme={null}
class FallbackPolicy
```

## Entries

### MemoryOnly

### InsecurePersistent

## Properties

### entries

```kotlin theme={null}
val entries: EnumEntries<FallbackPolicy>
```

Returns a representation of an immutable list of all enum entries, in the order they're declared.

### name

```kotlin theme={null}
val name: String
```

### ordinal

```kotlin theme={null}
val ordinal: Int
```

## Functions

### valueOf

```kotlin theme={null}
fun valueOf(value: String): FallbackPolicy
```

Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)

### values

```kotlin theme={null}
fun values(): Array<FallbackPolicy>
```

Returns an array containing the constants of this enum type, in the order they're declared.


# InsecurePersistent
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/classes/fallback-policy-insecure-persistent

Kotlin Class

**Class**

```kotlin theme={null}
class InsecurePersistent
```

## Properties

### name

```kotlin theme={null}
val name: String
```

### ordinal

```kotlin theme={null}
val ordinal: Int
```


# MemoryOnly
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/classes/fallback-policy-memory-only

Kotlin Class

**Class**

```kotlin theme={null}
class MemoryOnly
```

## Properties

### name

```kotlin theme={null}
val name: String
```

### ordinal

```kotlin theme={null}
val ordinal: Int
```


# InsecurePersistentSessionStore
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/classes/insecure-persistent-session-store

Kotlin Class

**Class**

```kotlin theme={null}
class InsecurePersistentSessionStore(settings: Settings = defaultSettings()) : SessionStore
```

## Constructors

```kotlin theme={null}
constructor(settings: Settings = defaultSettings())
```

## Functions

### clear

```kotlin theme={null}
open suspend override fun clear()
```

### token

```kotlin theme={null}
open suspend override fun token(): AuthToken?
```

### update

```kotlin theme={null}
open suspend override fun update(token: AuthToken?)
```


# InvalidEnvironmentKeyException
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/classes/invalid-environment-key-exception

Kotlin Class

**Class**

```kotlin theme={null}
class InvalidEnvironmentKeyException : Exception
```

## Constructors

```kotlin theme={null}
constructor()
```

## Properties

### cause

```kotlin theme={null}
open val cause: Throwable?
```

### message

```kotlin theme={null}
open val message: String?
```


# JvmWebViewBridge
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/classes/jvm-web-view-bridge

Kotlin Class

**Class**

```kotlin theme={null}
class JvmWebViewBridge : WebViewBridge
```

## Constructors

```kotlin theme={null}
constructor()
```

## Properties

### isLoaded

```kotlin theme={null}
open override val isLoaded: StateFlow<Boolean>
```

### messages

```kotlin theme={null}
open override val messages: SharedFlow<WebViewMessage>
```

## Functions

### loadUrl

```kotlin theme={null}
open suspend override fun loadUrl(url: String, timeout: Duration)
```

### reset

```kotlin theme={null}
open override fun reset()
```

### sendMessage

```kotlin theme={null}
open suspend override fun sendMessage(message: String)
```


# MalformedKeyException
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/classes/malformed-key-exception

Kotlin Class

**Class**

```kotlin theme={null}
class MalformedKeyException(message: String) : Exception
```

## Constructors

```kotlin theme={null}
constructor(message: String)
```

## Properties

### cause

```kotlin theme={null}
open val cause: Throwable?
```

### message

```kotlin theme={null}
open val message: String?
```


# OldKeyException
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/classes/old-key-exception

Kotlin Class

**Class**

```kotlin theme={null}
class OldKeyException : Exception
```

## Constructors

```kotlin theme={null}
constructor()
```

## Properties

### cause

```kotlin theme={null}
open val cause: Throwable?
```

### message

```kotlin theme={null}
open val message: String?
```


# TinkSecureStorage
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/classes/tink-secure-storage

Kotlin Class

**Class**

```kotlin theme={null}
class TinkSecureStorage(context: Context, logger: Logger) : FailureAwareSessionStore
```

## Constructors

```kotlin theme={null}
constructor(context: Context, logger: Logger)
```

## Functions

### clear

```kotlin theme={null}
open suspend override fun clear()
```

### hasFailed

```kotlin theme={null}
open override fun hasFailed(): Boolean
```

Returns true if initialization has been attempted and failed. This can be used by wrapper classes to determine if fallback storage should be used.

### token

```kotlin theme={null}
open suspend override fun token(): AuthToken?
```

### update

```kotlin theme={null}
open suspend override fun update(token: AuthToken?)
```


# TinkWithFallbackSessionStore
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/classes/tink-with-fallback-session-store

Kotlin Class

**Class**

```kotlin theme={null}
class TinkWithFallbackSessionStore : SessionStore
```

## Constructors

```kotlin theme={null}
Public constructor for production use.
```

## Functions

### clear

```kotlin theme={null}
open suspend override fun clear()
```

### isPersistentStorageAvailable

```kotlin theme={null}
fun isPersistentStorageAvailable(): Boolean
```

Returns true if persistent storage is available. When using MemoryOnly fallback policy and fallback is active, this returns false.

### isUsingFallback

```kotlin theme={null}
fun isUsingFallback(): Boolean
```

Returns true if the store has fallen back to the alternative storage strategy. This can be used for logging, telemetry, or to inform users about degraded functionality.

### token

```kotlin theme={null}
open suspend override fun token(): AuthToken?
```

### update

```kotlin theme={null}
open suspend override fun update(token: AuthToken?)
```


# TransactionStatus
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/classes/transaction-status

Kotlin Class

**Class**

```kotlin theme={null}
class TransactionStatus
```

## Entries

### PENDING

### SUCCESS

### FAILED

### AWAITING\_APPROVAL

## Properties

### entries

```kotlin theme={null}
val entries: EnumEntries<TransactionStatus>
```

Returns a representation of an immutable list of all enum entries, in the order they're declared.

### name

```kotlin theme={null}
val name: String
```

### ordinal

```kotlin theme={null}
val ordinal: Int
```

## Functions

### valueOf

```kotlin theme={null}
fun valueOf(value: String): TransactionStatus
```

Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)

### values

```kotlin theme={null}
fun values(): Array<TransactionStatus>
```

Returns an array containing the constants of this enum type, in the order they're declared.


# Wallet
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/classes/wallet

Kotlin Class

**Class**

```kotlin theme={null}
class Wallet
```

## Properties

### address

```kotlin theme={null}
val address: String
```

The blockchain address of the wallet

### chainType

```kotlin theme={null}
val chainType: ChainType
```

The blockchain type (EVM, Solana, etc.)

### config

```kotlin theme={null}
val config: WalletConfig
```

The wallet configuration including admin signer

### owner

```kotlin theme={null}
val owner: Owner?
```

The owner of the wallet, if available

### type

```kotlin theme={null}
val type: WalletType
```

The type of wallet (smart wallet or MPC wallet)

## Functions

### approve

```kotlin theme={null}
suspend fun approve(transactionId: String, signer: Signer? = null): Result<Transaction, TransactionError>
```

Signs a transaction that is in AWAITING\_APPROVAL status.

### balances

```kotlin theme={null}
suspend fun balances(tokens: List<String> = emptyList()): Result<Balances, BalanceError>
```

Gets the wallet balances.

### getSigner

```kotlin theme={null}
fun getSigner(): Signer?
```

Returns the current signer for this wallet.

### getTransaction

```kotlin theme={null}
suspend fun getTransaction(transactionId: String): Result<Transaction, TransactionError>
```

Retrieves a transaction by its ID.

### send

```kotlin theme={null}
suspend fun send(recipient: String, tokenLocator: String, amount: Double, idempotencyKey: String? = null, signer: Signer? = null): Result<Transaction, TransactionError>
```

Sends tokens to a recipient address.

### withSigner

```kotlin theme={null}
fun withSigner(newSigner: Signer): Wallet
```

Creates a new Wallet instance that uses the specified signer for transactions.


# WalletType
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/classes/wallet-type

Kotlin Class

**Class**

```kotlin theme={null}
class WalletType
```

## Entries

### SMART\_WALLET

### MPC\_WALLET

## Properties

### entries

```kotlin theme={null}
val entries: EnumEntries<WalletType>
```

Returns a representation of an immutable list of all enum entries, in the order they're declared.

### name

```kotlin theme={null}
val name: String
```

### ordinal

```kotlin theme={null}
val ordinal: Int
```

## Functions

### valueOf

```kotlin theme={null}
fun valueOf(value: String): WalletType
```

Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)

### values

```kotlin theme={null}
fun values(): Array<WalletType>
```

Returns an array containing the constants of this enum type, in the order they're declared.


# WebViewNotAvailableException
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/classes/web-view-not-available-exception

Kotlin Class

**Class**

```kotlin theme={null}
class WebViewNotAvailableException(message: String) : Exception
```

## Constructors

```kotlin theme={null}
constructor(message: String)
```

## Properties

### cause

```kotlin theme={null}
open val cause: Throwable?
```

### message

```kotlin theme={null}
open val message: String?
```


# ApiKey
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/api-key

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class ApiKey(val key: String, val type: ApiKey.Type, val environment: Environment)
```

## Constructors

```kotlin theme={null}
constructor(key: String, type: ApiKey.Type, environment: Environment)
```

## Properties

### apiEnvironmentPathComponent

```kotlin theme={null}
val apiEnvironmentPathComponent: String
```

### environment

```kotlin theme={null}
val environment: Environment
```

### isProduction

```kotlin theme={null}
val isProduction: Boolean
```

### key

```kotlin theme={null}
val key: String
```

### type

```kotlin theme={null}
val type: ApiKey.Type
```


# InvalidEnvironmentKey
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/api-key-error-invalid-environment-key

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class InvalidEnvironmentKey(val message: String = "Invalid environment key", val cause: Throwable? = null) : ApiKeyError
```

## Constructors

```kotlin theme={null}
constructor(message: String = "Invalid environment key", cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# MalformedKey
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/api-key-error-malformed-key

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class MalformedKey(val message: String, val cause: Throwable? = null) : ApiKeyError
```

## Constructors

```kotlin theme={null}
constructor(message: String, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# OldKey
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/api-key-error-old-key

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class OldKey(val message: String = "Old API key format detected. Please use the new key format.", val cause: Throwable? = null) : ApiKeyError
```

## Constructors

```kotlin theme={null}
constructor(message: String = "Old API key format detected. Please use the new key format.", cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# Approval
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/approval

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Approval(val signer: String, val signature: ApprovalSignature, val metadata: ApprovalMetadata? = null)
```

## Constructors

```kotlin theme={null}
constructor(signer: String, signature: ApprovalSignature, metadata: ApprovalMetadata? = null)
```

## Properties

### metadata

```kotlin theme={null}
val metadata: ApprovalMetadata? = null
```

### signature

```kotlin theme={null}
val signature: ApprovalSignature
```

### signer

```kotlin theme={null}
val signer: String
```


# Passkey
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/approval-metadata-passkey

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Passkey(val authenticatorData: String, val clientDataJSON: String, val challengeIndex: Int = 23, val typeIndex: Int = 1, val userVerificationRequired: Boolean = true) : ApprovalMetadata
```

## Constructors

```kotlin theme={null}
constructor(authenticatorData: String, clientDataJSON: String, challengeIndex: Int = 23, typeIndex: Int = 1, userVerificationRequired: Boolean = true)
```

## Properties

### authenticatorData

```kotlin theme={null}
val authenticatorData: String
```

### challengeIndex

```kotlin theme={null}
val challengeIndex: Int = 23
```

### clientDataJSON

```kotlin theme={null}
val clientDataJSON: String
```

### typeIndex

```kotlin theme={null}
val typeIndex: Int = 1
```

### userVerificationRequired

```kotlin theme={null}
val userVerificationRequired: Boolean = true
```


# Passkey
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/approval-signature-passkey

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Passkey(val r: String, val s: String) : ApprovalSignature
```

## Constructors

```kotlin theme={null}
constructor(r: String, s: String)
```

## Properties

### r

```kotlin theme={null}
val r: String
```

### s

```kotlin theme={null}
val s: String
```


# Raw
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/approval-signature-raw

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Raw(val value: String) : ApprovalSignature
```

## Constructors

```kotlin theme={null}
constructor(value: String)
```

## Properties

### value

```kotlin theme={null}
val value: String
```


# Approvals
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/approvals

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Approvals(val pending: List<Approvals.PendingApproval>, val submitted: List<Approvals.SubmittedApproval>)
```

## Constructors

```kotlin theme={null}
constructor(pending: List<Approvals.PendingApproval>, submitted: List<Approvals.SubmittedApproval>)
```

## Properties

### pending

```kotlin theme={null}
val pending: List<Approvals.PendingApproval>
```

### submitted

```kotlin theme={null}
val submitted: List<Approvals.SubmittedApproval>
```


# PendingApproval
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/approvals-pending-approval

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class PendingApproval(val signer: String, val message: String)
```

## Constructors

```kotlin theme={null}
constructor(signer: String, message: String)
```

## Properties

### message

```kotlin theme={null}
val message: String
```

### signer

```kotlin theme={null}
val signer: String
```


# SubmittedApproval
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/approvals-submitted-approval

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class SubmittedApproval(val signature: String, val submittedAt: Long, val signer: String, val message: String)
```

## Constructors

```kotlin theme={null}
constructor(signature: String, submittedAt: Long, signer: String, message: String)
```

## Properties

### message

```kotlin theme={null}
val message: String
```

### signature

```kotlin theme={null}
val signature: String
```

### signer

```kotlin theme={null}
val signer: String
```

### submittedAt

```kotlin theme={null}
val submittedAt: Long
```


# InvalidCredentials
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/auth-error-invalid-credentials

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class InvalidCredentials(val message: String = "Invalid credentials", val cause: Throwable? = null) : AuthError
```

## Constructors

```kotlin theme={null}
constructor(message: String = "Invalid credentials", cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# NotInitialized
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/auth-error-not-initialized

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class NotInitialized(val message: String = "Auth not initialized", val cause: Throwable? = null) : AuthError
```

## Constructors

```kotlin theme={null}
constructor(message: String = "Auth not initialized", cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# RateLimited
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/auth-error-rate-limited

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class RateLimited(val message: String = "Rate limited", val cause: Throwable? = null) : AuthError
```

## Constructors

```kotlin theme={null}
constructor(message: String = "Rate limited", cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# ServerError
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/auth-error-server-error

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class ServerError(val message: String = "Server error", val statusCode: Int? = null, val cause: Throwable? = null) : AuthError
```

## Constructors

```kotlin theme={null}
constructor(message: String = "Server error", statusCode: Int? = null, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```

### statusCode

```kotlin theme={null}
val statusCode: Int? = null
```


# TokenExpired
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/auth-error-token-expired

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class TokenExpired(val message: String = "Token expired", val cause: Throwable? = null) : AuthError
```

## Constructors

```kotlin theme={null}
constructor(message: String = "Token expired", cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# Unauthorized
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/auth-error-unauthorized

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Unauthorized(val message: String = "Unauthorized", val cause: Throwable? = null) : AuthError
```

## Constructors

```kotlin theme={null}
constructor(message: String = "Unauthorized", cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# BalanceNotFound
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/balance-error-balance-not-found

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class BalanceNotFound(val message: String, val cause: Throwable? = null) : BalanceError
```

## Constructors

```kotlin theme={null}
constructor(message: String, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# BalanceOperationFailed
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/balance-error-balance-operation-failed

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class BalanceOperationFailed(val message: String, val cause: Throwable? = null) : BalanceError
```

## Constructors

```kotlin theme={null}
constructor(message: String, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# Forbidden
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/balance-error-forbidden

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Forbidden(val message: String, val cause: Throwable? = null) : BalanceError
```

## Constructors

```kotlin theme={null}
constructor(message: String, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# RateLimited
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/balance-error-rate-limited

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class RateLimited(val message: String, val cause: Throwable? = null) : BalanceError
```

## Constructors

```kotlin theme={null}
constructor(message: String, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# ServiceNotInitialized
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/balance-error-service-not-initialized

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class ServiceNotInitialized(val message: String = "Balance service not initialized", val cause: Throwable? = null) : BalanceError
```

## Constructors

```kotlin theme={null}
constructor(message: String = "Balance service not initialized", cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# Unauthorized
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/balance-error-unauthorized

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Unauthorized(val message: String, val cause: Throwable? = null) : BalanceError
```

## Constructors

```kotlin theme={null}
constructor(message: String, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# Balances
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/balances

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Balances(val nativeToken: TokenBalance, val usdc: TokenBalance, val tokens: List<TokenBalance>)
```

## Constructors

```kotlin theme={null}
constructor(nativeToken: TokenBalance, usdc: TokenBalance, tokens: List<TokenBalance>)
```

## Properties

### nativeToken

```kotlin theme={null}
val nativeToken: TokenBalance
```

### tokens

```kotlin theme={null}
val tokens: List<TokenBalance>
```

### usdc

```kotlin theme={null}
val usdc: TokenBalance
```


# Call
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/call

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Call(val to: String, val value: String, val data: String)
```

## Constructors

```kotlin theme={null}
constructor(to: String, value: String, data: String)
```

## Properties

### data

```kotlin theme={null}
val data: String
```

### to

```kotlin theme={null}
val to: String
```

### value

```kotlin theme={null}
val value: String
```


# Solana
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/chain-info-solana

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Solana(val mintHash: String?) : ChainInfo
```

## Constructors

```kotlin theme={null}
constructor(mintHash: String?)
```

## Properties

### mintHash

```kotlin theme={null}
val mintHash: String?
```


# Stellar
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/chain-info-stellar

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Stellar(val contractId: String?) : ChainInfo
```

## Constructors

```kotlin theme={null}
constructor(contractId: String?)
```

## Properties

### contractId

```kotlin theme={null}
val contractId: String?
```


# Unknown
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/chain-unknown

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Unknown(val name: String) : Chain
```

## Constructors

```kotlin theme={null}
constructor(name: String)
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open override fun isValid(isProductionEnvironment: Boolean): Boolean
```


# Configuration
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/configuration

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Configuration(val apiKey: ApiKey, val appIdentifier: () -> String?)
```

## Constructors

```kotlin theme={null}
constructor(apiKey: ApiKey, appIdentifier: () -> String?)
```

## Properties

### apiKey

```kotlin theme={null}
val apiKey: ApiKey
```

### appIdentifier

```kotlin theme={null}
val appIdentifier: () -> String?
```

### baseUrl

```kotlin theme={null}
val baseUrl: String
```


# ApiKey
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/delegated-signer-api-key

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class ApiKey(val expiresAt: Long? = null) : DelegatedSigner
```

## Constructors

```kotlin theme={null}
constructor(expiresAt: Long? = null)
```

## Properties

### expiresAt

```kotlin theme={null}
open override val expiresAt: Long? = null
```

Optional expiration timestamp in milliseconds since Unix epoch. If set, the delegated signer will expire at this time.


# DelegatedSignerData
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/delegated-signer-data

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class DelegatedSignerData(val locator: String)
```

## Constructors

```kotlin theme={null}
constructor(locator: String)
```

## Properties

### identifier

```kotlin theme={null}
val identifier: String
```

The signer identifier extracted from the locator (e.g., email address, phone number, wallet address). Returns the full locator if no type prefix is present.

### locator

```kotlin theme={null}
val locator: String
```

### type

```kotlin theme={null}
val type: String?
```

The signer type extracted from the locator (e.g., "email", "phone", "external-wallet"). Returns null if the locator doesn't contain a type prefix.

## Functions

### toSignerData

```kotlin theme={null}
fun toSignerData(): SignerData?
```

Converts this delegated signer data to SignerData if possible. Only email and phone signers can be converted (non-custodial signers). Returns null for passkey, api-key, and external-wallet signers as they require additional credentials.


# Email
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/delegated-signer-email

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Email(val email: String, val expiresAt: Long? = null) : DelegatedSigner
```

## Constructors

```kotlin theme={null}
constructor(email: String, expiresAt: Long? = null)
```

## Properties

### email

```kotlin theme={null}
val email: String
```

### expiresAt

```kotlin theme={null}
open override val expiresAt: Long? = null
```

Optional expiration timestamp in milliseconds since Unix epoch. If set, the delegated signer will expire at this time.


# ExternalWallet
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/delegated-signer-external-wallet

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class ExternalWallet(val address: String, val expiresAt: Long? = null) : DelegatedSigner
```

## Constructors

```kotlin theme={null}
constructor(address: String, expiresAt: Long? = null)
```

## Properties

### address

```kotlin theme={null}
val address: String
```

### expiresAt

```kotlin theme={null}
open override val expiresAt: Long? = null
```

Optional expiration timestamp in milliseconds since Unix epoch. If set, the delegated signer will expire at this time.


# Locator
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/delegated-signer-locator

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Locator(val locator: String, val expiresAt: Long? = null) : DelegatedSigner
```

## Constructors

```kotlin theme={null}
constructor(locator: String, expiresAt: Long? = null)
```

## Properties

### expiresAt

```kotlin theme={null}
open override val expiresAt: Long? = null
```

Optional expiration timestamp in milliseconds since Unix epoch. If set, the delegated signer will expire at this time.

### locator

```kotlin theme={null}
val locator: String
```


# Passkey
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/delegated-signer-passkey

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Passkey(val id: String, val name: String, val publicKeyX: String, val publicKeyY: String, val expiresAt: Long? = null) : DelegatedSigner
```

## Constructors

```kotlin theme={null}
constructor(id: String, name: String, publicKeyX: String, publicKeyY: String, expiresAt: Long? = null)
```

## Properties

### expiresAt

```kotlin theme={null}
open override val expiresAt: Long? = null
```

Optional expiration timestamp in milliseconds since Unix epoch. If set, the delegated signer will expire at this time.

### id

```kotlin theme={null}
val id: String
```

### name

```kotlin theme={null}
val name: String
```

### publicKeyX

```kotlin theme={null}
val publicKeyX: String
```

### publicKeyY

```kotlin theme={null}
val publicKeyY: String
```


# Phone
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/delegated-signer-phone

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Phone(val phoneNumber: String, val expiresAt: Long? = null) : DelegatedSigner
```

## Constructors

```kotlin theme={null}
constructor(phoneNumber: String, expiresAt: Long? = null)
```

## Properties

### expiresAt

```kotlin theme={null}
open override val expiresAt: Long? = null
```

Optional expiration timestamp in milliseconds since Unix epoch. If set, the delegated signer will expire at this time.

### phoneNumber

```kotlin theme={null}
val phoneNumber: String
```


# EVMTransactionParams
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/evm-transaction-params

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class EVMTransactionParams(val calls: List<Call>, val chain: EVMChain, val signer: String) : TransactionParams
```

## Constructors

```kotlin theme={null}
constructor(calls: List<Call>, chain: EVMChain, signer: String)
```

## Properties

### calls

```kotlin theme={null}
val calls: List<Call>
```

### chain

```kotlin theme={null}
val chain: EVMChain
```

### signer

```kotlin theme={null}
open override val signer: String
```


# FeeConfig
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/fee-config

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class FeeConfig(val feePayer: String, val amount: String)
```

## Constructors

```kotlin theme={null}
constructor(feePayer: String, amount: String)
```

## Properties

### amount

```kotlin theme={null}
val amount: String
```

### feePayer

```kotlin theme={null}
val feePayer: String
```


# ConnectionError
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/network-error-connection-error

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class ConnectionError(val message: String, val cause: Throwable? = null) : NetworkError
```

## Constructors

```kotlin theme={null}
constructor(message: String, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# HttpError
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/network-error-http-error

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class HttpError(val statusCode: Int, val message: String, val cause: Throwable? = null) : NetworkError
```

## Constructors

```kotlin theme={null}
constructor(statusCode: Int, message: String, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```

### statusCode

```kotlin theme={null}
val statusCode: Int
```


# ParseError
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/network-error-parse-error

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class ParseError(val message: String, val cause: Throwable? = null) : NetworkError
```

## Constructors

```kotlin theme={null}
constructor(message: String, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# ServiceNotInitialized
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/network-error-service-not-initialized

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class ServiceNotInitialized(val message: String = "Service not initialized", val cause: Throwable? = null) : NetworkError
```

## Constructors

```kotlin theme={null}
constructor(message: String = "Service not initialized", cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# TimeoutError
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/network-error-timeout-error

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class TimeoutError(val message: String, val cause: Throwable? = null) : NetworkError
```

## Constructors

```kotlin theme={null}
constructor(message: String, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# UnknownError
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/network-error-unknown-error

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class UnknownError(val message: String, val cause: Throwable? = null) : NetworkError
```

## Constructors

```kotlin theme={null}
constructor(message: String, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# OnChainData
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/on-chain-data

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class OnChainData(val userOperation: UserOperation?, val userOperationHash: String?, val explorerLink: String?, val txId: String?, val transaction: String?, val lastValidBlockHeight: Int?)
```

## Constructors

```kotlin theme={null}
constructor(userOperation: UserOperation?, userOperationHash: String?, explorerLink: String?, txId: String?, transaction: String?, lastValidBlockHeight: Int?)
```

## Properties

### explorerLink

```kotlin theme={null}
val explorerLink: String?
```

### lastValidBlockHeight

```kotlin theme={null}
val lastValidBlockHeight: Int?
```

### transaction

```kotlin theme={null}
val transaction: String?
```

### txId

```kotlin theme={null}
val txId: String?
```

### userOperation

```kotlin theme={null}
val userOperation: UserOperation?
```

### userOperationHash

```kotlin theme={null}
val userOperationHash: String?
```


# Address
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/owner-address

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Address(val value: String) : Owner
```

## Constructors

```kotlin theme={null}
constructor(value: String)
```

## Properties

### value

```kotlin theme={null}
val value: String
```


# Email
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/owner-email

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Email(val value: String) : Owner
```

## Constructors

```kotlin theme={null}
constructor(value: String)
```

## Properties

### value

```kotlin theme={null}
val value: String
```


# PhoneNumber
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/owner-phone-number

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class PhoneNumber(val value: String) : Owner
```

## Constructors

```kotlin theme={null}
constructor(value: String)
```

## Properties

### value

```kotlin theme={null}
val value: String
```


# Twitter
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/owner-twitter

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Twitter(val value: String) : Owner
```

## Constructors

```kotlin theme={null}
constructor(value: String)
```

## Properties

### value

```kotlin theme={null}
val value: String
```


# UserId
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/owner-user-id

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class UserId(val value: String) : Owner
```

## Constructors

```kotlin theme={null}
constructor(value: String)
```

## Properties

### value

```kotlin theme={null}
val value: String
```


# Failure
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/result-failure

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Failure<E>(val error: E) : Result<Nothing, E>
```

## Constructors

```kotlin theme={null}
constructor(error: E)
```

## Properties

### error

```kotlin theme={null}
val error: E
```

## Functions

### flatMap

```kotlin theme={null}
inline fun <T, E, R> Result<T, E>.flatMap(transform: (T) -> Result<R, E>): Result<R, E>
```

### fold

```kotlin theme={null}
inline fun <T, E> Result<T, E>.fold(onSuccess: (T) -> Unit, onFailure: (E) -> Unit)
```

### getOrNull

```kotlin theme={null}
fun <T, E> Result<T, E>.getOrNull(): T?
```

### getOrThrow

```kotlin theme={null}
fun <T, E> Result<T, E>.getOrThrow(): T
```

### map

```kotlin theme={null}
inline fun <T, E, R> Result<T, E>.map(transform: (T) -> R): Result<R, E>
```

### mapError

```kotlin theme={null}
inline fun <T, E, F> Result<T, E>.mapError(transform: (E) -> F): Result<T, F>
```


# Success
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/result-success

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Success<T>(val value: T) : Result<T, Nothing>
```

## Constructors

```kotlin theme={null}
constructor(value: T)
```

## Properties

### value

```kotlin theme={null}
val value: T
```

## Functions

### flatMap

```kotlin theme={null}
inline fun <T, E, R> Result<T, E>.flatMap(transform: (T) -> Result<R, E>): Result<R, E>
```

### fold

```kotlin theme={null}
inline fun <T, E> Result<T, E>.fold(onSuccess: (T) -> Unit, onFailure: (E) -> Unit)
```

### getOrNull

```kotlin theme={null}
fun <T, E> Result<T, E>.getOrNull(): T?
```

### getOrThrow

```kotlin theme={null}
fun <T, E> Result<T, E>.getOrThrow(): T
```

### map

```kotlin theme={null}
inline fun <T, E, R> Result<T, E>.map(transform: (T) -> R): Result<R, E>
```

### mapError

```kotlin theme={null}
inline fun <T, E, F> Result<T, E>.mapError(transform: (E) -> F): Result<T, F>
```


# ApiKey
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/signer-data-api-key

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class ApiKey(val address: String, val locator: String) : SignerData
```

## Constructors

```kotlin theme={null}
constructor(address: String, locator: String)
```

## Properties

### address

```kotlin theme={null}
val address: String
```

### locator

```kotlin theme={null}
open override val locator: String
```


# Email
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/signer-data-email

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Email(val email: String, val locator: String = "email:") : SignerData, NonCustodialSigner
```

## Constructors

```kotlin theme={null}
constructor(email: String, locator: String = "email:")
```

## Properties

### email

```kotlin theme={null}
val email: String
```

### locator

```kotlin theme={null}
open override val locator: String
```


# ExternalWallet
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/signer-data-external-wallet

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class ExternalWallet(val address: String, val locator: String = "external-wallet:") : SignerData
```

## Constructors

```kotlin theme={null}
constructor(address: String, locator: String = "external-wallet:")
```

## Properties

### address

```kotlin theme={null}
val address: String
```

### locator

```kotlin theme={null}
open override val locator: String
```


# Passkey
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/signer-data-passkey

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Passkey(val id: String, val name: String, val publicKeyX: String, val publicKeyY: String, val validatorContractVersion: String, val locator: String) : SignerData
```

## Constructors

```kotlin theme={null}
constructor(id: String, name: String, publicKeyX: String, publicKeyY: String, validatorContractVersion: String, locator: String)
```

## Properties

### id

```kotlin theme={null}
val id: String
```

### locator

```kotlin theme={null}
open override val locator: String
```

### name

```kotlin theme={null}
val name: String
```

### publicKeyX

```kotlin theme={null}
val publicKeyX: String
```

### publicKeyY

```kotlin theme={null}
val publicKeyY: String
```

### validatorContractVersion

```kotlin theme={null}
val validatorContractVersion: String
```


# Phone
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/signer-data-phone

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Phone(val phone: String, val locator: String = "phone:") : SignerData, NonCustodialSigner
```

## Constructors

```kotlin theme={null}
constructor(phone: String, locator: String = "phone:")
```

## Properties

### locator

```kotlin theme={null}
open override val locator: String
```

### phone

```kotlin theme={null}
val phone: String
```


# Generic
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/signer-error-generic

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Generic(val message: String) : SignerError
```

## Constructors

```kotlin theme={null}
constructor(message: String)
```

## Properties

### message

```kotlin theme={null}
val message: String
```


# SigningFailed
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/signer-error-signing-failed

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class SigningFailed(val message: String) : SignerError
```

## Constructors

```kotlin theme={null}
constructor(message: String)
```

## Properties

### message

```kotlin theme={null}
val message: String
```


# Email
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/signer-type-email

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Email(val email: String) : SignerType
```

## Constructors

```kotlin theme={null}
constructor(email: String)
```

## Properties

### email

```kotlin theme={null}
val email: String
```


# Phone
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/signer-type-phone

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Phone(val phoneNumber: String) : SignerType
```

## Constructors

```kotlin theme={null}
constructor(phoneNumber: String)
```

## Properties

### phoneNumber

```kotlin theme={null}
val phoneNumber: String
```


# SolanaTransactionParams
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/solana-transaction-params

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class SolanaTransactionParams(val transaction: String, val signer: String, val feeConfig: FeeConfig? = null) : TransactionParams
```

## Constructors

```kotlin theme={null}
constructor(transaction: String, signer: String, feeConfig: FeeConfig? = null)
```

## Properties

### feeConfig

```kotlin theme={null}
val feeConfig: FeeConfig? = null
```

### signer

```kotlin theme={null}
open override val signer: String
```

### transaction

```kotlin theme={null}
val transaction: String
```


# StellarTransactionParams
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/stellar-transaction-params

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class StellarTransactionParams(val transaction: String, val signer: String? = null) : TransactionParams
```

## Constructors

```kotlin theme={null}
constructor(transaction: String, signer: String? = null)
```

## Properties

### signer

```kotlin theme={null}
open override val signer: String? = null
```

### transaction

```kotlin theme={null}
val transaction: String
```


# Generic
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/tee-error-generic

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Generic(val message: String) : TEEError
```

## Constructors

```kotlin theme={null}
constructor(message: String)
```

## Properties

### cause

```kotlin theme={null}
open val cause: Throwable?
```

### message

```kotlin theme={null}
open override val message: String
```


# InvalidPayload
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/tee-error-invalid-payload

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class InvalidPayload(val message: String = "Invalid payload provided for TEE operation") : TEEError
```

## Constructors

```kotlin theme={null}
constructor(message: String = "Invalid payload provided for TEE operation")
```

## Properties

### cause

```kotlin theme={null}
open val cause: Throwable?
```

### message

```kotlin theme={null}
open override val message: String
```


# SignerStatusRegression
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/tee-error-signer-status-regression

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class SignerStatusRegression(val message: String) : TEEError
```

## Constructors

```kotlin theme={null}
constructor(message: String)
```

## Properties

### cause

```kotlin theme={null}
open val cause: Throwable?
```

### message

```kotlin theme={null}
open override val message: String
```


# TokenBalance
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/token-balance

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class TokenBalance(val symbol: String, val name: String, val decimals: Int, val amount: String, val rawAmount: String, val chainInfo: ChainInfo? = null)
```

## Constructors

```kotlin theme={null}
constructor(symbol: String, name: String, decimals: Int, amount: String, rawAmount: String, chainInfo: ChainInfo? = null)
```

## Properties

### amount

```kotlin theme={null}
val amount: String
```

### chainInfo

```kotlin theme={null}
val chainInfo: ChainInfo? = null
```

### decimals

```kotlin theme={null}
val decimals: Int
```

### name

```kotlin theme={null}
val name: String
```

### rawAmount

```kotlin theme={null}
val rawAmount: String
```

### symbol

```kotlin theme={null}
val symbol: String
```


# Transaction
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/transaction

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Transaction(val id: String, val status: TransactionStatus, val onChain: OnChainData, val params: TransactionParams, val walletType: WalletType, val createdAt: Long, val approvals: Approvals?, val error: TransactionErrorDetails?)
```

## Constructors

```kotlin theme={null}
constructor(id: String, status: TransactionStatus, onChain: OnChainData, params: TransactionParams, walletType: WalletType, createdAt: Long, approvals: Approvals?, error: TransactionErrorDetails?)
```

## Properties

### approvals

```kotlin theme={null}
val approvals: Approvals?
```

### createdAt

```kotlin theme={null}
val createdAt: Long
```

### error

```kotlin theme={null}
val error: TransactionErrorDetails?
```

### id

```kotlin theme={null}
val id: String
```

### onChain

```kotlin theme={null}
val onChain: OnChainData
```

### params

```kotlin theme={null}
val params: TransactionParams
```

### status

```kotlin theme={null}
val status: TransactionStatus
```

### walletType

```kotlin theme={null}
val walletType: WalletType
```


# TransactionErrorDetails
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/transaction-error-details

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class TransactionErrorDetails(val reason: String, val message: String, val revert: TransactionErrorDetails.Revert?)
```

## Constructors

```kotlin theme={null}
constructor(reason: String, message: String, revert: TransactionErrorDetails.Revert?)
```

## Properties

### message

```kotlin theme={null}
val message: String
```

### reason

```kotlin theme={null}
val reason: String
```

### revert

```kotlin theme={null}
val revert: TransactionErrorDetails.Revert?
```


# Revert
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/transaction-error-details-revert

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Revert(val type: String, val reason: String, val simulationLink: String)
```

## Constructors

```kotlin theme={null}
constructor(type: String, reason: String, simulationLink: String)
```

## Properties

### reason

```kotlin theme={null}
val reason: String
```

### simulationLink

```kotlin theme={null}
val simulationLink: String
```

### type

```kotlin theme={null}
val type: String
```


# Forbidden
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/transaction-error-forbidden

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Forbidden(val message: String, val cause: Throwable? = null) : TransactionError
```

## Constructors

```kotlin theme={null}
constructor(message: String, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# InvalidTransactionState
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/transaction-error-invalid-transaction-state

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class InvalidTransactionState(val message: String, val cause: Throwable? = null) : TransactionError
```

## Constructors

```kotlin theme={null}
constructor(message: String, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# RateLimited
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/transaction-error-rate-limited

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class RateLimited(val message: String, val cause: Throwable? = null) : TransactionError
```

## Constructors

```kotlin theme={null}
constructor(message: String, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# ServiceNotInitialized
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/transaction-error-service-not-initialized

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class ServiceNotInitialized(val message: String, val cause: Throwable? = null) : TransactionError
```

## Constructors

```kotlin theme={null}
constructor(message: String, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# SigningFailed
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/transaction-error-signing-failed

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class SigningFailed(val message: String, val cause: Throwable? = null) : TransactionError
```

## Constructors

```kotlin theme={null}
constructor(message: String, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# Timeout
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/transaction-error-timeout

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Timeout(val message: String, val cause: Throwable? = null) : TransactionError
```

## Constructors

```kotlin theme={null}
constructor(message: String, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# TransactionCreationFailed
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/transaction-error-transaction-creation-failed

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class TransactionCreationFailed(val message: String, val cause: Throwable? = null) : TransactionError
```

## Constructors

```kotlin theme={null}
constructor(message: String, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# TransactionFailed
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/transaction-error-transaction-failed

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class TransactionFailed(val message: String, val cause: Throwable? = null) : TransactionError
```

## Constructors

```kotlin theme={null}
constructor(message: String, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# TransactionNotFound
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/transaction-error-transaction-not-found

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class TransactionNotFound(val message: String, val cause: Throwable? = null) : TransactionError
```

## Constructors

```kotlin theme={null}
constructor(message: String, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# TransactionOperationFailed
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/transaction-error-transaction-operation-failed

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class TransactionOperationFailed(val message: String, val cause: Throwable? = null) : TransactionError
```

## Constructors

```kotlin theme={null}
constructor(message: String, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# Unauthorized
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/transaction-error-unauthorized

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Unauthorized(val message: String, val cause: Throwable? = null) : TransactionError
```

## Constructors

```kotlin theme={null}
constructor(message: String, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# UserOperation
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/user-operation

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class UserOperation(val paymaster: String, val paymasterVerificationGasLimit: String, val preVerificationGas: String, val nonce: String, val paymasterPostOpGasLimit: String, val factoryData: String?, val factory: String?, val signature: String, val callGasLimit: String, val paymasterData: String, val verificationGasLimit: String, val maxFeePerGas: String, val sender: String, val callData: String, val maxPriorityFeePerGas: String)
```

## Constructors

```kotlin theme={null}
constructor(paymaster: String, paymasterVerificationGasLimit: String, preVerificationGas: String, nonce: String, paymasterPostOpGasLimit: String, factoryData: String?, factory: String?, signature: String, callGasLimit: String, paymasterData: String, verificationGasLimit: String, maxFeePerGas: String, sender: String, callData: String, maxPriorityFeePerGas: String)
```

## Properties

### callData

```kotlin theme={null}
val callData: String
```

### callGasLimit

```kotlin theme={null}
val callGasLimit: String
```

### factory

```kotlin theme={null}
val factory: String?
```

### factoryData

```kotlin theme={null}
val factoryData: String?
```

### maxFeePerGas

```kotlin theme={null}
val maxFeePerGas: String
```

### maxPriorityFeePerGas

```kotlin theme={null}
val maxPriorityFeePerGas: String
```

### nonce

```kotlin theme={null}
val nonce: String
```

### paymaster

```kotlin theme={null}
val paymaster: String
```

### paymasterData

```kotlin theme={null}
val paymasterData: String
```

### paymasterPostOpGasLimit

```kotlin theme={null}
val paymasterPostOpGasLimit: String
```

### paymasterVerificationGasLimit

```kotlin theme={null}
val paymasterVerificationGasLimit: String
```

### preVerificationGas

```kotlin theme={null}
val preVerificationGas: String
```

### sender

```kotlin theme={null}
val sender: String
```

### signature

```kotlin theme={null}
val signature: String
```

### verificationGasLimit

```kotlin theme={null}
val verificationGasLimit: String
```


# WalletConfig
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/wallet-config

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class WalletConfig(val adminSigner: SignerData, val delegatedSigners: List<DelegatedSignerData> = emptyList())
```

## Constructors

```kotlin theme={null}
constructor(adminSigner: SignerData, delegatedSigners: List<DelegatedSignerData> = emptyList())
```

## Properties

### adminSigner

```kotlin theme={null}
val adminSigner: SignerData
```

### delegatedSigners

```kotlin theme={null}
val delegatedSigners: List<DelegatedSignerData>
```


# ChainNotSupported
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/wallet-error-chain-not-supported

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class ChainNotSupported(val message: String, val cause: Throwable? = null) : WalletError
```

## Constructors

```kotlin theme={null}
constructor(message: String, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# Forbidden
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/wallet-error-forbidden

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Forbidden(val message: String, val cause: Throwable? = null) : WalletError
```

## Constructors

```kotlin theme={null}
constructor(message: String, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# InvalidInput
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/wallet-error-invalid-input

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class InvalidInput(val message: String, val cause: Throwable? = null) : WalletError
```

## Constructors

```kotlin theme={null}
constructor(message: String, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# InvalidSigner
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/wallet-error-invalid-signer

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class InvalidSigner(val message: String, val cause: Throwable? = null) : WalletError
```

## Constructors

```kotlin theme={null}
constructor(message: String, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# RateLimited
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/wallet-error-rate-limited

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class RateLimited(val message: String, val cause: Throwable? = null) : WalletError
```

## Constructors

```kotlin theme={null}
constructor(message: String, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# ServiceNotInitialized
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/wallet-error-service-not-initialized

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class ServiceNotInitialized(val message: String = "Wallet service not initialized", val cause: Throwable? = null) : WalletError
```

## Constructors

```kotlin theme={null}
constructor(message: String = "Wallet service not initialized", cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# SigningError
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/wallet-error-signing-error

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class SigningError(val message: String, val cause: Throwable? = null) : WalletError
```

## Constructors

```kotlin theme={null}
constructor(message: String, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# Unauthorized
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/wallet-error-unauthorized

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Unauthorized(val message: String, val cause: Throwable? = null) : WalletError
```

## Constructors

```kotlin theme={null}
constructor(message: String, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# WalletNotFound
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/wallet-error-wallet-not-found

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class WalletNotFound(val message: String, val cause: Throwable? = null) : WalletError
```

## Constructors

```kotlin theme={null}
constructor(message: String, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# WalletOperationFailed
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/wallet-error-wallet-operation-failed

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class WalletOperationFailed(val message: String, val cause: Throwable? = null) : WalletError
```

## Constructors

```kotlin theme={null}
constructor(message: String, cause: Throwable? = null)
```

## Properties

### cause

```kotlin theme={null}
open override val cause: Throwable? = null
```

### message

```kotlin theme={null}
open override val message: String
```


# Custom
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/data-classes/web-view-message-custom

Kotlin Data Class

**Data Class**

```kotlin theme={null}
data class Custom(val data: String) : WebViewMessage
```

## Constructors

```kotlin theme={null}
constructor(data: String)
```

## Properties

### data

```kotlin theme={null}
val data: String
```


# AuthManager
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/interfaces/auth-manager

Kotlin Interface

**Interface**

```kotlin theme={null}
interface AuthManager
```

## Functions

### getJWT

```kotlin theme={null}
abstract suspend fun getJWT(): String?
```


# AuthService
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/interfaces/auth-service

Kotlin Interface

**Interface**

```kotlin theme={null}
interface AuthService
```

## Functions

### logout

```kotlin theme={null}
abstract suspend fun logout(refreshToken: String): Result<Unit, AuthError>
```

### refreshToken

```kotlin theme={null}
abstract suspend fun refreshToken(oneTimeSecret: String): Result<AuthToken, AuthError>
```

### sendOtp

```kotlin theme={null}
abstract suspend fun sendOtp(email: String): Result<SendOtpResponse, AuthError>
```

### verifyOtp

```kotlin theme={null}
abstract suspend fun verifyOtp(email: String, code: String, state: String): Result<VerifyOtpResponse, AuthError>
```


# BalanceOperations
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/interfaces/balance-operations

Kotlin Interface

**Interface**

```kotlin theme={null}
interface BalanceOperations
```

## Functions

### getBalances

```kotlin theme={null}
abstract suspend fun getBalances(tokens: List<String>): Result<Balances, BalanceError>
```

Gets the wallet balances.


# CrossmintTEE
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/interfaces/crossmint-tee

Kotlin Interface

**Interface**

```kotlin theme={null}
interface CrossmintTEE
```

## Properties

### isHandshakeCompleted

```kotlin theme={null}
abstract val isHandshakeCompleted: Boolean
```

Indicates whether the handshake with the TEE service has been completed. Handshake must be completed before performing cryptographic operations.

### isOTPRequired

```kotlin theme={null}
abstract val isOTPRequired: StateFlow<Boolean>
```

Observable state indicating whether the OTP prompt should be shown.

## Functions

### awaitReady

```kotlin theme={null}
abstract suspend fun awaitReady()
```

Blocks continuation until a successful TEE load has completed. This method must be called before any signing operations.

### cancelOTP

```kotlin theme={null}
abstract fun cancelOTP()
```

Resets isOTPRequired to emit false

### performHandshake

```kotlin theme={null}
abstract suspend fun performHandshake(): Result<Unit, TEEError>
```

Performs the TEE handshake protocol. This is called automatically by load().

### provideOTP

```kotlin theme={null}
abstract fun provideOTP(code: String)
```

Provides the OTP code from the user to the TEE flow.

### signTransaction

```kotlin theme={null}
abstract suspend fun signTransaction(messageBytes: String, keyType: String, encoding: String, otpAuth: String): Result<String, TEEError>
```


# CrossmintWallets
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/interfaces/crossmint-wallets

Kotlin Interface

**Interface**

```kotlin theme={null}
interface CrossmintWallets
```

## Functions

### createSignerFromDelegated

```kotlin theme={null}
abstract suspend fun createSignerFromDelegated(delegatedSignerData: DelegatedSignerData, chainType: ChainType): Signer?
```

Creates a Signer from delegated signer data. Only supports email and phone signers (non-custodial signers). Returns null for passkey, api-key, and external-wallet signers as they require additional credentials.

### createWallet

```kotlin theme={null}
abstract suspend fun createWallet(chain: Chain, signerType: SignerType, delegatedSigners: List<DelegatedSigner> = emptyList(), owner: String? = null, alias: String? = null): Result<Wallet, WalletError>
```

Creates a new wallet on the specified chain with the given signer.

### getOrCreateWallet

```kotlin theme={null}
abstract suspend fun getOrCreateWallet(chain: Chain, signerType: SignerType, delegatedSigners: List<DelegatedSigner> = emptyList(), owner: String? = null, alias: String? = null): Result<Wallet, WalletError>
```

Gets an existing wallet or creates a new one if it doesn't exist. This is a convenience method that combines getWallet() and createWallet().

### getWallet

```kotlin theme={null}
abstract suspend fun getWallet(chain: Chain): Result<Wallet, WalletError>
```


# EmailSigner
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/interfaces/email-signer

Kotlin Interface

**Interface**

```kotlin theme={null}
interface EmailSigner : Signer
```

## Properties

### signerData

```kotlin theme={null}
abstract val signerData: SignerData
```

The admin signer data associated with this signer. Contains signer-specific information (email, public key, etc.)

## Functions

### getEncoding

```kotlin theme={null}
abstract suspend fun getEncoding(): String
```

The encoding format for signatures.

### getKeyType

```kotlin theme={null}
abstract suspend fun getKeyType(): String
```

The cryptographic key type used for signing.

### initialize

```kotlin theme={null}
abstract suspend fun initialize(service: CrossmintService?)
```

Initializes the signer with necessary service context. Must be called before sign() operations.

### locator

```kotlin theme={null}
open fun locator(): String
```

### processMessage

```kotlin theme={null}
abstract fun processMessage(message: String): String
```

Allows platform-specific preprocessing of the message before signing.

### sign

```kotlin theme={null}
abstract suspend fun sign(message: String): Result<String, SignerError>
```

Signs a message and returns the signature.


# FailureAwareSessionStore
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/interfaces/failure-aware-session-store

Kotlin Interface

**Interface**

```kotlin theme={null}
interface FailureAwareSessionStore : SessionStore
```

## Functions

### clear

```kotlin theme={null}
abstract suspend fun clear()
```

### hasFailed

```kotlin theme={null}
abstract fun hasFailed(): Boolean
```

Returns true if this store has encountered a failure and should no longer be used. Once this returns true, it should continue to return true for the lifetime of the instance.

### token

```kotlin theme={null}
abstract suspend fun token(): AuthToken?
```

### update

```kotlin theme={null}
abstract suspend fun update(token: AuthToken?)
```


# NonCustodialSigner
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/interfaces/non-custodial-signer

Kotlin Interface

**Interface**

```kotlin theme={null}
interface NonCustodialSigner
```

## Properties

### locator

```kotlin theme={null}
abstract val locator: String
```


# SessionStore
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/interfaces/session-store

Kotlin Interface

**Interface**

```kotlin theme={null}
interface SessionStore
```

## Functions

### clear

```kotlin theme={null}
abstract suspend fun clear()
```

### token

```kotlin theme={null}
abstract suspend fun token(): AuthToken?
```

### update

```kotlin theme={null}
abstract suspend fun update(token: AuthToken?)
```


# Signer
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/interfaces/signer

Kotlin Interface

**Interface**

```kotlin theme={null}
interface Signer
```

## Properties

### signerData

```kotlin theme={null}
abstract val signerData: SignerData
```

The admin signer data associated with this signer. Contains signer-specific information (email, public key, etc.)

## Functions

### initialize

```kotlin theme={null}
abstract suspend fun initialize(service: CrossmintService?)
```

Initializes the signer with necessary service context. Must be called before sign() operations.

### locator

```kotlin theme={null}
open fun locator(): String
```

### sign

```kotlin theme={null}
abstract suspend fun sign(message: String): Result<String, SignerError>
```

Signs a message and returns the signature.


# TransactionOperations
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/interfaces/transaction-operations

Kotlin Interface

**Interface**

```kotlin theme={null}
interface TransactionOperations
```

## Functions

### getTransaction

```kotlin theme={null}
abstract suspend fun getTransaction(transactionId: String): Result<Transaction, TransactionError>
```

### send

```kotlin theme={null}
abstract suspend fun send(recipient: String, tokenLocator: String, amount: Double, idempotencyKey: String? = null, signer: Signer? = null): Result<Transaction, TransactionError>
```

Sends tokens to a recipient address.

### signAndSubmitTransaction

```kotlin theme={null}
abstract suspend fun signAndSubmitTransaction(transactionId: String, signer: Signer?): Result<Transaction, TransactionError>
```


# Apechain
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-apechain

Kotlin Object

**Object**

```kotlin theme={null}
data object Apechain : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = false
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# Apex
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-apex

Kotlin Object

**Object**

```kotlin theme={null}
data object Apex : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = false
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# Arbitrum
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-arbitrum

Kotlin Object

**Object**

```kotlin theme={null}
data object Arbitrum : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = false
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# ArbitrumNova
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-arbitrum-nova

Kotlin Object

**Object**

```kotlin theme={null}
data object ArbitrumNova : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = false
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# ArbitrumSepolia
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-arbitrum-sepolia

Kotlin Object

**Object**

```kotlin theme={null}
data object ArbitrumSepolia : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# AstarZkEVM
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-astar-zk-evm

Kotlin Object

**Object**

```kotlin theme={null}
data object AstarZkEVM : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = false
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# Avalanche
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-avalanche

Kotlin Object

**Object**

```kotlin theme={null}
data object Avalanche : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = false
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# AvalancheFuji
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-avalanche-fuji

Kotlin Object

**Object**

```kotlin theme={null}
data object AvalancheFuji : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# BarretTestnet
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-barret-testnet

Kotlin Object

**Object**

```kotlin theme={null}
data object BarretTestnet : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# Base
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-base

Kotlin Object

**Object**

```kotlin theme={null}
data object Base : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = false
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# BaseGoerli
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-base-goerli

Kotlin Object

**Object**

```kotlin theme={null}
data object BaseGoerli : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# BaseSepolia
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-base-sepolia

Kotlin Object

**Object**

```kotlin theme={null}
data object BaseSepolia : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# BSCTestnet
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-bsc-testnet

Kotlin Object

**Object**

```kotlin theme={null}
data object BSCTestnet : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# Chiliz
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-chiliz

Kotlin Object

**Object**

```kotlin theme={null}
data object Chiliz : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = false
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# ChilizSpicyTestnet
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-chiliz-spicy-testnet

Kotlin Object

**Object**

```kotlin theme={null}
data object ChilizSpicyTestnet : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# Coti
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-coti

Kotlin Object

**Object**

```kotlin theme={null}
data object Coti : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = false
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# CotiTestnet
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-coti-testnet

Kotlin Object

**Object**

```kotlin theme={null}
data object CotiTestnet : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# Curtis
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-curtis

Kotlin Object

**Object**

```kotlin theme={null}
data object Curtis : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# Ethereum
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-ethereum

Kotlin Object

**Object**

```kotlin theme={null}
data object Ethereum : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = false
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# EthereumGoerli
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-ethereum-goerli

Kotlin Object

**Object**

```kotlin theme={null}
data object EthereumGoerli : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# EthereumSepolia
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-ethereum-sepolia

Kotlin Object

**Object**

```kotlin theme={null}
data object EthereumSepolia : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# HypersonicTestnet
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-hypersonic-testnet

Kotlin Object

**Object**

```kotlin theme={null}
data object HypersonicTestnet : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# Lightlink
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-lightlink

Kotlin Object

**Object**

```kotlin theme={null}
data object Lightlink : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = false
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# LightlinkPegasus
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-lightlink-pegasus

Kotlin Object

**Object**

```kotlin theme={null}
data object LightlinkPegasus : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# Mode
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-mode

Kotlin Object

**Object**

```kotlin theme={null}
data object Mode : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = false
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# ModeSepolia
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-mode-sepolia

Kotlin Object

**Object**

```kotlin theme={null}
data object ModeSepolia : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# Optimism
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-optimism

Kotlin Object

**Object**

```kotlin theme={null}
data object Optimism : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = false
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# OptimismGoerli
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-optimism-goerli

Kotlin Object

**Object**

```kotlin theme={null}
data object OptimismGoerli : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# OptimismSepolia
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-optimism-sepolia

Kotlin Object

**Object**

```kotlin theme={null}
data object OptimismSepolia : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# Polygon
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-polygon

Kotlin Object

**Object**

```kotlin theme={null}
data object Polygon : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = false
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# PolygonAmoy
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-polygon-amoy

Kotlin Object

**Object**

```kotlin theme={null}
data object PolygonAmoy : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# PolygonMumbai
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-polygon-mumbai

Kotlin Object

**Object**

```kotlin theme={null}
data object PolygonMumbai : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# Rari
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-rari

Kotlin Object

**Object**

```kotlin theme={null}
data object Rari : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = false
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# RariTestnet
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-rari-testnet

Kotlin Object

**Object**

```kotlin theme={null}
data object RariTestnet : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# Scroll
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-scroll

Kotlin Object

**Object**

```kotlin theme={null}
data object Scroll : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = false
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# ScrollSepolia
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-scroll-sepolia

Kotlin Object

**Object**

```kotlin theme={null}
data object ScrollSepolia : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# SeiAtlantic2Testnet
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-sei-atlantic2testnet

Kotlin Object

**Object**

```kotlin theme={null}
data object SeiAtlantic2Testnet : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# SeiPacific1
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-sei-pacific1

Kotlin Object

**Object**

```kotlin theme={null}
data object SeiPacific1 : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = false
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# Shape
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-shape

Kotlin Object

**Object**

```kotlin theme={null}
data object Shape : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = false
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# ShapeSepolia
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-shape-sepolia

Kotlin Object

**Object**

```kotlin theme={null}
data object ShapeSepolia : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# SkaleNebula
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-skale-nebula

Kotlin Object

**Object**

```kotlin theme={null}
data object SkaleNebula : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = false
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# SkaleNebulaTestnet
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-skale-nebula-testnet

Kotlin Object

**Object**

```kotlin theme={null}
data object SkaleNebulaTestnet : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# Soneium
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-soneium

Kotlin Object

**Object**

```kotlin theme={null}
data object Soneium : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = false
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# SoneiumMinatoTestnet
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-soneium-minato-testnet

Kotlin Object

**Object**

```kotlin theme={null}
data object SoneiumMinatoTestnet : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# Space
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-space

Kotlin Object

**Object**

```kotlin theme={null}
data object Space : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = false
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# SpaceTestnet
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-space-testnet

Kotlin Object

**Object**

```kotlin theme={null}
data object SpaceTestnet : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# Story
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-story

Kotlin Object

**Object**

```kotlin theme={null}
data object Story : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = false
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# StoryTestnet
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-story-testnet

Kotlin Object

**Object**

```kotlin theme={null}
data object StoryTestnet : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# VerifyTestnet
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-verify-testnet

Kotlin Object

**Object**

```kotlin theme={null}
data object VerifyTestnet : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# Viction
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-viction

Kotlin Object

**Object**

```kotlin theme={null}
data object Viction : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = false
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# VictionTestnet
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-viction-testnet

Kotlin Object

**Object**

```kotlin theme={null}
data object VictionTestnet : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# Xai
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-xai

Kotlin Object

**Object**

```kotlin theme={null}
data object Xai : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = false
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# XaiSepoliaTestnet
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-xai-sepolia-testnet

Kotlin Object

**Object**

```kotlin theme={null}
data object XaiSepoliaTestnet : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# ZenchainTestnet
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-zenchain-testnet

Kotlin Object

**Object**

```kotlin theme={null}
data object ZenchainTestnet : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# Zkatana
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-zkatana

Kotlin Object

**Object**

```kotlin theme={null}
data object Zkatana : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# Zkyoto
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-zkyoto

Kotlin Object

**Object**

```kotlin theme={null}
data object Zkyoto : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# Zora
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-zora

Kotlin Object

**Object**

```kotlin theme={null}
data object Zora : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = false
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# ZoraGoerli
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-zora-goerli

Kotlin Object

**Object**

```kotlin theme={null}
data object ZoraGoerli : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# ZoraSepolia
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/evm-chain-zora-sepolia

Kotlin Object

**Object**

```kotlin theme={null}
data object ZoraSepolia : EVMChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = true
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# Cancelled
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/signer-error-cancelled

Kotlin Object

**Object**

```kotlin theme={null}
data object Cancelled : SignerError
```


# InvalidEmail
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/signer-error-invalid-email

Kotlin Object

**Object**

```kotlin theme={null}
data object InvalidEmail : SignerError
```


# NotInitialized
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/signer-error-not-initialized

Kotlin Object

**Object**

```kotlin theme={null}
data object NotInitialized : SignerError
```


# NotStarted
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/signer-error-not-started

Kotlin Object

**Object**

```kotlin theme={null}
data object NotStarted : SignerError
```


# TeeNotStarted
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/signer-error-tee-not-started

Kotlin Object

**Object**

```kotlin theme={null}
data object TeeNotStarted : SignerError
```


# ApiKey
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/signer-type-api-key

Kotlin Object

<Note>
  [Contact us](https://www.crossmint.com/contact/sales) for access to API key signers.
</Note>

**Object**

```kotlin theme={null}
data object ApiKey : SignerType
```


# Solana
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/solana-chain-solana

Kotlin Object

**Object**

```kotlin theme={null}
data object Solana : SolanaChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = false
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open override fun isValid(isProductionEnvironment: Boolean): Boolean
```


# Stellar
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/stellar-chain-stellar

Kotlin Object

**Object**

```kotlin theme={null}
data object Stellar : StellarChain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
open override val isTestnet: Boolean = false
```

### name

```kotlin theme={null}
open override val name: String
```

## Functions

### isValid

```kotlin theme={null}
open override fun isValid(isProductionEnvironment: Boolean): Boolean
```


# EncryptionUnavailable
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/tee-error-encryption-unavailable

Kotlin Object

**Object**

```kotlin theme={null}
object EncryptionUnavailable : TEEError
```

## Properties

### cause

```kotlin theme={null}
open val cause: Throwable?
```

### message

```kotlin theme={null}
open override val message: String
```


# ErrorLoadingService
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/tee-error-error-loading-service

Kotlin Object

**Object**

```kotlin theme={null}
object ErrorLoadingService : TEEError
```

## Properties

### cause

```kotlin theme={null}
open val cause: Throwable?
```

### message

```kotlin theme={null}
open override val message: String
```


# HandshakeFailed
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/tee-error-handshake-failed

Kotlin Object

**Object**

```kotlin theme={null}
object HandshakeFailed : TEEError
```

## Properties

### cause

```kotlin theme={null}
open val cause: Throwable?
```

### message

```kotlin theme={null}
open override val message: String
```


# HandshakeRequired
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/tee-error-handshake-required

Kotlin Object

**Object**

```kotlin theme={null}
object HandshakeRequired : TEEError
```

## Properties

### cause

```kotlin theme={null}
open val cause: Throwable?
```

### message

```kotlin theme={null}
open override val message: String
```


# InvalidSignature
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/tee-error-invalid-signature

Kotlin Object

**Object**

```kotlin theme={null}
object InvalidSignature : TEEError
```

## Properties

### cause

```kotlin theme={null}
open val cause: Throwable?
```

### message

```kotlin theme={null}
open override val message: String
```


# JWTRequired
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/tee-error-jwt-required

Kotlin Object

**Object**

```kotlin theme={null}
object JWTRequired : TEEError
```

## Properties

### cause

```kotlin theme={null}
open val cause: Throwable?
```

### message

```kotlin theme={null}
open override val message: String
```


# SignerStatusUnavailable
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/tee-error-signer-status-unavailable

Kotlin Object

**Object**

```kotlin theme={null}
object SignerStatusUnavailable : TEEError
```

## Properties

### cause

```kotlin theme={null}
open val cause: Throwable?
```

### message

```kotlin theme={null}
open override val message: String
```


# Timeout
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/tee-error-timeout

Kotlin Object

**Object**

```kotlin theme={null}
object Timeout : TEEError
```

## Properties

### cause

```kotlin theme={null}
open val cause: Throwable?
```

### message

```kotlin theme={null}
open override val message: String
```


# UserCancelled
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/objects/tee-error-user-cancelled

Kotlin Object

**Object**

```kotlin theme={null}
object UserCancelled : TEEError
```

## Properties

### cause

```kotlin theme={null}
open val cause: Throwable?
```

### message

```kotlin theme={null}
open override val message: String
```


# ApprovalMetadata
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/sealed-classes/approval-metadata

Kotlin Sealed Class

**Sealed Class**

```kotlin theme={null}
sealed class ApprovalMetadata
```


# ApprovalSignature
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/sealed-classes/approval-signature

Kotlin Sealed Class

**Sealed Class**

```kotlin theme={null}
sealed class ApprovalSignature
```


# CheckoutError
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/sealed-classes/checkout-error

Kotlin Sealed Class

**Sealed Class**

```kotlin theme={null}
sealed class CheckoutError : Exception
```

## Properties

### cause

```kotlin theme={null}
open val cause: Throwable?
```

### message

```kotlin theme={null}
open val message: String?
```


# DelegatedSigner
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/sealed-classes/delegated-signer

Kotlin Sealed Class

**Sealed Class**

```kotlin theme={null}
sealed class DelegatedSigner
```

## Properties

### expiresAt

```kotlin theme={null}
abstract val expiresAt: Long?
```

Optional expiration timestamp in milliseconds since Unix epoch. If set, the delegated signer will expire at this time.


# Owner
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/sealed-classes/owner

Kotlin Sealed Class

**Sealed Class**

```kotlin theme={null}
sealed class Owner
```


# SignerData
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/sealed-classes/signer-data

Kotlin Sealed Class

**Sealed Class**

```kotlin theme={null}
sealed class SignerData
```

## Properties

### locator

```kotlin theme={null}
abstract val locator: String
```


# SignerError
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/sealed-classes/signer-error

Kotlin Sealed Class

**Sealed Class**

```kotlin theme={null}
sealed class SignerError
```


# SignerType
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/sealed-classes/signer-type

Kotlin Sealed Class

**Sealed Class**

```kotlin theme={null}
sealed class SignerType
```


# TEEError
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/sealed-classes/tee-error

Kotlin Sealed Class

**Sealed Class**

```kotlin theme={null}
sealed class TEEError : Exception
```

## Properties

### cause

```kotlin theme={null}
open val cause: Throwable?
```

### message

```kotlin theme={null}
open val message: String?
```


# ApiKeyError
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/sealed-interfaces/api-key-error

Kotlin Sealed Interface

**Sealed Interface**

```kotlin theme={null}
sealed interface ApiKeyError : ConfigurationError
```

## Properties

### cause

```kotlin theme={null}
abstract val cause: Throwable?
```

### message

```kotlin theme={null}
abstract val message: String
```


# AuthError
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/sealed-interfaces/auth-error

Kotlin Sealed Interface

**Sealed Interface**

```kotlin theme={null}
sealed interface AuthError : CrossmintError
```

## Properties

### cause

```kotlin theme={null}
abstract val cause: Throwable?
```

### message

```kotlin theme={null}
abstract val message: String
```


# BalanceError
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/sealed-interfaces/balance-error

Kotlin Sealed Interface

**Sealed Interface**

```kotlin theme={null}
sealed interface BalanceError : CrossmintError
```

## Properties

### cause

```kotlin theme={null}
abstract val cause: Throwable?
```

### message

```kotlin theme={null}
abstract val message: String
```


# Chain
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/sealed-interfaces/chain

Kotlin Sealed Interface

**Sealed Interface**

```kotlin theme={null}
sealed interface Chain
```

## Properties

### chainType

```kotlin theme={null}
abstract val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
abstract val isTestnet: Boolean
```

### name

```kotlin theme={null}
abstract val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# ChainInfo
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/sealed-interfaces/chain-info

Kotlin Sealed Interface

**Sealed Interface**

```kotlin theme={null}
sealed interface ChainInfo
```


# ConfigurationError
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/sealed-interfaces/configuration-error

Kotlin Sealed Interface

**Sealed Interface**

```kotlin theme={null}
sealed interface ConfigurationError : CrossmintError
```

## Properties

### cause

```kotlin theme={null}
abstract val cause: Throwable?
```

### message

```kotlin theme={null}
abstract val message: String
```


# CrossmintError
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/sealed-interfaces/crossmint-error

Kotlin Sealed Interface

**Sealed Interface**

```kotlin theme={null}
sealed interface CrossmintError
```

## Properties

### cause

```kotlin theme={null}
abstract val cause: Throwable?
```

### message

```kotlin theme={null}
abstract val message: String
```


# EVMChain
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/sealed-interfaces/evm-chain

Kotlin Sealed Interface

**Sealed Interface**

```kotlin theme={null}
sealed interface EVMChain : Chain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
abstract val isTestnet: Boolean
```

### name

```kotlin theme={null}
abstract val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# NetworkError
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/sealed-interfaces/network-error

Kotlin Sealed Interface

**Sealed Interface**

```kotlin theme={null}
sealed interface NetworkError : CrossmintError
```

## Properties

### cause

```kotlin theme={null}
abstract val cause: Throwable?
```

### message

```kotlin theme={null}
abstract val message: String
```


# Result
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/sealed-interfaces/result

Kotlin Sealed Interface

**Sealed Interface**

```kotlin theme={null}
sealed interface Result<out T, out E>
```

## Functions

### flatMap

```kotlin theme={null}
inline fun <T, E, R> Result<T, E>.flatMap(transform: (T) -> Result<R, E>): Result<R, E>
```

### fold

```kotlin theme={null}
inline fun <T, E> Result<T, E>.fold(onSuccess: (T) -> Unit, onFailure: (E) -> Unit)
```

### getOrNull

```kotlin theme={null}
fun <T, E> Result<T, E>.getOrNull(): T?
```

### getOrThrow

```kotlin theme={null}
fun <T, E> Result<T, E>.getOrThrow(): T
```

### map

```kotlin theme={null}
inline fun <T, E, R> Result<T, E>.map(transform: (T) -> R): Result<R, E>
```

### mapError

```kotlin theme={null}
inline fun <T, E, F> Result<T, E>.mapError(transform: (E) -> F): Result<T, F>
```


# SolanaChain
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/sealed-interfaces/solana-chain

Kotlin Sealed Interface

**Sealed Interface**

```kotlin theme={null}
sealed interface SolanaChain : Chain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
abstract val isTestnet: Boolean
```

### name

```kotlin theme={null}
abstract val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# StellarChain
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/sealed-interfaces/stellar-chain

Kotlin Sealed Interface

**Sealed Interface**

```kotlin theme={null}
sealed interface StellarChain : Chain
```

## Properties

### chainType

```kotlin theme={null}
open override val chainType: ChainType
```

### isTestnet

```kotlin theme={null}
abstract val isTestnet: Boolean
```

### name

```kotlin theme={null}
abstract val name: String
```

## Functions

### isValid

```kotlin theme={null}
open fun isValid(isProductionEnvironment: Boolean): Boolean
```


# TransactionError
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/sealed-interfaces/transaction-error

Kotlin Sealed Interface

**Sealed Interface**

```kotlin theme={null}
sealed interface TransactionError : CrossmintError
```

## Properties

### cause

```kotlin theme={null}
abstract val cause: Throwable?
```

### message

```kotlin theme={null}
abstract val message: String
```


# TransactionParams
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/sealed-interfaces/transaction-params

Kotlin Sealed Interface

**Sealed Interface**

```kotlin theme={null}
sealed interface TransactionParams
```

## Properties

### signer

```kotlin theme={null}
abstract val signer: String?
```


# WalletError
Source: https://docs.crossmint.com/sdk-reference/wallets/kotlin/sealed-interfaces/wallet-error

Kotlin Sealed Interface

**Sealed Interface**

```kotlin theme={null}
sealed interface WalletError : CrossmintError
```

## Properties

### cause

```kotlin theme={null}
abstract val cause: Throwable?
```

### message

```kotlin theme={null}
abstract val message: String
```


# Components
Source: https://docs.crossmint.com/sdk-reference/wallets/react-native/components

React Native components for React Native SDK reference for Crossmint wallets

***

## ExportPrivateKeyButton

Renders a button that allows the user to export their wallet's private key. Only works with email and phone signers. Will not render for passkey or external wallet signers.

### Props

<ResponseField name="appearance" type="UIConfig">
  Optional appearance configuration for styling the export button.
</ResponseField>

### Usage

```tsx theme={null}
import { ExportPrivateKeyButton } from "@crossmint/client-sdk-react-native-ui";
import { View, Text } from "react-native";

function WalletSettings() {
    return (
        <View>
            <Text>Export Private Key</Text>
            <ExportPrivateKeyButton
                appearance={{
                    colors: { border: "#e2e8f0" },
                    borderRadius: "12px",
                }}
            />
        </View>
    );
}
```

> **Note:** Only works with email and phone signers. Will not render for passkey or external wallet signers.


# Get Started
Source: https://docs.crossmint.com/sdk-reference/wallets/react-native/get-started

Installation and setup for the React Native SDK reference for Crossmint wallets

### Latest React Native SDK version - <a href="https://www.npmjs.com/package/@crossmint/client-sdk-react-native-ui"><img alt="npm" /></a>

The Crossmint React Native SDK (`@crossmint/client-sdk-react-native-ui`) provides React Native components and hooks for integrating Crossmint wallets into your mobile application.

## Installation

```bash theme={null}
npm install @crossmint/client-sdk-react-native-ui
```

## Provider Setup

Wrap your application with the required providers:

```tsx theme={null}
import {
    CrossmintProvider,
    CrossmintWalletProvider,
} from "@crossmint/client-sdk-react-native-ui";

function App() {
    return (
        <CrossmintProvider apiKey="YOUR_CLIENT_API_KEY">
            <CrossmintWalletProvider
                createOnLogin={{
                    chain: "base-sepolia",
                    signer: { type: "email" },
                }}
            >
                {/* Your app components */}
            </CrossmintWalletProvider>
        </CrossmintProvider>
    );
}
```

## Quick Example

Once providers are set up, use hooks to access wallet state:

```tsx theme={null}
import { useWallet } from "@crossmint/client-sdk-react-native-ui";
import { View, Text } from "react-native";

function WalletInfo() {
    const { wallet, status } = useWallet();

    if (status === "in-progress") return <Text>Loading wallet...</Text>;
    if (!wallet) return <Text>No wallet connected</Text>;

    return (
        <View>
            <Text>Address: {wallet.address}</Text>
            <Text>Chain: {wallet.chain}</Text>
        </View>
    );
}
```

## Next Steps

* [Providers](/sdk-reference/wallets/react-native/providers) — Configure providers and their options
* [Hooks](/sdk-reference/wallets/react-native/hooks) — Access SDK state via React hooks
* [Components](/sdk-reference/wallets/react-native/components) — Drop-in UI components
* [Wallets SDK Reference](/sdk-reference/wallets/typescript/classes/Wallet) — Complete wallet method documentation


# Hooks
Source: https://docs.crossmint.com/sdk-reference/wallets/react-native/hooks

React Native hooks for React Native SDK reference for Crossmint wallets

***

## useWallet()

### Returns

<ResponseField name="wallet" type="Wallet | undefined">
  The current wallet instance, or undefined if no wallet is loaded.
</ResponseField>

<ResponseField name="status" type="WalletStatus">
  Current wallet status. Options: `not-loaded` | `in-progress` | `loaded` | `error`.
</ResponseField>

<ResponseField name="getOrCreateWallet" type="(args: WalletArgsFor<Chain>) => Promise<Wallet | undefined>">
  Creates a new wallet or retrieves an existing one.

  <Expandable title="parameters">
    <ResponseField name="chain" type="Chain">
      The blockchain to create the wallet on (e.g. "base-sepolia").
    </ResponseField>

    <ResponseField name="signer" type="SignerConfigForChain">
      The signer configuration (e.g. `{ type: "email" }`).
    </ResponseField>

    <ResponseField name="owner" type="string">
      Optional owner identifier.
    </ResponseField>

    <ResponseField name="alias" type="string">
      Optional wallet alias.
    </ResponseField>

    <ResponseField name="plugins" type="WalletPlugin[]">
      Optional array of wallet plugins.
    </ResponseField>

    <ResponseField name="delegatedSigners" type="DelegatedSigner[]">
      Optional array of delegated signers.
    </ResponseField>
  </Expandable>
</ResponseField>

### Usage

```tsx theme={null}
import { useWallet } from "@crossmint/client-sdk-react-native-ui";
import { View, Text, TouchableOpacity } from "react-native";

function WalletActions() {
    const { wallet, status } = useWallet();

    if (status === "in-progress") return <Text>Loading wallet...</Text>;
    if (!wallet) return <Text>No wallet</Text>;

    const handleSend = async () => {
        const tx = await wallet.send("0x...", "usdc", "10");
        console.log("Transaction:", tx.explorerLink);
    };

    const handleBalances = async () => {
        const balances = await wallet.balances();
        console.log("USDC:", balances.usdc.amount);
        console.log("Native:", balances.nativeToken.amount);
    };

    return (
        <View>
            <Text>Wallet: {wallet.address}</Text>
            <TouchableOpacity onPress={handleBalances}>
                <Text>Check Balances</Text>
            </TouchableOpacity>
            <TouchableOpacity onPress={handleSend}>
                <Text>Send USDC</Text>
            </TouchableOpacity>
        </View>
    );
}
```

***

## useWalletEmailSigner()

Hook for managing email-based signer authentication flows. Provides OTP send/verify functions for wallets using an email signer. Must be used within a CrossmintWalletProvider.

### Returns

<ResponseField name="needsAuth" type="boolean">
  Whether the email signer currently requires authentication (OTP verification).
</ResponseField>

<ResponseField name="sendEmailWithOtp" type="() => Promise<void>">
  Sends a one-time password to the user's email address.
</ResponseField>

<ResponseField name="verifyOtp" type="(otp: string) => Promise<void>">
  Verifies the one-time password entered by the user.
</ResponseField>

<ResponseField name="reject" type="(error: Error) => void">
  Rejects the current authentication request with an error.
</ResponseField>

### Usage

```tsx theme={null}
import { useWalletEmailSigner } from "@crossmint/client-sdk-react-native-ui";
import { View, Text, TextInput, TouchableOpacity } from "react-native";
import { useState } from "react";

function EmailSignerFlow() {
    const { needsAuth, sendEmailWithOtp, verifyOtp, reject } = useWalletEmailSigner();
    const [otp, setOtp] = useState("");

    if (!needsAuth) return null;

    return (
        <View>
            <Text>Email verification required</Text>
            <TouchableOpacity onPress={sendEmailWithOtp}>
                <Text>Send OTP</Text>
            </TouchableOpacity>
            <TextInput value={otp} onChangeText={setOtp} placeholder="Enter OTP" />
            <TouchableOpacity onPress={() => verifyOtp(otp)}>
                <Text>Verify</Text>
            </TouchableOpacity>
            <TouchableOpacity onPress={() => reject(new Error("User cancelled"))}>
                <Text>Cancel</Text>
            </TouchableOpacity>
        </View>
    );
}
```

***

## Wallet Methods

The `wallet` instance returned by `useWallet()` provides methods for token transfers, balances, signing, and more.

Since the React Native SDK wraps the Wallets SDK, see the **[Wallets SDK Reference](/sdk-reference/wallets/typescript/classes/Wallet)** for complete documentation.

| Method                                                                                                             | Description                                                                                                                                                                                                 |
| ------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [`wallet.addDelegatedSigner()`](/sdk-reference/wallets/typescript/classes/Wallet#adddelegatedsigner)               | Add a delegated signer to the wallet                                                                                                                                                                        |
| [`wallet.balances()`](/sdk-reference/wallets/typescript/classes/Wallet#balances)                                   | Get the wallet balances - always includes USDC and native token (ETH/SOL)                                                                                                                                   |
| [`wallet.delegatedSigners()`](/sdk-reference/wallets/typescript/classes/Wallet#delegatedsigners)                   | List the delegated signers for this wallet.                                                                                                                                                                 |
| [`wallet.experimental_activity()`](/sdk-reference/wallets/typescript/classes/Wallet#experimental-activity)         | Get the wallet activity                                                                                                                                                                                     |
| [`wallet.experimental_nfts()`](/sdk-reference/wallets/typescript/classes/Wallet#experimental-nfts)                 | Get the wallet NFTs                                                                                                                                                                                         |
| [`wallet.experimental_transaction()`](/sdk-reference/wallets/typescript/classes/Wallet#experimental-transaction)   | Get a transaction by id                                                                                                                                                                                     |
| [`wallet.experimental_transactions()`](/sdk-reference/wallets/typescript/classes/Wallet#experimental-transactions) | Get the wallet transactions                                                                                                                                                                                 |
| [`wallet.send()`](/sdk-reference/wallets/typescript/classes/Wallet#send)                                           | Send a token to a wallet or user locator                                                                                                                                                                    |
| [`wallet.stagingFund()`](/sdk-reference/wallets/typescript/classes/Wallet#stagingfund)                             | Funds the wallet with Crossmint's stablecoin (USDXM).  **Note:** This method is only available in staging environments and exclusively supports USDXM tokens. It cannot be used in production environments. |

**Chain-specific:**

* [`EVMWallet`](/sdk-reference/wallets/typescript/classes/EVMWallet) — `getViemClient()`, `sendTransaction()`, `signMessage()`, `signTypedData()`
* [`SolanaWallet`](/sdk-reference/wallets/typescript/classes/SolanaWallet) — `sendTransaction()`
* [`StellarWallet`](/sdk-reference/wallets/typescript/classes/StellarWallet) — `sendTransaction()`


# Providers
Source: https://docs.crossmint.com/sdk-reference/wallets/react-native/providers

React Native context providers for React Native SDK reference for Crossmint wallets

1. `CrossmintProvider` — SDK initialization (required for all Crossmint features)
2. `CrossmintWalletProvider` — Wallet creation and management

***

## CrossmintProvider

Root provider for the Crossmint SDK. Must wrap your entire application. Initializes the SDK with your API key and sets up logging.

### Props

<ResponseField name="apiKey" type="string">
  Your Crossmint client-side API key.
</ResponseField>

<ResponseField name="consoleLogLevel" type="ConsoleLogLevel">
  Minimum log level for console output (or "silent" to suppress all output). Logs below this level will not be written to the console. Set to "silent" to completely suppress console output. Defaults to "debug" (all logs shown) for backward compatibility.
</ResponseField>

<ResponseField name="overrideBaseUrl" type="string">
  Override the base API URL.
</ResponseField>

### Usage

```tsx theme={null}
import { CrossmintProvider } from "@crossmint/client-sdk-react-native-ui";

function App() {
    return (
        <CrossmintProvider apiKey="YOUR_CLIENT_API_KEY">
            {/* Your app content */}
        </CrossmintProvider>
    );
}
```

***

## CrossmintWalletProvider

Provider for wallet creation and management. Must be nested inside CrossmintProvider. Handles secure communication with the Crossmint signer via a hidden WebView.

### Props

<ResponseField name="appearance" type="UIConfig">
  Optional appearance configuration for styling built-in UI components.
</ResponseField>

<ResponseField name="callbacks" type="{ onTransactionStart?: () => Promise<void>; onWalletCreationStart?: () => Promise<void> }">
  Optional lifecycle callbacks invoked during wallet creation and transaction signing.
</ResponseField>

<ResponseField name="createOnLogin" type="CreateOnLogin">
  Wallet configuration for automatic creation on user login. Defines the chain and signer type for the wallet.

  <Expandable title="properties">
    <ResponseField name="chain" type="Chain">
      The blockchain to create the wallet on (e.g. "base-sepolia").
    </ResponseField>

    <ResponseField name="signer" type="SignerConfigForChain">
      The signer configuration (e.g. `{ type: "email" }`).
    </ResponseField>

    <ResponseField name="owner" type="string">
      Optional owner identifier.
    </ResponseField>

    <ResponseField name="alias" type="string">
      Optional wallet alias.
    </ResponseField>

    <ResponseField name="plugins" type="WalletPlugin[]">
      Optional array of wallet plugins.
    </ResponseField>

    <ResponseField name="delegatedSigners" type="DelegatedSigner[]">
      Optional array of delegated signers.
    </ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="headlessSigningFlow" type="boolean">
  When true (default), no UI is rendered and signing flows must be handled manually. When false, built-in UI components are rendered.
</ResponseField>

### Usage

```tsx theme={null}
import {
    CrossmintProvider,
    CrossmintWalletProvider,
} from "@crossmint/client-sdk-react-native-ui";

function App() {
    return (
        <CrossmintProvider apiKey="YOUR_CLIENT_API_KEY">
            <CrossmintWalletProvider
                createOnLogin={{
                    chain: "base-sepolia",
                    signer: { type: "email" },
                }}
            >
                {/* Your app content */}
            </CrossmintWalletProvider>
        </CrossmintProvider>
    );
}
```

> **Note:** CrossmintWalletProvider must be nested inside CrossmintProvider.


# Components
Source: https://docs.crossmint.com/sdk-reference/wallets/react/components

React components for React SDK reference for Crossmint wallets

***

## ExportPrivateKeyButton

### Props

<ResponseField name="appearance" type="UIConfig">
  Optional appearance configuration for styling the export button.
</ResponseField>

### Usage

```tsx theme={null}
import { ExportPrivateKeyButton } from "@crossmint/client-sdk-react-ui";

function WalletSettings() {
    return (
        <div>
            <h3>Export Private Key</h3>
            <ExportPrivateKeyButton
                appearance={{
                    colors: { border: "#e2e8f0" },
                    borderRadius: "12px",
                }}
            />
        </div>
    );
}
```

> **Note:** Only works with email and phone signers. Will not render for passkey or external wallet signers.


# Get Started
Source: https://docs.crossmint.com/sdk-reference/wallets/react/get-started

Installation and setup for the React SDK reference for Crossmint wallets

### Latest React SDK version - <a href="https://www.npmjs.com/package/@crossmint/client-sdk-react-ui"><img alt="npm" /></a>

The Crossmint React SDK (`@crossmint/client-sdk-react-ui`) provides React components and hooks for integrating Crossmint wallets into your application.

## Installation

<Snippet />

## Provider Setup

Wrap your application with the required providers:

```tsx theme={null}
import {
    CrossmintProvider,
    CrossmintWalletProvider,
} from "@crossmint/client-sdk-react-ui";

function App() {
    return (
        <CrossmintProvider apiKey="YOUR_CLIENT_API_KEY">
            <CrossmintWalletProvider
                createOnLogin={{
                    chain: "base-sepolia",
                    signer: { type: "email" },
                }}
            >
                {/* Your app components */}
            </CrossmintWalletProvider>
        </CrossmintProvider>
    );
}
```

## Quick Example

Once providers are set up, use hooks to access wallet state:

```tsx theme={null}
import { useWallet } from "@crossmint/client-sdk-react-ui";

function WalletInfo() {
    const { wallet, status } = useWallet();

    if (status === "in-progress") return <p>Loading wallet...</p>;
    if (!wallet) return <p>No wallet connected</p>;

    return (
        <div>
            <p>Address: {wallet.address}</p>
            <p>Chain: {wallet.chain}</p>
        </div>
    );
}
```

## Next Steps

* [Providers](/sdk-reference/wallets/react/providers) — Configure providers and their options
* [Hooks](/sdk-reference/wallets/react/hooks) — Access SDK state via React hooks
* [Components](/sdk-reference/wallets/react/components) — Drop-in UI components
* [Wallets SDK Reference](/sdk-reference/wallets/typescript/classes/Wallet) — Complete wallet method documentation


# Hooks
Source: https://docs.crossmint.com/sdk-reference/wallets/react/hooks

React hooks for React SDK reference for Crossmint wallets

***

## useWallet()

### Returns

<ResponseField name="wallet" type="Wallet | undefined">
  The current wallet instance, or undefined if no wallet is loaded.
</ResponseField>

<ResponseField name="status" type="WalletStatus">
  Current wallet status. Options: `not-loaded` | `in-progress` | `loaded` | `error`.
</ResponseField>

<ResponseField name="getOrCreateWallet" type="(args: WalletArgsFor<Chain>) => Promise<Wallet | undefined>">
  Creates a new wallet or retrieves an existing one.

  <Expandable title="parameters">
    <ResponseField name="chain" type="Chain">
      The blockchain to create the wallet on (e.g. "base-sepolia").
    </ResponseField>

    <ResponseField name="signer" type="SignerConfigForChain">
      The signer configuration (e.g. `{ type: "email" }`).
    </ResponseField>

    <ResponseField name="owner" type="string">
      Optional owner identifier.
    </ResponseField>

    <ResponseField name="alias" type="string">
      Optional wallet alias.
    </ResponseField>

    <ResponseField name="plugins" type="WalletPlugin[]">
      Optional array of wallet plugins.
    </ResponseField>

    <ResponseField name="delegatedSigners" type="DelegatedSigner[]">
      Optional array of delegated signers.
    </ResponseField>
  </Expandable>
</ResponseField>

### Usage

```tsx theme={null}
import { useWallet } from "@crossmint/client-sdk-react-ui";

function WalletActions() {
    const { wallet, status } = useWallet();

    if (status === "in-progress") return <p>Loading wallet...</p>;
    if (!wallet) return <p>No wallet</p>;

    const handleSend = async () => {
        const tx = await wallet.send("0x...", "usdc", "10");
        console.log("Transaction:", tx.explorerLink);
    };

    const handleBalances = async () => {
        const balances = await wallet.balances();
        console.log("USDC:", balances.usdc.amount);
        console.log("Native:", balances.nativeToken.amount);
    };

    return (
        <div>
            <p>Wallet: {wallet.address}</p>
            <button onClick={handleBalances}>Check Balances</button>
            <button onClick={handleSend}>Send USDC</button>
        </div>
    );
}
```

***

## Wallet Methods

The `wallet` instance returned by `useWallet()` provides methods for token transfers, balances, signing, and more.

Since the React SDK wraps the Wallets SDK, see the **[Wallets SDK Reference](/sdk-reference/wallets/typescript/classes/Wallet)** for complete documentation.

| Method                                                                                                             | Description                                                                                                                                                                                                 |
| ------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [`wallet.addDelegatedSigner()`](/sdk-reference/wallets/typescript/classes/Wallet#adddelegatedsigner)               | Add a delegated signer to the wallet                                                                                                                                                                        |
| [`wallet.balances()`](/sdk-reference/wallets/typescript/classes/Wallet#balances)                                   | Get the wallet balances - always includes USDC and native token (ETH/SOL)                                                                                                                                   |
| [`wallet.delegatedSigners()`](/sdk-reference/wallets/typescript/classes/Wallet#delegatedsigners)                   | List the delegated signers for this wallet.                                                                                                                                                                 |
| [`wallet.experimental_activity()`](/sdk-reference/wallets/typescript/classes/Wallet#experimental-activity)         | Get the wallet activity                                                                                                                                                                                     |
| [`wallet.experimental_nfts()`](/sdk-reference/wallets/typescript/classes/Wallet#experimental-nfts)                 | Get the wallet NFTs                                                                                                                                                                                         |
| [`wallet.experimental_transaction()`](/sdk-reference/wallets/typescript/classes/Wallet#experimental-transaction)   | Get a transaction by id                                                                                                                                                                                     |
| [`wallet.experimental_transactions()`](/sdk-reference/wallets/typescript/classes/Wallet#experimental-transactions) | Get the wallet transactions                                                                                                                                                                                 |
| [`wallet.send()`](/sdk-reference/wallets/typescript/classes/Wallet#send)                                           | Send a token to a wallet or user locator                                                                                                                                                                    |
| [`wallet.stagingFund()`](/sdk-reference/wallets/typescript/classes/Wallet#stagingfund)                             | Funds the wallet with Crossmint's stablecoin (USDXM).  **Note:** This method is only available in staging environments and exclusively supports USDXM tokens. It cannot be used in production environments. |

**Chain-specific:**

* [`EVMWallet`](/sdk-reference/wallets/typescript/classes/EVMWallet) — `getViemClient()`, `sendTransaction()`, `signMessage()`, `signTypedData()`
* [`SolanaWallet`](/sdk-reference/wallets/typescript/classes/SolanaWallet) — `sendTransaction()`
* [`StellarWallet`](/sdk-reference/wallets/typescript/classes/StellarWallet) — `sendTransaction()`


# Providers
Source: https://docs.crossmint.com/sdk-reference/wallets/react/providers

React context providers for React SDK reference for Crossmint wallets

1. `CrossmintProvider` — SDK initialization (required for all Crossmint features)
2. `CrossmintWalletProvider` — Wallet creation and management

***

## CrossmintProvider

### Props

<ResponseField name="apiKey" type="string">
  Your Crossmint client-side API key.
</ResponseField>

<ResponseField name="appId" type="string">
  Application identifier, sent as `x-app-identifier` header.
</ResponseField>

<ResponseField name="consoleLogLevel" type="ConsoleLogLevel">
  Minimum log level for console output (or "silent" to suppress all output). Logs below this level will not be written to the console. Set to "silent" to completely suppress console output. Defaults to "debug" (all logs shown) for backward compatibility.
</ResponseField>

<ResponseField name="extensionId" type="string">
  Extension identifier, sent as `x-extension-id` header.
</ResponseField>

<ResponseField name="jwt" type="string">
  JWT token for authentication.
</ResponseField>

<ResponseField name="overrideBaseUrl" type="string">
  Override the base API URL.
</ResponseField>

### Usage

```tsx theme={null}
import { CrossmintProvider } from "@crossmint/client-sdk-react-ui";

function App() {
    return (
        <CrossmintProvider apiKey="YOUR_CLIENT_API_KEY">
            {/* Your app content */}
        </CrossmintProvider>
    );
}
```

***

## CrossmintWalletProvider

### Props

<ResponseField name="appearance" type="UIConfig">
  Appearance configuration for wallet UI components.
</ResponseField>

<ResponseField name="callbacks" type="{ onTransactionStart?: () => Promise<void>; onWalletCreationStart?: () => Promise<void> }">
  Lifecycle callbacks for wallet creation and transaction events.
</ResponseField>

<ResponseField name="createOnLogin" type="CreateOnLogin">
  Configuration for automatic wallet creation on login.

  <Expandable title="properties">
    <ResponseField name="chain" type="Chain">
      The blockchain to create the wallet on (e.g. "base-sepolia").
    </ResponseField>

    <ResponseField name="signer" type="SignerConfigForChain">
      The signer configuration (e.g. `{ type: "email" }`).
    </ResponseField>

    <ResponseField name="owner" type="string">
      Optional owner identifier.
    </ResponseField>

    <ResponseField name="alias" type="string">
      Optional wallet alias.
    </ResponseField>

    <ResponseField name="plugins" type="WalletPlugin[]">
      Optional array of wallet plugins.
    </ResponseField>

    <ResponseField name="delegatedSigners" type="DelegatedSigner[]">
      Optional array of delegated signers.
    </ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="showPasskeyHelpers" type="boolean">
  Whether to show passkey helper UI. Default: true.
</ResponseField>

### Usage

```tsx theme={null}
import {
    CrossmintProvider,
    CrossmintWalletProvider,
} from "@crossmint/client-sdk-react-ui";

function App() {
    return (
        <CrossmintProvider apiKey="YOUR_CLIENT_API_KEY">
            <CrossmintWalletProvider
                createOnLogin={{
                    chain: "base-sepolia",
                    signer: { type: "email" },
                }}
            >
                {/* Your app content */}
            </CrossmintWalletProvider>
        </CrossmintProvider>
    );
}
```

> **Note:** CrossmintWalletProvider must be nested inside CrossmintProvider.


# ABI
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/classes/abi

Swift Class

**Class**

```swift theme={null}
class ABI
```

## Enumerations

### ABI.Argument

```swift theme={null}
enum Argument
```

### ABI.Error

```swift theme={null}
enum Error
```


# ApiKeySigner
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/classes/apikeysigner

Swift Class

<Note>
  [Contact us](https://www.crossmint.com/contact/sales) for access to API key signers.
</Note>

**Class**

```swift theme={null}
class ApiKeySigner
```

## Initializers

### init(adminSigner:)

```swift theme={null}
init(adminSigner: ApiKeySignerData = ApiKeySignerData())
```

## Instance Properties

### adminSigner

Inherited from `Signer.adminSigner`.

```swift theme={null}
let adminSigner: ApiKeySignerData
```

### signerType

Inherited from `Signer.signerType`.

```swift theme={null}
nonisolated let signerType: SignerType
```

## Instance Methods

### approvals(withSignature:)

Inherited from `Signer.approvals(withSignature:)`.

```swift theme={null}
func approvals(withSignature signature: String) async throws(SignerError) -> [SignRequestApi.Approval]
```

### initialize(\_:)

Inherited from `Signer.initialize(_:)`.

```swift theme={null}
func initialize(_ service: SmartWalletService?) async throws(SignerError)
```

### sign(message:)

Inherited from `Signer.sign(message:)`.

```swift theme={null}
func sign(message: String) async throws(SignerError) -> String
```

## Type Aliases

### ApiKeySigner.AdminType

Inherited from `Signer.AdminType`.

```swift theme={null}
typealias AdminType = ApiKeySignerData
```


# CrossmintAuthManager
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/classes/crossmintauthmanager

Swift Class

**Class**

```swift theme={null}
actor CrossmintAuthManager
```

## Initializers

### init(apiKey:)

```swift theme={null}
convenience init(apiKey apiKeyString: String) throws
```

### init(authService:secureStorage:)

```swift theme={null}
init(authService: any AuthService, secureStorage: any SecureStorage)
```

## Instance Properties

### authenticationStatus

```swift theme={null}
var authenticationStatus: AuthenticationStatus { get async throws(AuthError) }
```

### email

```swift theme={null}
var email: String? { get }
```

### jwt

Inherited from `AuthManager.jwt`.

```swift theme={null}
var jwt: String? { get }
```

## Instance Methods

### logout()

```swift theme={null}
func logout() async throws(AuthManagerError) -> OTPAuthenticationStatus
```

### oneTimeSecretAuthentication(oneTimeSecret:)

```swift theme={null}
func oneTimeSecretAuthentication(oneTimeSecret: String) async throws(AuthManagerError) -> OTPAuthenticationStatus
```

### otpAuthentication(email:code:forceRefresh:)

```swift theme={null}
func otpAuthentication(email: String, code: String? = nil, forceRefresh: Bool = false) async throws(AuthManagerError) -> OTPAuthenticationStatus
```

### reset()

```swift theme={null}
func reset() async -> OTPAuthenticationStatus
```

### setJWT(\_:)

Inherited from `AuthManager.setJWT(_:)`.

```swift theme={null}
func setJWT(_ jwt: String) async
```


# CrossmintClient
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/classes/crossmintclient

Swift Class

**Class**

```swift theme={null}
actor CrossmintClient
```

## Type Methods

### sdk(key:authManager:)

```swift theme={null}
static func sdk(key: String, authManager: AuthManager? = nil) throws -> ClientSDK
```

## Enumerations

### CrossmintClient.Error

```swift theme={null}
enum Error
```


# CrossmintClientSDK
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/classes/crossmintclientsdk

Swift Class

**Class**

```swift theme={null}
final class CrossmintClientSDK
```

## Instance Properties

### authManager

Inherited from `ClientSDK.authManager`.

```swift theme={null}
let authManager: any CrossmintAuth.AuthManager
```

### crossmintService

Inherited from `ClientSDK.crossmintService`.

```swift theme={null}
let crossmintService: CrossmintService
```

## Instance Methods

### crossmintWallets()

Inherited from `ClientSDK.crossmintWallets()`.

```swift theme={null}
func crossmintWallets() -> CrossmintWallets
```


# CrossmintSDK
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/classes/crossmintsdk

Swift Class

**Class**

The main entry point for interacting with the Crossmint SDK.

```swift theme={null}
@MainActor final class CrossmintSDK
```

`CrossmintSDK` provides access to Crossmint’s wallet services, authentication, and blockchain functionality. Use the shared instance to integrate Crossmint features into your SwiftUI application.
Initialize the SDK with your API key before accessing any functionality:

```swift theme={null}
let sdk = CrossmintSDK.shared(apiKey: "your-api-key")
```

Then use the SDK to access wallets and authentication:

```swift theme={null}
// Get or create a wallet
let wallet = try await sdk.crossmintWallets.getOrCreateWallet(
    type: .evm,
    linkedUser: "user@example.com"
)

// Sign a transaction
let signature = try await wallet.signTransaction(transaction)
```

## Initialization

### shared

Returns the shared SDK instance.

```swift theme={null}
@MainActor static var shared: CrossmintSDK { get }
```

In debug builds, this property attempts to read the API key from the `CROSSMINT_API_KEY` environment variable. In release builds or if the environment variable is not set, accessing this property without first calling `shared(apiKey:authManager:logLevel:)` will cause a fatal error.

> **Info**: Call `shared(apiKey:authManager:logLevel:)` to initialize the SDK before accessing this property in production.

### shared(apiKey:authManager:logLevel:)

Initializes and returns the shared SDK instance with the specified configuration.

```swift theme={null}
@MainActor static func shared(apiKey: String, authManager: AuthManager? = nil, logLevel: LogLevel = .error) -> CrossmintSDK
```

The shared `CrossmintSDK` instance.

Call this method once during app startup to configure the SDK. Subsequent calls return the existing instance without reinitializing.

```swift theme={null}
@main
struct MyApp: App {
    init() {
        _ = CrossmintSDK.shared(
            apiKey: "your-api-key",
            logLevel: .debug
        )
    }

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}
```

#### Parameters

* **apiKey**: Your Crossmint client API key.

* **authManager**: An optional custom authentication manager. Pass `nil` to use the default.

* **logLevel**: The logging verbosity level. Defaults to `.error`.

## Services

### crossmintWallets

Provides access to Crossmint wallet operations.

```swift theme={null}
@MainActor let crossmintWallets: CrossmintWallets
```

Use this property to create, retrieve, and manage smart wallets across supported blockchains (EVM, Solana).

```swift theme={null}
let wallet = try await CrossmintSDK.shared.crossmintWallets.getOrCreateWallet(
    type: .evm,
    linkedUser: "user@example.com"
)
```

### authManager

Manages user authentication and session state.

```swift theme={null}
@MainActor let authManager: AuthManager
```

Use this property to authenticate users, check login status, and manage sessions.

### crossmintService

Provides low-level access to Crossmint API services.

```swift theme={null}
@MainActor let crossmintService: CrossmintService
```

Most applications should use `crossmintWallets` and `authManager` instead. This property is available for advanced use cases requiring direct API access.

## OTP Verification

### isOTPRequired

A publisher that emits `true` when OTP verification is required.

```swift theme={null}
@MainActor var isOTPRequired: Published<Bool>.Publisher { get }
```

Subscribe to this publisher to present an OTP input UI when the SDK requires additional verification for sensitive operations.

```swift theme={null}
struct ContentView: View {
    @ObservedObject var sdk = CrossmintSDK.shared
    @State private var showOTPSheet = false

    var body: some View {
        MyContent()
            .onReceive(sdk.isOTPRequired) { required in
                showOTPSheet = required
            }
            .sheet(isPresented: $showOTPSheet) {
                OTPInputView()
            }
    }
}
```

### submit(otp:)

Submits an OTP code for verification.

```swift theme={null}
@MainActor func submit(otp: String)
```

Call this method when the user enters their OTP code in response to `isOTPRequired` emitting `true`.

#### Parameters

* **otp**: The one-time password entered by the user.

### cancelTransaction()

Cancels the current transaction requiring OTP verification.

```swift theme={null}
@MainActor func cancelTransaction()
```

Call this method if the user dismisses the OTP input without entering a code.

## Session Management

### logout()

Logs out the current user and resets the SDK state.

```swift theme={null}
@MainActor func logout() async throws
```

Call this method when the user signs out of your application to clear any cached authentication state and pending operations.

## Instance Properties

### isProductionEnvironment

Indicates whether the SDK is configured for the production environment.

```swift theme={null}
@MainActor var isProductionEnvironment: Bool { get }
```

Returns `true` if using a production API key, `false` for staging/development keys.


# DefaultAuthService
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/classes/defaultauthservice

Swift Class

**Class**

```swift theme={null}
final class DefaultAuthService
```

## Initializers

### init(crossmintService:jsonCoder:)

```swift theme={null}
init(crossmintService: any CrossmintService, jsonCoder: any JSONCoder = DefaultJSONCoder())
```

## Instance Properties

### jsonCoder

```swift theme={null}
let jsonCoder: any JSONCoder
```

## Instance Methods

### logout(\_:)

Inherited from `AuthService.logout(_:)`.

```swift theme={null}
func logout(_ logoutRequest: LogoutRequest) async throws(AuthError)
```

### refreshJWT(\_:)

Inherited from `AuthService.refreshJWT(_:)`.

```swift theme={null}
func refreshJWT(_ refreshJWTRequest: RefreshJWTRequest) async throws(AuthError) -> RefreshJWTResponse
```

### validateEmail(\_:)

Inherited from `AuthService.validateEmail(_:)`.

```swift theme={null}
func validateEmail(_ validateEmailRequest: ValidateEmailRequest) async throws(AuthError) -> ValidateEmailResponse
```

### validateToken(\_:)

Inherited from `AuthService.validateToken(_:)`.

```swift theme={null}
func validateToken(_ validateTokenRequest: ValidateTokenRequest) async throws(AuthError) -> ValidateTokenResponse
```


# DefaultCrossmintWallets
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/classes/defaultcrossmintwallets

Swift Class

**Class**

```swift theme={null}
final class DefaultCrossmintWallets
```

## Initializers

### init(service:secureWalletStorage:)

```swift theme={null}
init(service: SmartWalletService, secureWalletStorage: SecureWalletStorage)
```

## Instance Methods

### getOrCreateWallet(chain:signer:options:)

Inherited from `CrossmintWallets.getOrCreateWallet(chain:signer:options:)`.

```swift theme={null}
func getOrCreateWallet(chain: Chain, signer: any Signer, options: WalletOptions? = nil) async throws(WalletError) -> Wallet
```


# DefaultSmartWalletService
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/classes/defaultsmartwalletservice

Swift Class

**Class**

```swift theme={null}
final class DefaultSmartWalletService
```

## Initializers

### init(crossmintService:authManager:jsonCoder:)

```swift theme={null}
init(crossmintService: CrossmintService, authManager: AuthManager, jsonCoder: JSONCoder = DefaultJSONCoder())
```

## Instance Properties

### authHeaders

Inherited from `AuthenticatedService.authHeaders`.

```swift theme={null}
var authHeaders: [String : String] { get async }
```

### isProductionEnvironment

Inherited from `SmartWalletService.isProductionEnvironment`.

```swift theme={null}
var isProductionEnvironment: Bool { get }
```

## Instance Methods

### approveSignature(\_:)

Inherited from `SmartWalletService.approveSignature(_:)`.

```swift theme={null}
func approveSignature(_ request: SignRequest) async throws(SignatureError)
```

### createSignature(\_:)

Inherited from `SmartWalletService.createSignature(_:)`.

```swift theme={null}
func createSignature(_ request: CreateSignatureRequest) async throws(SignatureError) -> any SignatureApiModel
```

### createTransaction(\_:)

Inherited from `SmartWalletService.createTransaction(_:)`.

```swift theme={null}
func createTransaction(_ request: CreateTransactionRequest) async throws(TransactionError) -> any TransactionApiModel
```

### createWallet(\_:)

Inherited from `SmartWalletService.createWallet(_:)`.

```swift theme={null}
func createWallet(_ request: CreateWalletParams) async throws(WalletError) -> WalletApiModel
```

### fetchSignature(\_:chainType:)

Inherited from `SmartWalletService.fetchSignature(_:chainType:)`.

```swift theme={null}
func fetchSignature(_ signatureId: String, chainType: ChainType) async throws(SignatureError) -> any SignatureApiModel
```

### fetchTransaction(\_:)

Inherited from `SmartWalletService.fetchTransaction(_:)`.

```swift theme={null}
func fetchTransaction(_ fetchTransactionRequest: FetchTransactionRequest) async throws(TransactionError) -> any TransactionApiModel
```

### fund(\_:)

Inherited from `SmartWalletService.fund(_:)`.

```swift theme={null}
func fund(_ request: FundWalletRequest) async throws(WalletError)
```

### getBalance(\_:)

Inherited from `SmartWalletService.getBalance(_:)`.

```swift theme={null}
func getBalance(_ params: GetBalanceQueryParams) async throws(WalletError) -> Balances
```

### getNFTs(\_:)

Inherited from `SmartWalletService.getNFTs(_:)`.

```swift theme={null}
func getNFTs(_ params: GetNTFQueryParams) async throws(WalletError) -> [NFT]
```

### getWallet(\_:)

Inherited from `SmartWalletService.getWallet(_:)`.

```swift theme={null}
func getWallet(_ request: GetMeWalletRequest) async throws(WalletError) -> WalletApiModel
```

### signTransaction(\_:)

Inherited from `SmartWalletService.signTransaction(_:)`.

```swift theme={null}
func signTransaction(_ request: SignRequest) async throws(TransactionError) -> any TransactionApiModel
```

### transferToken(chainType:tokenLocator:recipient:amount:idempotencyKey:)

Inherited from `SmartWalletService.transferToken(chainType:tokenLocator:recipient:amount:idempotencyKey:)`.

```swift theme={null}
func transferToken(chainType: String, tokenLocator: String, recipient: String, amount: String, idempotencyKey: String? = nil) async throws(TransactionError) -> any TransactionApiModel
```


# EVMEmailSigner
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/classes/evmemailsigner

Swift Class

**Class**

```swift theme={null}
final class EVMEmailSigner
```

## Initializers

### init(email:crossmintTEE:)

```swift theme={null}
init(email: String, crossmintTEE: CrossmintTEE?)
```

## Instance Properties

### adminSigner

Inherited from `Signer.adminSigner`.

```swift theme={null}
var adminSigner: EmailSignerData { get async }
```

### email

```swift theme={null}
var email: String? { get async }
```

### encoding

```swift theme={null}
var encoding: String { get async }
```

### isInitialized

```swift theme={null}
var isInitialized: Bool { get async }
```

### keyType

```swift theme={null}
var keyType: String { get async }
```

### signerType

Inherited from `Signer.signerType`.

```swift theme={null}
nonisolated let signerType: SignerType
```

## Type Aliases

### EVMEmailSigner.AdminType

Inherited from `Signer.AdminType`.

```swift theme={null}
typealias AdminType = EmailSignerData
```


# EVMKeyPairSigner
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/classes/evmkeypairsigner

Swift Class

**Class**

```swift theme={null}
final class EVMKeyPairSigner
```

## Initializers

### init(privateKey:)

```swift theme={null}
init(privateKey: String) throws(SignerError)
```

### init(privateKeyData:)

```swift theme={null}
init(privateKeyData: [UInt8]? = nil) throws(SignerError)
```

## Instance Properties

### adminSigner

Inherited from `Signer.adminSigner`.

```swift theme={null}
var adminSigner: ExternalWalletSignerData { get async }
```

### evmAddress

```swift theme={null}
var evmAddress: EVMAddress { get async }
```

### privateKey

```swift theme={null}
var privateKey: String { get async }
```

### publicKey

```swift theme={null}
var publicKey: String { get async }
```

### signerType

Inherited from `Signer.signerType`.

```swift theme={null}
nonisolated let signerType: SignerType
```

## Instance Methods

### approvals(withSignature:)

Inherited from `Signer.approvals(withSignature:)`.

```swift theme={null}
func approvals(withSignature signature: String) async throws(SignerError) -> [SignRequestApi.Approval]
```

### initialize(\_:)

Inherited from `Signer.initialize(_:)`.

```swift theme={null}
func initialize(_ service: SmartWalletService?) async throws(SignerError)
```

### sign(message:)

Inherited from `Signer.sign(message:)`.

```swift theme={null}
func sign(message: String) async throws(SignerError) -> String
```

## Type Aliases

### EVMKeyPairSigner.AdminType

Inherited from `Signer.AdminType`.

```swift theme={null}
typealias AdminType = ExternalWalletSignerData
```


# EVMWallet
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/classes/evmwallet

Swift Class

**Class**

```swift theme={null}
class EVMWallet
```

## Instance Methods

### sendTransaction(to:data:value:chain:)

```swift theme={null}
func sendTransaction(to address: EVMAddress, data: String?, value: BigInt?, chain: EVMChain) async throws(TransactionError) -> Transaction
```

### sendTransaction(to:value:data:chain:)

```swift theme={null}
func sendTransaction(to address: String, value: String?, data: String?, chain: EVMChain? = nil) async throws(TransactionError) -> TransactionSummary
```

### signMessage(\_:signer:isSmartWalletSignature:)

```swift theme={null}
func signMessage(_ message: String, signer: (any AdminSignerData)? = nil, isSmartWalletSignature: Bool = true) async throws(SignatureError) -> String
```

### signTypedData(\_:signer:isSmartWalletSignature:)

```swift theme={null}
func signTypedData(_ typedData: EIP712.TypedData, signer: (any AdminSignerData)? = nil, isSmartWalletSignature: Bool = true) async throws(SignatureError) -> String
```

## Type Aliases

### EVMWallet.SpecificChain

Inherited from `WalletOnChain.SpecificChain`.

```swift theme={null}
typealias SpecificChain = EVMChain
```

## Type Methods

### from(wallet:)

```swift theme={null}
static func from(wallet: Wallet) throws(WalletError) -> EVMWallet
```


# KeychainSecureStorage
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/classes/keychainsecurestorage

Swift Class

**Class**

```swift theme={null}
final class KeychainSecureStorage
```

## Initializers

### init(bundleId:)

```swift theme={null}
init(bundleId: String)
```

## Instance Methods

### clear()

Inherited from `SecureStorage.clear()`.

```swift theme={null}
func clear()
```

### getEmail()

Inherited from `SecureStorage.getEmail()`.

```swift theme={null}
func getEmail() async throws(SecureStorageError) -> String?
```

### getJWT()

Inherited from `SecureStorage.getJWT()`.

```swift theme={null}
func getJWT() async throws(SecureStorageError) -> String?
```

### getOneTimeSecret()

Inherited from `SecureStorage.getOneTimeSecret()`.

```swift theme={null}
func getOneTimeSecret() async throws(SecureStorageError) -> String?
```

### storeEmail(\_:)

Inherited from `SecureStorage.storeEmail(_:)`.

```swift theme={null}
func storeEmail(_ email: String) async throws(SecureStorageError)
```

### storeJWT(\_:)

Inherited from `SecureStorage.storeJWT(_:)`.

```swift theme={null}
func storeJWT(_ jwt: String) async throws(SecureStorageError)
```

### storeOneTimeSecret(\_:)

Inherited from `SecureStorage.storeOneTimeSecret(_:)`.

```swift theme={null}
func storeOneTimeSecret(_ secret: String) async throws(SecureStorageError)
```


# KeychainSecureWalletStorage
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/classes/keychainsecurewalletstorage

Swift Class

**Class**

```swift theme={null}
final class KeychainSecureWalletStorage
```

## Initializers

### init(bundleId:)

```swift theme={null}
init(bundleId: String)
```

## Instance Methods

### getPrivateKey(forEmail:)

Inherited from `SecureWalletStorage.getPrivateKey(forEmail:)`.

```swift theme={null}
func getPrivateKey(forEmail email: String) -> String?
```

### savePrivateKey(\_:forEmail:)

Inherited from `SecureWalletStorage.savePrivateKey(_:forEmail:)`.

```swift theme={null}
func savePrivateKey(_ privateKey: String, forEmail email: String)
```


# Passkey
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/classes/passkey

Swift Class

**Class**

```swift theme={null}
class Passkey
```

## Initializers

### init()

```swift theme={null}
init()
```

## Instance Methods

### create(\_:forcePlatformKey:forceSecurityKey:)

```swift theme={null}
@MainActor func create(_ options: PasskeyCredentialCreationOptions, forcePlatformKey: Bool, forceSecurityKey: Bool) async throws -> PublicKeyCredentialJSON
```

### get(\_:forcePlatformKey:forceSecurityKey:)

Main get entrypoint

```swift theme={null}
@MainActor func get(_ options: PasskeyCredentialRequestOptions, forcePlatformKey: Bool, forceSecurityKey: Bool) async throws -> PublicKeyCredentialJSON
```


# PasskeySigner
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/classes/passkeysigner

Swift Class

**Class**

```swift theme={null}
final class PasskeySigner
```

## Initializers

### init(name:host:)

```swift theme={null}
init(name: String, host: String)
```

## Instance Properties

### adminSigner

Inherited from `Signer.adminSigner`.

```swift theme={null}
var adminSigner: PasskeySignerData { get async }
```

### signerType

Inherited from `Signer.signerType`.

```swift theme={null}
nonisolated let signerType: SignerType
```

## Instance Methods

### approvals(withSignature:)

Inherited from `Signer.approvals(withSignature:)`.

```swift theme={null}
func approvals(withSignature signature: String) async throws(SignerError) -> [SignRequestApi.Approval]
```

### initialize(\_:)

Inherited from `Signer.initialize(_:)`.

```swift theme={null}
func initialize(_ service: SmartWalletService?) async throws(SignerError)
```

### sign(message:)

Inherited from `Signer.sign(message:)`.

```swift theme={null}
func sign(message: String) async throws(SignerError) -> String
```

### updateAdminSigner(\_:)

```swift theme={null}
func updateAdminSigner(_ adminSigner: PasskeySignerData) async -> any Signer
```

## Type Aliases

### PasskeySigner.AdminType

Inherited from `Signer.AdminType`.

```swift theme={null}
typealias AdminType = PasskeySignerData
```


# SolanaEmailSigner
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/classes/solanaemailsigner

Swift Class

**Class**

```swift theme={null}
final class SolanaEmailSigner
```

## Initializers

### init(email:crossmintTEE:)

```swift theme={null}
init(email: String, crossmintTEE: CrossmintTEE?)
```

## Instance Properties

### adminSigner

Inherited from `Signer.adminSigner`.

```swift theme={null}
var adminSigner: EmailSignerData { get async }
```

### email

```swift theme={null}
var email: String? { get async }
```

### encoding

```swift theme={null}
var encoding: String { get async }
```

### isInitialized

```swift theme={null}
var isInitialized: Bool { get async }
```

### keyType

```swift theme={null}
var keyType: String { get async }
```

### signerType

Inherited from `Signer.signerType`.

```swift theme={null}
nonisolated let signerType: SignerType
```

## Type Aliases

### SolanaEmailSigner.AdminType

Inherited from `Signer.AdminType`.

```swift theme={null}
typealias AdminType = EmailSignerData
```


# SolanaWallet
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/classes/solanawallet

Swift Class

**Class**

```swift theme={null}
final class SolanaWallet
```

## Instance Methods

### sendTransaction(transaction:)

```swift theme={null}
func sendTransaction(transaction: String) async throws(TransactionError) -> TransactionSummary
```

### sendTransaction(transaction:)

```swift theme={null}
func sendTransaction(transaction: String) async throws(TransactionError) -> Transaction
```

## Type Aliases

### SolanaWallet.SpecificChain

Inherited from `WalletOnChain.SpecificChain`.

```swift theme={null}
typealias SpecificChain = SolanaChain
```

## Type Methods

### from(wallet:)

```swift theme={null}
static func from(wallet: Wallet) throws(WalletError) -> SolanaWallet
```


# StellarEmailSigner
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/classes/stellaremailsigner

Swift Class

**Class**

```swift theme={null}
final class StellarEmailSigner
```

## Initializers

### init(email:crossmintTEE:)

```swift theme={null}
init(email: String, crossmintTEE: CrossmintTEE?)
```

## Instance Properties

### adminSigner

Inherited from `Signer.adminSigner`.

```swift theme={null}
var adminSigner: EmailSignerData { get async }
```

### email

```swift theme={null}
var email: String? { get async }
```

### encoding

```swift theme={null}
var encoding: String { get async }
```

### isInitialized

```swift theme={null}
var isInitialized: Bool { get async }
```

### keyType

```swift theme={null}
var keyType: String { get async }
```

### signerType

Inherited from `Signer.signerType`.

```swift theme={null}
nonisolated let signerType: SignerType
```

## Type Aliases

### StellarEmailSigner.AdminType

Inherited from `Signer.AdminType`.

```swift theme={null}
typealias AdminType = EmailSignerData
```


# StellarWallet
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/classes/stellarwallet

Swift Class

**Class**

```swift theme={null}
final class StellarWallet
```

## Instance Methods

### sendTransaction(transaction:)

```swift theme={null}
func sendTransaction(transaction: String) async throws(TransactionError) -> TransactionSummary
```

## Type Aliases

### StellarWallet.SpecificChain

Inherited from `WalletOnChain.SpecificChain`.

```swift theme={null}
typealias SpecificChain = StellarChain
```

## Type Methods

### from(wallet:)

```swift theme={null}
static func from(wallet: Wallet) throws(WalletError) -> StellarWallet
```


# Wallet
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/classes/wallet

Swift Class

**Class**

```swift theme={null}
class Wallet
```

## Instance Properties

### address

```swift theme={null}
var address: String { get }
```

## Instance Methods

### approve(transactionId:)

```swift theme={null}
func approve(transactionId id: String) async throws(TransactionError) -> Transaction
```

### balance(of:)

```swift theme={null}
func balance(of tokens: [CryptoCurrency] = []) async throws(WalletError) -> Balances
```

### balances(*:*:)

```swift theme={null}
func balances(_ tokens: [CryptoCurrency] = [], _ chains: [Chain] = []) async throws(WalletError) -> Balance
```

### fund(token:amount:)

```swift theme={null}
func fund(token: CryptoCurrency, amount: Int) async throws(WalletError)
```

### nfts(page:nftsPerPage:)

```swift theme={null}
func nfts(page: Int, nftsPerPage: Int) async throws(WalletError) -> [NFT]
```

### send(*:*:\_:idempotencyKey:)

Sends tokens to a recipient.

```swift theme={null}
func send(_ walletLocator: String, _ tokenLocator: String, _ amount: Double, idempotencyKey: String? = nil) async throws(TransactionError) -> TransactionSummary
```

A TransactionSummary containing the transaction details

#### Parameters

* **walletLocator**: The recipient wallet address

* **tokenLocator**: Token identifier in format “:” (e.g., “base-sepolia:eth”, “solana:usdc”)

* **amount**: The amount to send as a decimal number

* **idempotencyKey**: Optional unique key to prevent duplicate transaction creation. If not provided, a random UUID will be generated.

### send(token:recipient:amount:)

```swift theme={null}
func send(token: CryptoCurrency, recipient: TransferTokenRecipient, amount: String) async throws(TransactionError) -> Transaction
```

### transferToken(tokenId:recipient:amount:)

```swift theme={null}
func transferToken(tokenId: String? = nil, recipient: TransferTokenRecipient, amount: String) async throws(TransactionError) -> Transaction
```


# Address
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/address

Swift Enumeration

**Enumeration**

```swift theme={null}
enum Address
```

## Enumeration Cases

### Address.evm(\_:)

```swift theme={null}
case evm(EVMAddress)
```

### Address.solana(\_:)

```swift theme={null}
case solana(SolanaAddress)
```

### Address.stellar(\_:)

```swift theme={null}
case stellar(StellarAddress)
```

## Initializers

### init(address:)

Inherited from `BlockchainAddress.init(address:)`.

```swift theme={null}
init(address: String) throws(BlockchainAddressError)
```

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

## Instance Properties

### description

Inherited from `CustomStringConvertible.description`.

```swift theme={null}
var description: String { get }
```

### hiddenPublicKeyAddress

```swift theme={null}
var hiddenPublicKeyAddress: String { get }
```

## Instance Methods

### encode(to:)

Inherited from `Encodable.encode(to:)`.

```swift theme={null}
func encode(to encoder: Encoder) throws
```

## Type Methods

### validateAddressAndReturnAddress(\_:chain:)

```swift theme={null}
static func validateAddressAndReturnAddress(_ address: String, chain: Chain? = nil) -> Address?
```


# AdminSignerDataType
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/adminsignerdatatype

Swift Enumeration

**Enumeration**

```swift theme={null}
enum AdminSignerDataType
```

## Enumeration Cases

### AdminSignerDataType.apiKey

```swift theme={null}
case apiKey
```

### AdminSignerDataType.email

```swift theme={null}
case email
```

### AdminSignerDataType.externalWallet

```swift theme={null}
case externalWallet
```

### AdminSignerDataType.passkey

```swift theme={null}
case passkey
```

### AdminSignerDataType.phone

```swift theme={null}
case phone
```

## Initializers

### init(rawValue:)

Inherited from `RawRepresentable.init(rawValue:)`.

```swift theme={null}
init?(rawValue: String)
```


# AttestationConveyancePreference
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/attestationconveyancepreference

Swift Enumeration

**Enumeration**

Specification reference: [https://w3c.github.io/webauthn/#enum-attestation-convey](https://w3c.github.io/webauthn/#enum-attestation-convey)

```swift theme={null}
enum AttestationConveyancePreference
```

## Enumeration Cases

### AttestationConveyancePreference.direct

```swift theme={null}
case direct
```

### AttestationConveyancePreference.enterprise

```swift theme={null}
case enterprise
```

### AttestationConveyancePreference.indirect

```swift theme={null}
case indirect
```

### AttestationConveyancePreference.none

```swift theme={null}
case none
```

## Initializers

### init(rawValue:)

Inherited from `RawRepresentable.init(rawValue:)`.

```swift theme={null}
init?(rawValue: String)
```


# AttestationParsingError
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/attestationparsingerror

Swift Enumeration

**Enumeration**

```swift theme={null}
enum AttestationParsingError
```

## Enumeration Cases

### AttestationParsingError.attestedCredentialDataMissing

```swift theme={null}
case attestedCredentialDataMissing
```

### AttestationParsingError.authDataTooShort

```swift theme={null}
case authDataTooShort
```

### AttestationParsingError.cborDecodingFailed(description:)

```swift theme={null}
case cborDecodingFailed(description: String)
```

### AttestationParsingError.coordinateExtractionFailed

```swift theme={null}
case coordinateExtractionFailed
```

### AttestationParsingError.coseKeyDecodingFailed

```swift theme={null}
case coseKeyDecodingFailed
```

### AttestationParsingError.invalidAttestationObject(description:)

```swift theme={null}
case invalidAttestationObject(description: String)
```

### AttestationParsingError.invalidCoordinateData

```swift theme={null}
case invalidCoordinateData
```

### AttestationParsingError.invalidCoseKeyFormat

```swift theme={null}
case invalidCoseKeyFormat
```


# AuthenticationStatus
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/authenticationstatus

Swift Enumeration

**Enumeration**

```swift theme={null}
enum AuthenticationStatus
```

## Enumeration Cases

### AuthenticationStatus.authenticated(email:jwt:secret:)

```swift theme={null}
case authenticated(email: String, jwt: String, secret: String)
```

### AuthenticationStatus.authenticating

```swift theme={null}
case authenticating
```

### AuthenticationStatus.nonAuthenticated

```swift theme={null}
case nonAuthenticated
```

## Instance Properties

### isAuthenticated

```swift theme={null}
var isAuthenticated: Bool { get }
```


# AuthenticatorAttachment
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/authenticatorattachment

Swift Enumeration

**Enumeration**

Specification reference: [https://w3c.github.io/webauthn/#enum-attachment](https://w3c.github.io/webauthn/#enum-attachment)

```swift theme={null}
enum AuthenticatorAttachment
```

## Enumeration Cases

### AuthenticatorAttachment.crossPlatform

```swift theme={null}
case crossPlatform
```

### AuthenticatorAttachment.platform

```swift theme={null}
case platform
```

## Initializers

### init(rawValue:)

Inherited from `RawRepresentable.init(rawValue:)`.

```swift theme={null}
init?(rawValue: String)
```


# AuthenticatorTransport
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/authenticatortransport

Swift Enumeration

**Enumeration**

Specification reference: [https://w3c.github.io/webauthn/#enum-transport](https://w3c.github.io/webauthn/#enum-transport)

```swift theme={null}
enum AuthenticatorTransport
```

## Enumeration Cases

### AuthenticatorTransport.ble

```swift theme={null}
case ble
```

### AuthenticatorTransport.hybrid

```swift theme={null}
case hybrid
```

### AuthenticatorTransport.nfc

```swift theme={null}
case nfc
```

### AuthenticatorTransport.usb

```swift theme={null}
case usb
```

## Initializers

### init(rawValue:)

Inherited from `RawRepresentable.init(rawValue:)`.

```swift theme={null}
init?(rawValue: String)
```


# AuthError
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/autherror

Swift Enumeration

**Enumeration**

```swift theme={null}
enum AuthError
```

## Enumeration Cases

### AuthError.generic(\_:)

```swift theme={null}
case generic(String)
```

### AuthError.serviceError(\_:)

```swift theme={null}
case serviceError(CrossmintServiceError)
```

### AuthError.signInRequired

```swift theme={null}
case signInRequired
```

## Instance Properties

### errorMessage

Inherited from `ServiceError.errorMessage`.

```swift theme={null}
var errorMessage: String { get }
```

## Type Methods

### fromNetworkError(\_:)

Inherited from `ServiceError.fromNetworkError(_:)`.

```swift theme={null}
static func fromNetworkError(_ error: NetworkError) -> AuthError
```

### fromServiceError(\_:)

Inherited from `ServiceError.fromServiceError(_:)`.

```swift theme={null}
static func fromServiceError(_ error: CrossmintServiceError) -> AuthError
```


# AuthManagerError
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/authmanagererror

Swift Enumeration

**Enumeration**

```swift theme={null}
enum AuthManagerError
```

## Enumeration Cases

### AuthManagerError.serviceError(\_:)

```swift theme={null}
case serviceError(String)
```

### AuthManagerError.unknown(\_:)

```swift theme={null}
case unknown(String)
```

## Instance Properties

### errorMessage

```swift theme={null}
var errorMessage: String { get }
```


# BlockchainAddressError
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/blockchainaddresserror

Swift Enumeration

**Enumeration**

```swift theme={null}
enum BlockchainAddressError
```

## Enumeration Cases

### BlockchainAddressError.chainNotSupported(\_:)

```swift theme={null}
case chainNotSupported(String)
```

### BlockchainAddressError.invalidAptosAddress(\_:)

```swift theme={null}
case invalidAptosAddress(String)
```

### BlockchainAddressError.invalidCardanoAddress(\_:)

```swift theme={null}
case invalidCardanoAddress(String)
```

### BlockchainAddressError.invalidEVMAddress(\_:)

```swift theme={null}
case invalidEVMAddress(String)
```

### BlockchainAddressError.invalidSolanaAddress(\_:)

```swift theme={null}
case invalidSolanaAddress(String)
```

### BlockchainAddressError.invalidStellarAddress(\_:)

```swift theme={null}
case invalidStellarAddress(String)
```

### BlockchainAddressError.invalidSuiAddress(\_:)

```swift theme={null}
case invalidSuiAddress(String)
```


# BlockchainExplorerLinkType
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/blockchainexplorerlinktype

Swift Enumeration

**Enumeration**

```swift theme={null}
enum BlockchainExplorerLinkType
```

## Enumeration Cases

### BlockchainExplorerLinkType.address(\_:)

```swift theme={null}
case address(BlockchainAddressLink)
```


# Chain
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/chain

Swift Enumeration

**Enumeration**

```swift theme={null}
enum Chain
```

## Enumeration Cases

### Chain.apechain

```swift theme={null}
case apechain
```

### Chain.apex

```swift theme={null}
case apex
```

### Chain.arbitrum

```swift theme={null}
case arbitrum
```

### Chain.arbitrumSepolia

```swift theme={null}
case arbitrumSepolia
```

### Chain.arbitrumnova

```swift theme={null}
case arbitrumnova
```

### Chain.astarZkevm

```swift theme={null}
case astarZkevm
```

### Chain.avalanche

```swift theme={null}
case avalanche
```

### Chain.avalancheFuji

```swift theme={null}
case avalancheFuji
```

### Chain.barretTestnet

```swift theme={null}
case barretTestnet
```

### Chain.base

```swift theme={null}
case base
```

### Chain.baseGoerli

```swift theme={null}
case baseGoerli
```

### Chain.baseSepolia

```swift theme={null}
case baseSepolia
```

### Chain.bsc

```swift theme={null}
case bsc
```

### Chain.bscTestnet

```swift theme={null}
case bscTestnet
```

### Chain.chiliz

```swift theme={null}
case chiliz
```

### Chain.chilizSpicyTestnet

```swift theme={null}
case chilizSpicyTestnet
```

### Chain.coti

```swift theme={null}
case coti
```

### Chain.cotiTestnet

```swift theme={null}
case cotiTestnet
```

### Chain.curtis

```swift theme={null}
case curtis
```

### Chain.ethereum

```swift theme={null}
case ethereum
```

### Chain.ethereumGoerli

```swift theme={null}
case ethereumGoerli
```

### Chain.ethereumSepolia

```swift theme={null}
case ethereumSepolia
```

### Chain.hypersonicTestnet

```swift theme={null}
case hypersonicTestnet
```

### Chain.lightlink

```swift theme={null}
case lightlink
```

### Chain.lightlinkPegasus

```swift theme={null}
case lightlinkPegasus
```

### Chain.mode

```swift theme={null}
case mode
```

### Chain.modeSepolia

```swift theme={null}
case modeSepolia
```

### Chain.optimism

```swift theme={null}
case optimism
```

### Chain.optimismGoerli

```swift theme={null}
case optimismGoerli
```

### Chain.optimismSepolia

```swift theme={null}
case optimismSepolia
```

### Chain.polygon

```swift theme={null}
case polygon
```

### Chain.polygonAmoy

```swift theme={null}
case polygonAmoy
```

### Chain.polygonMumbai

```swift theme={null}
case polygonMumbai
```

### Chain.rari

```swift theme={null}
case rari
```

### Chain.rariTestnet

```swift theme={null}
case rariTestnet
```

### Chain.scroll

```swift theme={null}
case scroll
```

### Chain.scrollSepolia

```swift theme={null}
case scrollSepolia
```

### Chain.seiAtlantic2Testnet

```swift theme={null}
case seiAtlantic2Testnet
```

### Chain.seiPacific1

```swift theme={null}
case seiPacific1
```

### Chain.shape

```swift theme={null}
case shape
```

### Chain.shapeSepolia

```swift theme={null}
case shapeSepolia
```

### Chain.skaleNebula

```swift theme={null}
case skaleNebula
```

### Chain.skaleNebulaTestnet

```swift theme={null}
case skaleNebulaTestnet
```

### Chain.solana

```swift theme={null}
case solana
```

### Chain.soneium

```swift theme={null}
case soneium
```

### Chain.soneiumMinatoTestnet

```swift theme={null}
case soneiumMinatoTestnet
```

### Chain.space

```swift theme={null}
case space
```

### Chain.spaceTestnet

```swift theme={null}
case spaceTestnet
```

### Chain.stellar

```swift theme={null}
case stellar
```

### Chain.story

```swift theme={null}
case story
```

### Chain.storyTestnet

```swift theme={null}
case storyTestnet
```

### Chain.unknown(name:)

```swift theme={null}
case unknown(name: String)
```

### Chain.verifyTestnet

```swift theme={null}
case verifyTestnet
```

### Chain.viction

```swift theme={null}
case viction
```

### Chain.victionTestnet

```swift theme={null}
case victionTestnet
```

### Chain.xai

```swift theme={null}
case xai
```

### Chain.xaiSepoliaTestnet

```swift theme={null}
case xaiSepoliaTestnet
```

### Chain.zenchainTestnet

```swift theme={null}
case zenchainTestnet
```

### Chain.zkatana

```swift theme={null}
case zkatana
```

### Chain.zkyoto

```swift theme={null}
case zkyoto
```

### Chain.zora

```swift theme={null}
case zora
```

### Chain.zoraGoerli

```swift theme={null}
case zoraGoerli
```

### Chain.zoraSepolia

```swift theme={null}
case zoraSepolia
```

## Initializers

### init(\_:)

```swift theme={null}
init(_ from: String)
```

## Instance Properties

### chainType

Inherited from `AnyChain.chainType`.

```swift theme={null}
var chainType: ChainType { get }
```

### name

Inherited from `AnyChain.name`.

```swift theme={null}
var name: String { get }
```

## Instance Methods

### isValid(isProductionEnvironment:)

Inherited from `AnyChain.isValid(isProductionEnvironment:)`.

```swift theme={null}
func isValid(isProductionEnvironment: Bool) -> Bool
```

## Type Methods

### fromName(\_:)

```swift theme={null}
static func fromName(_ name: String) -> Chain?
```


# ChainAndAddress
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/chainandaddress

Swift Enumeration

**Enumeration**

```swift theme={null}
enum ChainAndAddress
```

## Enumeration Cases

### ChainAndAddress.evm(*:*:)

```swift theme={null}
case evm(EVMChain, EVMAddress)
```

### ChainAndAddress.solana(\_:)

```swift theme={null}
case solana(SolanaAddress)
```

### ChainAndAddress.stellar(\_:)

```swift theme={null}
case stellar(StellarAddress)
```

## Instance Properties

### blockchainAddress

```swift theme={null}
var blockchainAddress: any BlockchainAddress { get }
```

### chain

```swift theme={null}
var chain: Chain { get }
```

### description

Inherited from `CustomStringConvertible.description`.

```swift theme={null}
var description: String { get }
```


# ChainType
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/chaintype

Swift Enumeration

**Enumeration**

```swift theme={null}
enum ChainType
```

## Enumeration Cases

### ChainType.evm

```swift theme={null}
case evm
```

### ChainType.solana

```swift theme={null}
case solana
```

### ChainType.stellar

```swift theme={null}
case stellar
```

### ChainType.unknown

```swift theme={null}
case unknown
```

## Initializers

### init(rawValue:)

Inherited from `RawRepresentable.init(rawValue:)`.

```swift theme={null}
init?(rawValue: String)
```


# CrossmintEnvironment
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/crossmintenvironment

Swift Enumeration

**Enumeration**

```swift theme={null}
enum CrossmintEnvironment
```

## Enumeration Cases

### CrossmintEnvironment.development

```swift theme={null}
case development
```

### CrossmintEnvironment.production

```swift theme={null}
case production
```

### CrossmintEnvironment.staging

```swift theme={null}
case staging
```

## Initializers

### init(rawValue:)

Inherited from `RawRepresentable.init(rawValue:)`.

```swift theme={null}
init?(rawValue: String)
```


# CrossmintServiceError
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/crossmintserviceerror

Swift Enumeration

**Enumeration**

```swift theme={null}
enum CrossmintServiceError
```

## Enumeration Cases

### CrossmintServiceError.invalidApiKey(\_:)

```swift theme={null}
case invalidApiKey(String)
```

### CrossmintServiceError.invalidData(\_:)

```swift theme={null}
case invalidData(String)
```

### CrossmintServiceError.invalidURL

```swift theme={null}
case invalidURL
```

### CrossmintServiceError.timeout

```swift theme={null}
case timeout
```

### CrossmintServiceError.unknown

```swift theme={null}
case unknown
```

## Instance Properties

### errorMessage

```swift theme={null}
var errorMessage: String { get }
```


# CryptoCurrency
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/cryptocurrency

Swift Enumeration

**Enumeration**

```swift theme={null}
enum CryptoCurrency
```

## Operators

### `<(_:_:)`

Inherited from `Comparable.<(_:_:)`.

```swift theme={null}
static func < (lhs: CryptoCurrency, rhs: CryptoCurrency) -> Bool
```

## Enumeration Cases

### CryptoCurrency.ada

```swift theme={null}
case ada
```

### CryptoCurrency.ape

```swift theme={null}
case ape
```

### CryptoCurrency.apt

```swift theme={null}
case apt
```

### CryptoCurrency.avax

```swift theme={null}
case avax
```

### CryptoCurrency.bnb

```swift theme={null}
case bnb
```

### CryptoCurrency.bonk

```swift theme={null}
case bonk
```

### CryptoCurrency.brett

```swift theme={null}
case brett
```

### CryptoCurrency.busd

```swift theme={null}
case busd
```

### CryptoCurrency.chz

```swift theme={null}
case chz
```

### CryptoCurrency.degen

```swift theme={null}
case degen
```

### CryptoCurrency.eth

```swift theme={null}
case eth
```

### CryptoCurrency.eurc

```swift theme={null}
case eurc
```

### CryptoCurrency.fuel

```swift theme={null}
case fuel
```

### CryptoCurrency.ip

```swift theme={null}
case ip
```

### CryptoCurrency.matic

```swift theme={null}
case matic
```

### CryptoCurrency.mother

```swift theme={null}
case mother
```

### CryptoCurrency.pol

```swift theme={null}
case pol
```

### CryptoCurrency.sei

```swift theme={null}
case sei
```

### CryptoCurrency.sfuel

```swift theme={null}
case sfuel
```

### CryptoCurrency.sol

```swift theme={null}
case sol
```

### CryptoCurrency.sui

```swift theme={null}
case sui
```

### CryptoCurrency.superverse

```swift theme={null}
case superverse
```

### CryptoCurrency.toshi

```swift theme={null}
case toshi
```

### CryptoCurrency.unknown(\_:)

```swift theme={null}
case unknown(String)
```

### CryptoCurrency.usdc

```swift theme={null}
case usdc
```

### CryptoCurrency.usdce

```swift theme={null}
case usdce
```

### CryptoCurrency.usdxm

```swift theme={null}
case usdxm
```

### CryptoCurrency.vic

```swift theme={null}
case vic
```

### CryptoCurrency.weth

```swift theme={null}
case weth
```

### CryptoCurrency.wif

```swift theme={null}
case wif
```

### CryptoCurrency.xai

```swift theme={null}
case xai
```

### CryptoCurrency.xlm

```swift theme={null}
case xlm
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

### init(name:)

```swift theme={null}
init(name: String)
```

## Instance Properties

### name

```swift theme={null}
var name: String { get }
```

## Instance Methods

### contains(\_:)

Inherited from `RangeExpression.contains(_:)`.

```swift theme={null}
func contains(_ element: CryptoCurrency) -> Bool
```

### getNumericPriceDecimalsPerCurrency(defaultValue:)

```swift theme={null}
func getNumericPriceDecimalsPerCurrency(defaultValue: Int = 5) -> Int
```

### relative(to:)

```swift theme={null}
func relative<C>(to collection: C) -> Range<C.Index> where C : Collection
```

### relative(to:)

Inherited from `RangeExpression.relative(to:)`.

```swift theme={null}
func relative<C>(to collection: C) -> Range<CryptoCurrency> where C : Collection, C.Index == CryptoCurrency
```

## Type Properties

### allCases

Inherited from `CaseIterable.allCases`.

```swift theme={null}
static var allCases: [CryptoCurrency] { get }
```


# CryptoPaymentFailureCode
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/cryptopaymentfailurecode

Swift Enumeration

**Enumeration**

```swift theme={null}
enum CryptoPaymentFailureCode
```

## Enumeration Cases

### CryptoPaymentFailureCode.insufficientFunds

```swift theme={null}
case insufficientFunds
```

### CryptoPaymentFailureCode.txIdNotFound

```swift theme={null}
case txIdNotFound
```

### CryptoPaymentFailureCode.unknown

```swift theme={null}
case unknown
```

## Initializers

### init(rawValue:)

Inherited from `RawRepresentable.init(rawValue:)`.

```swift theme={null}
init?(rawValue: String)
```


# EIP712
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/eip712

Swift Enumeration

**Enumeration**

```swift theme={null}
enum EIP712
```

## Classes

### EIP712.Builder

```swift theme={null}
class Builder
```

### EIP712.FieldBuilder

```swift theme={null}
class FieldBuilder
```

## Structures

### EIP712.Domain

```swift theme={null}
struct Domain
```

### EIP712.Field

```swift theme={null}
struct Field
```

### EIP712.TypedData

```swift theme={null}
struct TypedData
```

## Enumerations

### EIP712.CommonPatterns

```swift theme={null}
enum CommonPatterns
```

### EIP712.TypeString

```swift theme={null}
enum TypeString
```


# Either
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/either

Swift Enumeration

**Enumeration**

```swift theme={null}
enum Either<Create, Get> where Create : Sendable, Get : Sendable
```

## Enumeration Cases

### Either.create(\_:)

```swift theme={null}
case create(Create)
```

### Either.get(\_:)

```swift theme={null}
case get(Get)
```


# EmailSignerError
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/emailsignererror

Swift Enumeration

**Enumeration**

```swift theme={null}
enum EmailSignerError
```

## Enumeration Cases

### EmailSignerError.generic(\_:)

```swift theme={null}
case generic(String)
```

### EmailSignerError.nonAvailable

```swift theme={null}
case nonAvailable
```

### EmailSignerError.teeNotStarted

```swift theme={null}
case teeNotStarted
```


# EVMChain
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/evmchain

Swift Enumeration

**Enumeration**

```swift theme={null}
enum EVMChain
```

## Enumeration Cases

### EVMChain.apechain

```swift theme={null}
case apechain
```

### EVMChain.apex

```swift theme={null}
case apex
```

### EVMChain.arbitrum

```swift theme={null}
case arbitrum
```

### EVMChain.arbitrumSepolia

```swift theme={null}
case arbitrumSepolia
```

### EVMChain.arbitrumnova

```swift theme={null}
case arbitrumnova
```

### EVMChain.astarZkevm

```swift theme={null}
case astarZkevm
```

### EVMChain.avalanche

```swift theme={null}
case avalanche
```

### EVMChain.avalancheFuji

```swift theme={null}
case avalancheFuji
```

### EVMChain.barretTestnet

```swift theme={null}
case barretTestnet
```

### EVMChain.base

```swift theme={null}
case base
```

### EVMChain.baseGoerli

```swift theme={null}
case baseGoerli
```

### EVMChain.baseSepolia

```swift theme={null}
case baseSepolia
```

### EVMChain.bsc

```swift theme={null}
case bsc
```

### EVMChain.bscTestnet

```swift theme={null}
case bscTestnet
```

### EVMChain.chiliz

```swift theme={null}
case chiliz
```

### EVMChain.chilizSpicyTestnet

```swift theme={null}
case chilizSpicyTestnet
```

### EVMChain.coti

```swift theme={null}
case coti
```

### EVMChain.cotiTestnet

```swift theme={null}
case cotiTestnet
```

### EVMChain.curtis

```swift theme={null}
case curtis
```

### EVMChain.ethereum

```swift theme={null}
case ethereum
```

### EVMChain.ethereumGoerli

```swift theme={null}
case ethereumGoerli
```

### EVMChain.ethereumSepolia

```swift theme={null}
case ethereumSepolia
```

### EVMChain.hypersonicTestnet

```swift theme={null}
case hypersonicTestnet
```

### EVMChain.lightlink

```swift theme={null}
case lightlink
```

### EVMChain.lightlinkPegasus

```swift theme={null}
case lightlinkPegasus
```

### EVMChain.mode

```swift theme={null}
case mode
```

### EVMChain.modeSepolia

```swift theme={null}
case modeSepolia
```

### EVMChain.optimism

```swift theme={null}
case optimism
```

### EVMChain.optimismGoerli

```swift theme={null}
case optimismGoerli
```

### EVMChain.optimismSepolia

```swift theme={null}
case optimismSepolia
```

### EVMChain.polygon

```swift theme={null}
case polygon
```

### EVMChain.polygonAmoy

```swift theme={null}
case polygonAmoy
```

### EVMChain.polygonMumbai

```swift theme={null}
case polygonMumbai
```

### EVMChain.rari

```swift theme={null}
case rari
```

### EVMChain.rariTestnet

```swift theme={null}
case rariTestnet
```

### EVMChain.scroll

```swift theme={null}
case scroll
```

### EVMChain.scrollSepolia

```swift theme={null}
case scrollSepolia
```

### EVMChain.seiAtlantic2Testnet

```swift theme={null}
case seiAtlantic2Testnet
```

### EVMChain.seiPacific1

```swift theme={null}
case seiPacific1
```

### EVMChain.shape

```swift theme={null}
case shape
```

### EVMChain.shapeSepolia

```swift theme={null}
case shapeSepolia
```

### EVMChain.skaleNebula

```swift theme={null}
case skaleNebula
```

### EVMChain.skaleNebulaTestnet

```swift theme={null}
case skaleNebulaTestnet
```

### EVMChain.soneium

```swift theme={null}
case soneium
```

### EVMChain.soneiumMinatoTestnet

```swift theme={null}
case soneiumMinatoTestnet
```

### EVMChain.space

```swift theme={null}
case space
```

### EVMChain.spaceTestnet

```swift theme={null}
case spaceTestnet
```

### EVMChain.story

```swift theme={null}
case story
```

### EVMChain.storyTestnet

```swift theme={null}
case storyTestnet
```

### EVMChain.verifyTestnet

```swift theme={null}
case verifyTestnet
```

### EVMChain.viction

```swift theme={null}
case viction
```

### EVMChain.victionTestnet

```swift theme={null}
case victionTestnet
```

### EVMChain.xai

```swift theme={null}
case xai
```

### EVMChain.xaiSepoliaTestnet

```swift theme={null}
case xaiSepoliaTestnet
```

### EVMChain.zenchainTestnet

```swift theme={null}
case zenchainTestnet
```

### EVMChain.zkatana

```swift theme={null}
case zkatana
```

### EVMChain.zkyoto

```swift theme={null}
case zkyoto
```

### EVMChain.zora

```swift theme={null}
case zora
```

### EVMChain.zoraGoerli

```swift theme={null}
case zoraGoerli
```

### EVMChain.zoraSepolia

```swift theme={null}
case zoraSepolia
```

## Initializers

### init(\_:)

Inherited from `SpecificChain.init(_:)`.

```swift theme={null}
init?(_ from: String)
```

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

## Instance Properties

### chain

Inherited from `SpecificChain.chain`.

```swift theme={null}
var chain: Chain { get }
```

### chainType

Inherited from `AnyChain.chainType`.

```swift theme={null}
var chainType: ChainType { get }
```

### name

Inherited from `AnyChain.name`.

```swift theme={null}
var name: String { get }
```

## Instance Methods

### isValid(isProductionEnvironment:)

Inherited from `AnyChain.isValid(isProductionEnvironment:)`.

```swift theme={null}
func isValid(isProductionEnvironment: Bool) -> Bool
```


# EVMSigners
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/evmsigners

Swift Enumeration

**Enumeration**

```swift theme={null}
enum EVMSigners
```

## Enumeration Cases

### EVMSigners.apiKey

```swift theme={null}
case apiKey
```

### EVMSigners.email(\_:)

```swift theme={null}
case email(String)
```

### EVMSigners.passkey(name:host:)

```swift theme={null}
case passkey(name: String, host: String)
```

## Instance Properties

### signer

Inherited from `SignerProvider.signer`.

```swift theme={null}
@MainActor var signer: any Signer { get }
```


# EVMSmartWalletMapping
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/evmsmartwalletmapping

Swift Enumeration

**Enumeration**

```swift theme={null}
enum EVMSmartWalletMapping
```

## Type Aliases

### EVMSmartWalletMapping.APIModel

Inherited from `WalletTypeTransactionMapping.APIModel`.

```swift theme={null}
typealias APIModel = EVMTransactionApiModel
```

## Type Properties

### chainType

Inherited from `WalletTypeTransactionMapping.chainType`.

```swift theme={null}
static let chainType: ChainType
```


# FiatCurrency
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/fiatcurrency

Swift Enumeration

**Enumeration**

```swift theme={null}
enum FiatCurrency
```

## Operators

### `<(_:_:)`

Inherited from `Comparable.<(_:_:)`.

```swift theme={null}
static func < (lhs: FiatCurrency, rhs: FiatCurrency) -> Bool
```

## Enumeration Cases

### FiatCurrency.aud

```swift theme={null}
case aud
```

### FiatCurrency.eur

```swift theme={null}
case eur
```

### FiatCurrency.gbp

```swift theme={null}
case gbp
```

### FiatCurrency.hkd

```swift theme={null}
case hkd
```

### FiatCurrency.inr

```swift theme={null}
case inr
```

### FiatCurrency.jpy

```swift theme={null}
case jpy
```

### FiatCurrency.krw

```swift theme={null}
case krw
```

### FiatCurrency.sgd

```swift theme={null}
case sgd
```

### FiatCurrency.unknown(\_:)

```swift theme={null}
case unknown(String)
```

### FiatCurrency.usd

```swift theme={null}
case usd
```

### FiatCurrency.vnd

```swift theme={null}
case vnd
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

### init(name:)

```swift theme={null}
init(name: String)
```

## Instance Properties

### isPaymentEnabledFiatCurrency

```swift theme={null}
var isPaymentEnabledFiatCurrency: Bool { get }
```

### name

```swift theme={null}
var name: String { get }
```

## Instance Methods

### contains(\_:)

Inherited from `RangeExpression.contains(_:)`.

```swift theme={null}
func contains(_ element: FiatCurrency) -> Bool
```

### encode(to:)

Inherited from `Encodable.encode(to:)`.

```swift theme={null}
func encode(to encoder: Encoder) throws
```

### relative(to:)

Inherited from `RangeExpression.relative(to:)`.

```swift theme={null}
func relative<C>(to collection: C) -> Range<FiatCurrency> where C : Collection, C.Index == FiatCurrency
```

### relative(to:)

```swift theme={null}
func relative<C>(to collection: C) -> Range<C.Index> where C : Collection
```


# LargeBlobSupport
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/largeblobsupport

Swift Enumeration

**Enumeration**

Specification reference: [https://w3c.github.io/webauthn/#enumdef-largeblobsupport](https://w3c.github.io/webauthn/#enumdef-largeblobsupport)

```swift theme={null}
enum LargeBlobSupport
```

## Enumeration Cases

### LargeBlobSupport.preferred

```swift theme={null}
case preferred
```

### LargeBlobSupport.required

```swift theme={null}
case required
```

## Initializers

### init(rawValue:)

Inherited from `RawRepresentable.init(rawValue:)`.

```swift theme={null}
init?(rawValue: String)
```


# LinkedUserError
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/linkedusererror

Swift Enumeration

**Enumeration**

```swift theme={null}
enum LinkedUserError
```

## Enumeration Cases

### LinkedUserError.invalidLocator(\_:)

```swift theme={null}
case invalidLocator(String)
```

### LinkedUserError.unknownType(\_:)

```swift theme={null}
case unknownType(String)
```

## Instance Properties

### errorDescription

Inherited from `LocalizedError.errorDescription`.

```swift theme={null}
var errorDescription: String? { get }
```


# OTPAuthenticationStatus
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/otpauthenticationstatus

Swift Enumeration

**Enumeration**

```swift theme={null}
enum OTPAuthenticationStatus
```

## Enumeration Cases

### OTPAuthenticationStatus.authenticationStatus(\_:)

```swift theme={null}
case authenticationStatus(AuthenticationStatus)
```

### OTPAuthenticationStatus.emailSent(email:emailId:)

```swift theme={null}
case emailSent(email: String, emailId: String)
```

## Instance Properties

### email

```swift theme={null}
var email: String? { get }
```

### isAuthenticated

```swift theme={null}
var isAuthenticated: Bool { get }
```


# Owner
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/owner

Swift Enumeration

**Enumeration**

```swift theme={null}
enum Owner
```

## Enumeration Cases

### Owner.email(\_:)

```swift theme={null}
case email(String)
```

### Owner.phoneNumber(\_:)

```swift theme={null}
case phoneNumber(String)
```

### Owner.twitter(\_:)

```swift theme={null}
case twitter(String)
```

### Owner.userId(\_:)

```swift theme={null}
case userId(String)
```

### Owner.x(\_:)

```swift theme={null}
case x(String)
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: Decoder) throws
```

### init(from:)

```swift theme={null}
init(from locator: String) throws
```

## Instance Properties

### description

Inherited from `CustomStringConvertible.description`.

```swift theme={null}
var description: String { get }
```

## Instance Methods

### encode(to:)

Inherited from `Encodable.encode(to:)`.

```swift theme={null}
func encode(to encoder: Encoder) throws
```


# PasskeyErrorType
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/passkeyerrortype

Swift Enumeration

**Enumeration**

```swift theme={null}
enum PasskeyErrorType
```

## Enumeration Cases

### PasskeyErrorType.badConfiguration

```swift theme={null}
case badConfiguration
```

### PasskeyErrorType.cancelled

```swift theme={null}
case cancelled
```

### PasskeyErrorType.invalidChallenge

```swift theme={null}
case invalidChallenge
```

### PasskeyErrorType.invalidUser

```swift theme={null}
case invalidUser
```

### PasskeyErrorType.notSupported

```swift theme={null}
case notSupported
```

### PasskeyErrorType.requestFailed

```swift theme={null}
case requestFailed
```

### PasskeyErrorType.timedOut

```swift theme={null}
case timedOut
```

### PasskeyErrorType.unknown

```swift theme={null}
case unknown
```

## Initializers

### init(rawValue:)

Inherited from `RawRepresentable.init(rawValue:)`.

```swift theme={null}
init?(rawValue: String)
```


# PublicKeyCredentialType
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/publickeycredentialtype

Swift Enumeration

**Enumeration**

Specification reference: [https://w3c.github.io/webauthn/#enum-credentialType](https://w3c.github.io/webauthn/#enum-credentialType)

```swift theme={null}
enum PublicKeyCredentialType
```

## Enumeration Cases

### PublicKeyCredentialType.publicKey

```swift theme={null}
case publicKey
```

## Initializers

### init(rawValue:)

Inherited from `RawRepresentable.init(rawValue:)`.

```swift theme={null}
init?(rawValue: String)
```


# RequestBuilderError
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/requestbuildererror

Swift Enumeration

**Enumeration**

```swift theme={null}
enum RequestBuilderError
```

## Enumeration Cases

### RequestBuilderError.invalidURL

```swift theme={null}
case invalidURL
```


# ResidentKeyRequirement
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/residentkeyrequirement

Swift Enumeration

**Enumeration**

Specification reference: [https://w3c.github.io/webauthn/#enum-residentKeyRequirement](https://w3c.github.io/webauthn/#enum-residentKeyRequirement)

```swift theme={null}
enum ResidentKeyRequirement
```

## Enumeration Cases

### ResidentKeyRequirement.discouraged

```swift theme={null}
case discouraged
```

### ResidentKeyRequirement.preferred

```swift theme={null}
case preferred
```

### ResidentKeyRequirement.required

```swift theme={null}
case required
```

## Initializers

### init(rawValue:)

Inherited from `RawRepresentable.init(rawValue:)`.

```swift theme={null}
init?(rawValue: String)
```


# SecureStorageError
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/securestorageerror

Swift Enumeration

**Enumeration**

```swift theme={null}
enum SecureStorageError
```

## Enumeration Cases

### SecureStorageError.decryptionFailed

```swift theme={null}
case decryptionFailed
```

### SecureStorageError.encryptionFailed(\_:)

```swift theme={null}
case encryptionFailed(String)
```

### SecureStorageError.storageUnavailable

```swift theme={null}
case storageUnavailable
```

### SecureStorageError.unknown

```swift theme={null}
case unknown
```


# SignatureError
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/signatureerror

Swift Enumeration

**Enumeration**

```swift theme={null}
enum SignatureError
```

## Enumeration Cases

### SignatureError.approvalFailed

```swift theme={null}
case approvalFailed
```

### SignatureError.creationFailed

```swift theme={null}
case creationFailed
```

### SignatureError.decodingError

```swift theme={null}
case decodingError
```

### SignatureError.networkError

```swift theme={null}
case networkError
```

### SignatureError.serviceError(\_:)

```swift theme={null}
case serviceError(CrossmintServiceError)
```

### SignatureError.unknown

```swift theme={null}
case unknown
```

### SignatureError.userCancelled

```swift theme={null}
case userCancelled
```

## Instance Properties

### errorMessage

Inherited from `ServiceError.errorMessage`.

```swift theme={null}
var errorMessage: String { get }
```

## Type Methods

### fromNetworkError(\_:)

Inherited from `ServiceError.fromNetworkError(_:)`.

```swift theme={null}
static func fromNetworkError(_ error: NetworkError) -> SignatureError
```

### fromServiceError(\_:)

Inherited from `ServiceError.fromServiceError(_:)`.

```swift theme={null}
static func fromServiceError(_ error: CrossmintServiceError) -> SignatureError
```


# SignerError
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/signererror

Swift Enumeration

**Enumeration**

```swift theme={null}
enum SignerError
```

## Enumeration Cases

### SignerError.cancelled

```swift theme={null}
case cancelled
```

### SignerError.invalidAddress

```swift theme={null}
case invalidAddress
```

### SignerError.invalidEmail

```swift theme={null}
case invalidEmail
```

### SignerError.invalidMessage

```swift theme={null}
case invalidMessage
```

### SignerError.invalidPrivateKey

```swift theme={null}
case invalidPrivateKey
```

### SignerError.invalidSigner

```swift theme={null}
case invalidSigner
```

### SignerError.notStarted

```swift theme={null}
case notStarted
```

### SignerError.passkey(\_:)

```swift theme={null}
case passkey(PasskeyError)
```

### SignerError.signingFailed

```swift theme={null}
case signingFailed
```

## Enumerations

### SignerError.PasskeyError

```swift theme={null}
enum PasskeyError
```


# Signers
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/signers

Swift Enumeration

**Enumeration**

```swift theme={null}
enum Signers
```

## Enumeration Cases

### Signers.evmEmailSigner(email:)

```swift theme={null}
case evmEmailSigner(email: String)
```

### Signers.evmFireblocksSigner

```swift theme={null}
case evmFireblocksSigner
```

### Signers.passkeySigner(name:host:)

```swift theme={null}
case passkeySigner(name: String, host: String)
```

### Signers.solanaEmailSigner(email:)

```swift theme={null}
case solanaEmailSigner(email: String)
```

### Signers.solanaFireblocksSigner

```swift theme={null}
case solanaFireblocksSigner
```

## Instance Properties

### signer

```swift theme={null}
@MainActor var signer: any Signer { get }
```


# SignerType
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/signertype

Swift Enumeration

**Enumeration**

```swift theme={null}
enum SignerType
```

## Enumeration Cases

### SignerType.apiKey

```swift theme={null}
case apiKey
```

### SignerType.email

```swift theme={null}
case email
```

### SignerType.externalWallet

```swift theme={null}
case externalWallet
```

### SignerType.passkey

```swift theme={null}
case passkey
```

## Initializers

### init(rawValue:)

Inherited from `RawRepresentable.init(rawValue:)`.

```swift theme={null}
init?(rawValue: String)
```


# SolanaChain
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/solanachain

Swift Enumeration

**Enumeration**

```swift theme={null}
enum SolanaChain
```

## Enumeration Cases

### SolanaChain.solana

```swift theme={null}
case solana
```

## Initializers

### init(\_:)

Inherited from `SpecificChain.init(_:)`.

```swift theme={null}
init?(_ from: String)
```

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

## Instance Properties

### chain

Inherited from `SpecificChain.chain`.

```swift theme={null}
var chain: Chain { get }
```

### chainType

Inherited from `AnyChain.chainType`.

```swift theme={null}
var chainType: ChainType { get }
```

### name

Inherited from `AnyChain.name`.

```swift theme={null}
var name: String { get }
```

## Instance Methods

### isValid(isProductionEnvironment:)

Inherited from `AnyChain.isValid(isProductionEnvironment:)`.

```swift theme={null}
func isValid(isProductionEnvironment: Bool) -> Bool
```


# SolanaSigners
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/solanasigners

Swift Enumeration

**Enumeration**

```swift theme={null}
enum SolanaSigners
```

## Enumeration Cases

### SolanaSigners.apiKey

```swift theme={null}
case apiKey
```

### SolanaSigners.email(\_:)

```swift theme={null}
case email(String)
```

## Instance Properties

### signer

Inherited from `SignerProvider.signer`.

```swift theme={null}
@MainActor var signer: any Signer { get }
```


# SolanaSmartWalletMapping
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/solanasmartwalletmapping

Swift Enumeration

**Enumeration**

```swift theme={null}
enum SolanaSmartWalletMapping
```

## Type Aliases

### SolanaSmartWalletMapping.APIModel

Inherited from `WalletTypeTransactionMapping.APIModel`.

```swift theme={null}
typealias APIModel = SolanaTransactionApiModel
```

## Type Properties

### chainType

Inherited from `WalletTypeTransactionMapping.chainType`.

```swift theme={null}
static let chainType: ChainType
```


# SolanaSupportedToken
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/solanasupportedtoken

Swift Enumeration

**Enumeration**

```swift theme={null}
enum SolanaSupportedToken
```

## Enumeration Cases

### SolanaSupportedToken.sol

```swift theme={null}
case sol
```

### SolanaSupportedToken.usdc

```swift theme={null}
case usdc
```

## Instance Properties

### asCryptoCurrency

```swift theme={null}
var asCryptoCurrency: CryptoCurrency { get }
```

### name

```swift theme={null}
var name: String { get }
```

## Type Methods

### toSolanaSupportedToken(\_:)

```swift theme={null}
static func toSolanaSupportedToken(_ cryptoCurrency: CryptoCurrency?) -> SolanaSupportedToken?
```


# StellarChain
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/stellarchain

Swift Enumeration

**Enumeration**

```swift theme={null}
enum StellarChain
```

## Enumeration Cases

### StellarChain.stellar

```swift theme={null}
case stellar
```

## Initializers

### init(\_:)

Inherited from `SpecificChain.init(_:)`.

```swift theme={null}
init?(_ from: String)
```

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

## Instance Properties

### chain

Inherited from `SpecificChain.chain`.

```swift theme={null}
var chain: Chain { get }
```

### chainType

Inherited from `AnyChain.chainType`.

```swift theme={null}
var chainType: ChainType { get }
```

### name

Inherited from `AnyChain.name`.

```swift theme={null}
var name: String { get }
```

## Instance Methods

### isValid(isProductionEnvironment:)

Inherited from `AnyChain.isValid(isProductionEnvironment:)`.

```swift theme={null}
func isValid(isProductionEnvironment: Bool) -> Bool
```


# StellarSigners
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/stellarsigners

Swift Enumeration

**Enumeration**

```swift theme={null}
enum StellarSigners
```

## Enumeration Cases

### StellarSigners.apiKey

```swift theme={null}
case apiKey
```

### StellarSigners.email(\_:)

```swift theme={null}
case email(String)
```

## Instance Properties

### signer

Inherited from `SignerProvider.signer`.

```swift theme={null}
@MainActor var signer: any Signer { get }
```


# StellarSmartWalletMapping
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/stellarsmartwalletmapping

Swift Enumeration

**Enumeration**

```swift theme={null}
enum StellarSmartWalletMapping
```

## Type Aliases

### StellarSmartWalletMapping.APIModel

Inherited from `WalletTypeTransactionMapping.APIModel`.

```swift theme={null}
typealias APIModel = StellarTransactionApiModel
```

## Type Properties

### chainType

Inherited from `WalletTypeTransactionMapping.chainType`.

```swift theme={null}
static let chainType: ChainType
```


# StellarSupportedToken
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/stellarsupportedtoken

Swift Enumeration

**Enumeration**

```swift theme={null}
enum StellarSupportedToken
```

## Enumeration Cases

### StellarSupportedToken.usdxm

```swift theme={null}
case usdxm
```

### StellarSupportedToken.xlm

```swift theme={null}
case xlm
```

## Instance Properties

### asCryptoCurrency

```swift theme={null}
var asCryptoCurrency: CryptoCurrency { get }
```

### name

```swift theme={null}
var name: String { get }
```

## Type Methods

### toStellarSupportedToken(\_:)

```swift theme={null}
static func toStellarSupportedToken(_ cryptoCurrency: CryptoCurrency?) -> StellarSupportedToken?
```


# TransactionError
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/transactionerror

Swift Enumeration

**Enumeration**

```swift theme={null}
enum TransactionError
```

## Enumeration Cases

### TransactionError.invalidApprovals(expected:actual:)

```swift theme={null}
case invalidApprovals(expected: Int, actual: Int)
```

### TransactionError.serviceError(\_:)

```swift theme={null}
case serviceError(CrossmintServiceError)
```

### TransactionError.transactionCreationFailed

```swift theme={null}
case transactionCreationFailed
```

### TransactionError.transactionCreationFailedNoSigner

```swift theme={null}
case transactionCreationFailedNoSigner
```

### TransactionError.transactionGeneric(\_:)

```swift theme={null}
case transactionGeneric(String)
```

### TransactionError.transactionNotFound

```swift theme={null}
case transactionNotFound
```

### TransactionError.transactionSigningFailed(\_:)

```swift theme={null}
case transactionSigningFailed(Error)
```

### TransactionError.transactionSigningFailedInvalidKey

```swift theme={null}
case transactionSigningFailedInvalidKey
```

### TransactionError.transactionSigningFailedNoMessage

```swift theme={null}
case transactionSigningFailedNoMessage
```

### TransactionError.transactionSigningFailedNoSigner

```swift theme={null}
case transactionSigningFailedNoSigner
```

### TransactionError.userCancelled

```swift theme={null}
case userCancelled
```

## Instance Properties

### errorMessage

Inherited from `ServiceError.errorMessage`.

```swift theme={null}
var errorMessage: String { get }
```

## Type Methods

### fromNetworkError(\_:)

Inherited from `ServiceError.fromNetworkError(_:)`.

```swift theme={null}
static func fromNetworkError(_ error: NetworkError) -> TransactionError
```

### fromServiceError(\_:)

Inherited from `ServiceError.fromServiceError(_:)`.

```swift theme={null}
static func fromServiceError(_ error: CrossmintServiceError) -> TransactionError
```


# TransactionStatusApiModel
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/transactionstatusapimodel

Swift Enumeration

**Enumeration**

```swift theme={null}
enum TransactionStatusApiModel
```

## Enumeration Cases

### TransactionStatusApiModel.awaitingApproval

```swift theme={null}
case awaitingApproval
```

### TransactionStatusApiModel.failed

```swift theme={null}
case failed
```

### TransactionStatusApiModel.pending

```swift theme={null}
case pending
```

### TransactionStatusApiModel.success

```swift theme={null}
case success
```

## Initializers

### init(rawValue:)

Inherited from `RawRepresentable.init(rawValue:)`.

```swift theme={null}
init?(rawValue: String)
```


# TransferTokenLocator
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/transfertokenlocator

Swift Enumeration

**Enumeration**

```swift theme={null}
enum TransferTokenLocator
```

## Operators

### !=(*:*:)

```swift theme={null}
static func != (lhs: TransferTokenLocator, rhs: String) -> Bool
```

### !=(*:*:)

```swift theme={null}
static func != (lhs: String, rhs: TransferTokenLocator) -> Bool
```

### ==(*:*:)

```swift theme={null}
static func == (lhs: TransferTokenLocator, rhs: String) -> Bool
```

### ==(*:*:)

```swift theme={null}
static func == (lhs: String, rhs: TransferTokenLocator) -> Bool
```

## Enumeration Cases

### TransferTokenLocator.address(\_:)

```swift theme={null}
case address(ChainAndAddress)
```

### TransferTokenLocator.currency(\_:)

```swift theme={null}
case currency(CurrencyData)
```

### TransferTokenLocator.tokenId(\_:tokenId:)

```swift theme={null}
case tokenId(ChainAndAddress, tokenId: String)
```

## Instance Properties

### description

Inherited from `CustomStringConvertible.description`.

```swift theme={null}
var description: String { get }
```

## Instance Methods

### matches(\_:)

```swift theme={null}
func matches(_ string: String) -> Bool
```

## Enumerations

### TransferTokenLocator.CurrencyData

```swift theme={null}
enum CurrencyData
```


# TransferTokenRecipient
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/transfertokenrecipient

Swift Enumeration

**Enumeration**

```swift theme={null}
enum TransferTokenRecipient
```

## Operators

### !=(*:*:)

```swift theme={null}
static func != (lhs: TransferTokenRecipient, rhs: NonEmptyString) -> Bool
```

### !=(*:*:)

```swift theme={null}
static func != (lhs: TransferTokenRecipient, rhs: String) -> Bool
```

### !=(*:*:)

```swift theme={null}
static func != (lhs: String, rhs: TransferTokenRecipient) -> Bool
```

### !=(*:*:)

```swift theme={null}
static func != (lhs: NonEmptyString, rhs: TransferTokenRecipient) -> Bool
```

### ==(*:*:)

```swift theme={null}
static func == (lhs: String, rhs: TransferTokenRecipient) -> Bool
```

### ==(*:*:)

```swift theme={null}
static func == (lhs: NonEmptyString, rhs: TransferTokenRecipient) -> Bool
```

### ==(*:*:)

```swift theme={null}
static func == (lhs: TransferTokenRecipient, rhs: String) -> Bool
```

### ==(*:*:)

```swift theme={null}
static func == (lhs: TransferTokenRecipient, rhs: NonEmptyString) -> Bool
```

## Enumeration Cases

### TransferTokenRecipient.address(\_:)

```swift theme={null}
case address(ChainAndAddress)
```

### TransferTokenRecipient.email(\_:)

```swift theme={null}
case email(OptionalChain)
```

### TransferTokenRecipient.phoneNumber(\_:)

```swift theme={null}
case phoneNumber(OptionalChain)
```

### TransferTokenRecipient.twitter(\_:)

```swift theme={null}
case twitter(OptionalChain)
```

### TransferTokenRecipient.userId(\_:)

```swift theme={null}
case userId(OptionalChain)
```

### TransferTokenRecipient.x(\_:)

```swift theme={null}
case x(OptionalChain)
```

## Instance Properties

### description

Inherited from `CustomStringConvertible.description`.

```swift theme={null}
var description: String { get }
```

## Instance Methods

### encode(to:)

Inherited from `Encodable.encode(to:)`.

```swift theme={null}
func encode(to encoder: Encoder) throws
```

### matches(\_:)

```swift theme={null}
func matches(_ string: String) -> Bool
```

## Enumerations

### TransferTokenRecipient.OptionalChain

```swift theme={null}
enum OptionalChain
```


# UnknownChain
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/unknownchain

Swift Enumeration

**Enumeration**

```swift theme={null}
enum UnknownChain
```

## Enumeration Cases

### UnknownChain.unknown(name:isTest:)

```swift theme={null}
case unknown(name: String, isTest: Bool)
```

## Initializers

### init(\_:)

Inherited from `SpecificChain.init(_:)`.

```swift theme={null}
init?(_ from: String)
```

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

## Instance Properties

### chain

Inherited from `SpecificChain.chain`.

```swift theme={null}
var chain: Chain { get }
```

### chainType

Inherited from `AnyChain.chainType`.

```swift theme={null}
var chainType: ChainType { get }
```

### name

Inherited from `AnyChain.name`.

```swift theme={null}
var name: String { get }
```

## Instance Methods

### isValid(isProductionEnvironment:)

Inherited from `AnyChain.isValid(isProductionEnvironment:)`.

```swift theme={null}
func isValid(isProductionEnvironment: Bool) -> Bool
```


# UnknownMapping
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/unknownmapping

Swift Enumeration

**Enumeration**

```swift theme={null}
enum UnknownMapping
```

## Type Aliases

### UnknownMapping.APIModel

Inherited from `WalletTypeTransactionMapping.APIModel`.

```swift theme={null}
typealias APIModel = UnknownApiTransaction
```

## Type Properties

### chainType

Inherited from `WalletTypeTransactionMapping.chainType`.

```swift theme={null}
static let chainType: ChainType
```


# UserVerificationRequirement
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/userverificationrequirement

Swift Enumeration

**Enumeration**

Specification reference: [https://w3c.github.io/webauthn/#enum-userVerificationRequirement](https://w3c.github.io/webauthn/#enum-userVerificationRequirement)

```swift theme={null}
enum UserVerificationRequirement
```

## Enumeration Cases

### UserVerificationRequirement.discouraged

```swift theme={null}
case discouraged
```

### UserVerificationRequirement.preferred

```swift theme={null}
case preferred
```

### UserVerificationRequirement.required

```swift theme={null}
case required
```

## Initializers

### init(rawValue:)

Inherited from `RawRepresentable.init(rawValue:)`.

```swift theme={null}
init?(rawValue: String)
```


# WalletError
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/walleterror

Swift Enumeration

**Enumeration**

```swift theme={null}
enum WalletError
```

## Enumeration Cases

### WalletError.invalidChain(chain:)

```swift theme={null}
case invalidChain(chain: Chain)
```

### WalletError.invalidToken(token:)

```swift theme={null}
case invalidToken(token: CryptoCurrency)
```

### WalletError.serviceError(\_:)

```swift theme={null}
case serviceError(CrossmintServiceError)
```

### WalletError.transactionNotFound

```swift theme={null}
case transactionNotFound
```

### WalletError.walletCreationCancelled

```swift theme={null}
case walletCreationCancelled
```

### WalletError.walletCreationFailed(\_:)

```swift theme={null}
case walletCreationFailed(String)
```

### WalletError.walletGeneric(\_:)

```swift theme={null}
case walletGeneric(String)
```

### WalletError.walletInvalidCredentials

```swift theme={null}
case walletInvalidCredentials
```

### WalletError.walletInvalidSignerProvided

```swift theme={null}
case walletInvalidSignerProvided
```

### WalletError.walletInvalidType(\_:)

```swift theme={null}
case walletInvalidType(String)
```

### WalletError.walletLocatorError(\_:)

```swift theme={null}
case walletLocatorError(String)
```

### WalletError.walletNotFound

```swift theme={null}
case walletNotFound
```

## Instance Properties

### errorMessage

Inherited from `ServiceError.errorMessage`.

```swift theme={null}
var errorMessage: String { get }
```

## Type Methods

### fromNetworkError(\_:)

Inherited from `ServiceError.fromNetworkError(_:)`.

```swift theme={null}
static func fromNetworkError(_ error: NetworkError) -> WalletError
```

### fromServiceError(\_:)

Inherited from `ServiceError.fromServiceError(_:)`.

```swift theme={null}
static func fromServiceError(_ error: CrossmintServiceError) -> WalletError
```


# WalletLocator
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/walletlocator

Swift Enumeration

**Enumeration**

```swift theme={null}
enum WalletLocator
```

## Enumeration Cases

### WalletLocator.address(\_:)

```swift theme={null}
case address(Address)
```

### WalletLocator.externalWallet(*:*:)

```swift theme={null}
case externalWallet(Chain, Address)
```

### WalletLocator.owner(*:*:)

```swift theme={null}
case owner(Owner, ChainType)
```

### WalletLocator.ownerWithChain(*:*:)

```swift theme={null}
case ownerWithChain(Owner, Chain)
```

## Initializers

### init(from:)

```swift theme={null}
init(from locator: String) throws
```

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: Decoder) throws
```

## Instance Properties

### value

```swift theme={null}
var value: String { get }
```

## Instance Methods

### encode(to:)

Inherited from `Encodable.encode(to:)`.

```swift theme={null}
func encode(to encoder: Encoder) throws
```


# WalletType
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/enums/wallettype

Swift Enumeration

**Enumeration**

```swift theme={null}
enum WalletType
```

## Enumeration Cases

### WalletType.mpc

```swift theme={null}
case mpc
```

### WalletType.smart

```swift theme={null}
case smart
```

## Initializers

### init(rawValue:)

Inherited from `RawRepresentable.init(rawValue:)`.

```swift theme={null}
init?(rawValue: String)
```


# CrossmintCommonTypes
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/extensions/crossmintcommontypes

Swift Extended Module

**Extended Module**

## Extended Enumerations

### EVMChain

```swift theme={null}
extension EVMChain
```

### SolanaChain

```swift theme={null}
extension SolanaChain
```

### StellarChain

```swift theme={null}
extension StellarChain
```


# Logger
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/extensions/logger

Swift Extended Module

**Extended Module**

## Extended Structures

### Logger

```swift theme={null}
extension Logger
```


# SwiftUICore
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/extensions/swiftuicore

Swift Extended Module

**Extended Module**

## Extended Protocols

### View

```swift theme={null}
extension View
```


# getBlockchainExplorerURL(for:)
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/functions/getblockchainexplorerurl-for

Swift Function

**Function**

```swift theme={null}
func getBlockchainExplorerURL(for link: BlockchainExplorerLinkType) -> String
```


# AdminSignerApiModel
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/protocols/adminsignerapimodel

Swift Protocol

**Protocol**

```swift theme={null}
protocol AdminSignerApiModel : Decodable, Encodable
```

## Instance Properties

### toDomain

```swift theme={null}
var toDomain: AdminSignerData { get }
```

### type

```swift theme={null}
var type: AdminSignerDataType { get }
```


# AdminSignerData
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/protocols/adminsignerdata

Swift Protocol

**Protocol**

```swift theme={null}
protocol AdminSignerData : Decodable, Encodable, Sendable
```

## Instance Properties

### locator

```swift theme={null}
var locator: String { get }
```

### locatorId

```swift theme={null}
var locatorId: String { get }
```

### type

```swift theme={null}
var type: AdminSignerDataType { get }
```


# AnyChain
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/protocols/anychain

Swift Protocol

**Protocol**

```swift theme={null}
protocol AnyChain : Sendable
```

## Instance Properties

### chainType

```swift theme={null}
var chainType: ChainType { get }
```

### name

```swift theme={null}
var name: String { get }
```

## Instance Methods

### isValid(isProductionEnvironment:)

```swift theme={null}
func isValid(isProductionEnvironment: Bool) -> Bool
```


# AuthenticatedService
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/protocols/authenticatedservice

Swift Protocol

**Protocol**

```swift theme={null}
protocol AuthenticatedService : Sendable
```

## Instance Properties

### authHeaders

```swift theme={null}
var authHeaders: [String : String] { get async }
```


# AuthManager
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/protocols/authmanager

Swift Protocol

**Protocol**

```swift theme={null}
protocol AuthManager : Sendable
```

## Instance Properties

### jwt

```swift theme={null}
var jwt: String? { get async }
```

## Instance Methods

### setJWT(\_:)

```swift theme={null}
func setJWT(_ jwt: String) async
```


# AuthService
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/protocols/authservice

Swift Protocol

**Protocol**

```swift theme={null}
protocol AuthService : Sendable
```

## Instance Methods

### logout(\_:)

```swift theme={null}
func logout(_ logoutRequest: LogoutRequest) async throws(AuthError)
```

### refreshJWT(\_:)

```swift theme={null}
func refreshJWT(_ refreshJWTRequest: RefreshJWTRequest) async throws(AuthError) -> RefreshJWTResponse
```

### validateEmail(\_:)

```swift theme={null}
func validateEmail(_ validateEmailRequest: ValidateEmailRequest) async throws(AuthError) -> ValidateEmailResponse
```

### validateToken(\_:)

```swift theme={null}
func validateToken(_ validateTokenRequest: ValidateTokenRequest) async throws(AuthError) -> ValidateTokenResponse
```


# BlockchainAddress
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/protocols/blockchainaddress

Swift Protocol

**Protocol**

```swift theme={null}
protocol BlockchainAddress : CustomStringConvertible, Decodable, Encodable, Hashable, Sendable
```

## Initializers

### init(address:)

```swift theme={null}
init(address: String) throws(BlockchainAddressError)
```


# ChainWithSigners
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/protocols/chainwithsigners

Swift Protocol

**Protocol**

Protocol that associates a `SpecificChain` with its corresponding `SignerProvider`.

```swift theme={null}
protocol ChainWithSigners : SpecificChain
```

This protocol extends `SpecificChain` to add the signer provider association, enabling generic wallet creation methods that work across all chains without requiring separate method overloads per chain type.

## Associated Types

### SpecificSigner

```swift theme={null}
associatedtype SpecificSigner : SignerProvider
```


# ClientSDK
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/protocols/clientsdk

Swift Protocol

**Protocol**

```swift theme={null}
protocol ClientSDK
```

## Instance Properties

### authManager

```swift theme={null}
var authManager: AuthManager { get }
```

### crossmintService

```swift theme={null}
var crossmintService: CrossmintService { get }
```

## Instance Methods

### crossmintWallets()

```swift theme={null}
func crossmintWallets() -> CrossmintWallets
```


# CrossmintService
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/protocols/crossmintservice

Swift Protocol

**Protocol**

```swift theme={null}
protocol CrossmintService : Sendable
```

## Instance Properties

### isProductionEnvironment

```swift theme={null}
var isProductionEnvironment: Bool { get }
```

## Instance Methods

### executeRequest(\_:errorType:)

```swift theme={null}
func executeRequest<T, E>(_ endpoint: Endpoint, errorType: E.Type) async throws(E) -> T where T : Decodable, E : ServiceError
```

### executeRequest(\_:errorType:)

```swift theme={null}
func executeRequest<E>(_ endpoint: Endpoint, errorType: E.Type) async throws(E) where E : ServiceError
```

### executeRequest(*:errorType:*:)

```swift theme={null}
func executeRequest<T, E>(_ endpoint: Endpoint, errorType: E.Type, _ transform: (NetworkError) -> E?) async throws(E) -> T where T : Decodable, E : ServiceError
```

### executeRequest(*:errorType:*:)

```swift theme={null}
func executeRequest<E>(_ endpoint: Endpoint, errorType: E.Type, _ transform: (NetworkError) -> E?) async throws(E) where E : ServiceError
```

### executeRequestForRawData(\_:errorType:)

```swift theme={null}
func executeRequestForRawData<E>(_ endpoint: Endpoint, errorType: E.Type) async throws(E) -> Data where E : ServiceError
```

### executeRequestForRawData(*:errorType:*:)

```swift theme={null}
func executeRequestForRawData<E>(_ endpoint: Endpoint, errorType: E.Type, _ transform: (NetworkError) -> E?) async throws(E) -> Data where E : ServiceError
```

### getApiBaseURL()

```swift theme={null}
func getApiBaseURL() throws(CrossmintServiceError) -> URL
```


# CrossmintWallets
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/protocols/crossmintwallets

Swift Protocol

**Protocol**

```swift theme={null}
protocol CrossmintWallets : Sendable
```

## Instance Methods

### getOrCreateWallet(chain:signer:options:)

```swift theme={null}
func getOrCreateWallet<C>(chain: C, signer: C.SpecificSigner, options: WalletOptions?) async throws(WalletError) -> Wallet where C : ChainWithSigners
```

### getOrCreateWallet(chain:signer:options:)

```swift theme={null}
func getOrCreateWallet(chain: Chain, signer: any Signer, options: WalletOptions?) async throws(WalletError) -> Wallet
```


# EVMCompatibleSigner
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/protocols/evmcompatiblesigner

Swift Protocol

**Protocol**

```swift theme={null}
protocol EVMCompatibleSigner : Sendable
```


# JSONCoder
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/protocols/jsoncoder

Swift Protocol

**Protocol**

```swift theme={null}
protocol JSONCoder : Sendable
```

## Instance Methods

### decode(\_:from:)

```swift theme={null}
func decode<T>(_ type: T.Type, from data: Data) throws(CrossmintServiceError) -> T where T : Decodable
```

### encode(\_:)

```swift theme={null}
func encode<T>(_ instance: T) throws(CrossmintServiceError) -> Data where T : Encodable
```

### encodeRequest(\_:errorType:)

```swift theme={null}
func encodeRequest<T, E>(_ request: T, errorType: E.Type) throws(E) -> Data where T : Encodable, E : ServiceError
```


# RequestBuilder
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/protocols/requestbuilder

Swift Protocol

**Protocol**

```swift theme={null}
protocol RequestBuilder : Sendable
```

## Instance Methods

### getApiBaseURL(forApiKey:)

```swift theme={null}
func getApiBaseURL(forApiKey key: ApiKey) throws(RequestBuilderError) -> URL
```

### getRequest(forEndpoint:withKey:andAppIdentifier:)

```swift theme={null}
func getRequest(forEndpoint endpoint: Endpoint, withKey key: ApiKey, andAppIdentifier appIdentifier: String) throws(RequestBuilderError) -> URLRequest
```


# SecureStorage
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/protocols/securestorage

Swift Protocol

**Protocol**

```swift theme={null}
protocol SecureStorage : Sendable
```

## Instance Methods

### clear()

```swift theme={null}
func clear()
```

### getEmail()

```swift theme={null}
func getEmail() async throws(SecureStorageError) -> String?
```

### getJWT()

```swift theme={null}
func getJWT() async throws(SecureStorageError) -> String?
```

### getOneTimeSecret()

```swift theme={null}
func getOneTimeSecret() async throws(SecureStorageError) -> String?
```

### storeEmail(\_:)

```swift theme={null}
func storeEmail(_ email: String) async throws(SecureStorageError)
```

### storeJWT(\_:)

```swift theme={null}
func storeJWT(_ secret: String) async throws(SecureStorageError)
```

### storeOneTimeSecret(\_:)

```swift theme={null}
func storeOneTimeSecret(_ secret: String) async throws(SecureStorageError)
```


# SecureWalletStorage
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/protocols/securewalletstorage

Swift Protocol

**Protocol**

```swift theme={null}
protocol SecureWalletStorage : Sendable
```

## Instance Methods

### getPrivateKey(forEmail:)

```swift theme={null}
func getPrivateKey(forEmail email: String) -> String?
```

### savePrivateKey(\_:forEmail:)

```swift theme={null}
func savePrivateKey(_ privateKey: String, forEmail email: String)
```


# ServiceError
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/protocols/serviceerror

Swift Protocol

**Protocol**

```swift theme={null}
protocol ServiceError : Error
```

## Instance Properties

### errorMessage

```swift theme={null}
var errorMessage: String { get }
```

## Type Methods

### fromNetworkError(\_:)

```swift theme={null}
static func fromNetworkError(_ error: NetworkError) -> Self
```

### fromServiceError(\_:)

```swift theme={null}
static func fromServiceError(_ error: CrossmintServiceError) -> Self
```


# SignatureApiModel
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/protocols/signatureapimodel

Swift Protocol

**Protocol**

```swift theme={null}
protocol SignatureApiModel : Decodable
```

## Instance Properties

### approvals

```swift theme={null}
var approvals: Approvals { get }
```

### chainType

```swift theme={null}
var chainType: String? { get }
```

### createdAt

```swift theme={null}
var createdAt: Date { get }
```

### id

```swift theme={null}
var id: String { get }
```

### status

```swift theme={null}
var status: String { get }
```

### type

```swift theme={null}
var type: String { get }
```

### walletType

```swift theme={null}
var walletType: String? { get }
```


# Signer
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/protocols/signer

Swift Protocol

**Protocol**

```swift theme={null}
protocol Signer<AdminType> : Sendable
```

## Associated Types

### AdminType

```swift theme={null}
associatedtype AdminType : AdminSignerData
```

## Instance Properties

### adminSigner

```swift theme={null}
var adminSigner: AdminType { get async }
```

### signerType

```swift theme={null}
var signerType: SignerType { get }
```

## Instance Methods

### approvals(withSignature:)

```swift theme={null}
func approvals(withSignature signature: String) async throws(SignerError) -> [SignRequestApi.Approval]
```

### initialize()

```swift theme={null}
func initialize() async throws(SignerError)
```

### initialize(\_:)

```swift theme={null}
func initialize(_ service: SmartWalletService?) async throws(SignerError)
```

### sign(message:)

```swift theme={null}
func sign(message: String) async throws(SignerError) -> String
```


# SignerProvider
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/protocols/signerprovider

Swift Protocol

**Protocol**

```swift theme={null}
protocol SignerProvider : Sendable
```

## Instance Properties

### signer

```swift theme={null}
@MainActor var signer: any Signer { get }
```


# SmartWalletCreationQueryParams
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/protocols/smartwalletcreationqueryparams

Swift Protocol

**Protocol**

```swift theme={null}
protocol SmartWalletCreationQueryParams : Encodable, Sendable
```

## Instance Properties

### type

```swift theme={null}
var type: WalletType { get }
```


# SmartWalletService
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/protocols/smartwalletservice

Swift Protocol

**Protocol**

```swift theme={null}
protocol SmartWalletService : AuthenticatedService
```

## Instance Properties

### isProductionEnvironment

```swift theme={null}
var isProductionEnvironment: Bool { get }
```

## Instance Methods

### approveSignature(\_:)

```swift theme={null}
func approveSignature(_ request: SignRequest) async throws(SignatureError)
```

### createSignature(\_:)

```swift theme={null}
func createSignature(_ request: CreateSignatureRequest) async throws(SignatureError) -> any SignatureApiModel
```

### createTransaction(\_:)

```swift theme={null}
func createTransaction(_ request: CreateTransactionRequest) async throws(TransactionError) -> any TransactionApiModel
```

### createWallet(\_:)

```swift theme={null}
func createWallet(_ request: CreateWalletParams) async throws(WalletError) -> WalletApiModel
```

### fetchSignature(\_:chainType:)

```swift theme={null}
func fetchSignature(_ signatureId: String, chainType: ChainType) async throws(SignatureError) -> any SignatureApiModel
```

### fetchTransaction(\_:)

```swift theme={null}
func fetchTransaction(_ fetchTransactionRequest: FetchTransactionRequest) async throws(TransactionError) -> any TransactionApiModel
```

### fund(\_:)

```swift theme={null}
func fund(_ request: FundWalletRequest) async throws(WalletError)
```

### getBalance(\_:)

```swift theme={null}
func getBalance(_ params: GetBalanceQueryParams) async throws(WalletError) -> Balances
```

### getNFTs(\_:)

```swift theme={null}
func getNFTs(_ params: GetNTFQueryParams) async throws(WalletError) -> [NFT]
```

### getWallet(\_:)

```swift theme={null}
func getWallet(_ request: GetMeWalletRequest) async throws(WalletError) -> WalletApiModel
```

### signTransaction(\_:)

```swift theme={null}
func signTransaction(_ request: SignRequest) async throws(TransactionError) -> any TransactionApiModel
```

### transferToken(chainType:tokenLocator:recipient:amount:idempotencyKey:)

```swift theme={null}
func transferToken(chainType: String, tokenLocator: String, recipient: String, amount: String, idempotencyKey: String?) async throws(TransactionError) -> any TransactionApiModel
```


# SolanaCompatibleSigner
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/protocols/solanacompatiblesigner

Swift Protocol

**Protocol**

```swift theme={null}
protocol SolanaCompatibleSigner : Sendable
```


# SpecificChain
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/protocols/specificchain

Swift Protocol

**Protocol**

```swift theme={null}
protocol SpecificChain : AnyChain, Decodable, Encodable, Hashable
```

## Operators

### !=(*:*:)

```swift theme={null}
static func != (lhs: Chain, rhs: Self) -> Bool
```

### !=(*:*:)

```swift theme={null}
static func != (lhs: Self, rhs: Chain) -> Bool
```

## Initializers

### init(\_:)

```swift theme={null}
init?(_ from: String)
```

## Instance Properties

### chain

```swift theme={null}
var chain: Chain { get }
```


# StellarCompatibleSigner
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/protocols/stellarcompatiblesigner

Swift Protocol

**Protocol**

```swift theme={null}
protocol StellarCompatibleSigner : Sendable
```


# TransactionApiModel
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/protocols/transactionapimodel

Swift Protocol

**Protocol**

```swift theme={null}
protocol TransactionApiModel : Decodable, Identifiable
```

## Instance Methods

### toDomain(withService:)

```swift theme={null}
func toDomain(withService service: SmartWalletService) -> Transaction?
```


# TransactionRequest
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/protocols/transactionrequest

Swift Protocol

**Protocol**

```swift theme={null}
protocol TransactionRequest : Encodable
```


# WalletOnChain
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/protocols/walletonchain

Swift Protocol

**Protocol**

```swift theme={null}
protocol WalletOnChain
```

## Associated Types

### SpecificChain

```swift theme={null}
associatedtype SpecificChain : AnyChain
```

## Instance Methods

### fund(token:amount:on:)

```swift theme={null}
func fund(token: CryptoCurrency, amount: Int, on chain: SpecificChain) async throws(WalletError)
```

### nfts(page:nftsPerPage:on:)

```swift theme={null}
func nfts(page: Int, nftsPerPage: Int, on chain: SpecificChain) async throws(WalletError) -> [NFT]
```


# WalletTypeTransactionMapping
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/protocols/wallettypetransactionmapping

Swift Protocol

**Protocol**

```swift theme={null}
protocol WalletTypeTransactionMapping
```

## Associated Types

### APIModel

```swift theme={null}
associatedtype APIModel : TransactionApiModel
```

## Type Properties

### chainType

```swift theme={null}
static var chainType: ChainType { get }
```


# ABIAddress
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/abiaddress

Swift Structure

**Structure**

```swift theme={null}
struct ABIAddress
```

## Initializers

### init(address:)

```swift theme={null}
init(address: String)
```


# ABIUInt64
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/abiuint64

Swift Structure

**Structure**

```swift theme={null}
struct ABIUInt64
```

## Initializers

### init(uint:)

```swift theme={null}
init(uint: UInt64)
```


# AccountWalletConfig
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/accountwalletconfig

Swift Structure

**Structure**

```swift theme={null}
struct AccountWalletConfig
```

## Structures

### AccountWalletConfig.Signer

```swift theme={null}
struct Signer
```


# ApiKey
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/apikey

Swift Structure

**Structure**

```swift theme={null}
struct ApiKey
```

## Initializers

### init(key:)

```swift theme={null}
init(key: String) throws(ApiKey.Error)
```

## Instance Properties

### apiEnvironmentPathComponent

```swift theme={null}
var apiEnvironmentPathComponent: String { get }
```

### environment

```swift theme={null}
let environment: CrossmintEnvironment
```

### key

```swift theme={null}
let key: String
```

### type

```swift theme={null}
let type: Type
```

## Enumerations

### ApiKey.Error

```swift theme={null}
enum Error
```

### ApiKey.Type

```swift theme={null}
enum `Type`
```


# ApiKeySignerApiModel
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/apikeysignerapimodel

Swift Structure

<Note>
  [Contact us](https://www.crossmint.com/contact/sales) for access to API key signers.
</Note>

**Structure**

```swift theme={null}
struct ApiKeySignerApiModel
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

## Instance Properties

### address

```swift theme={null}
let address: String
```

### locator

```swift theme={null}
let locator: String
```

### toDomain

Inherited from `AdminSignerApiModel.toDomain`.

```swift theme={null}
var toDomain: any AdminSignerData { get }
```

### type

Inherited from `AdminSignerApiModel.type`.

```swift theme={null}
let type: AdminSignerDataType
```


# ApiKeySignerData
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/apikeysignerdata

Swift Structure

<Note>
  [Contact us](https://www.crossmint.com/contact/sales) for access to API key signers.
</Note>

**Structure**

```swift theme={null}
struct ApiKeySignerData
```

## Initializers

### init()

```swift theme={null}
init()
```

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: Decoder) throws
```

## Instance Properties

### locatorId

Inherited from `AdminSignerData.locatorId`.

```swift theme={null}
var locatorId: String { get }
```

### type

Inherited from `AdminSignerData.type`.

```swift theme={null}
var type: AdminSignerDataType { get }
```

## Instance Methods

### encode(to:)

Inherited from `Encodable.encode(to:)`.

```swift theme={null}
nonisolated func encode(to encoder: Encoder) throws
```


# ApprovalEntry
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/approvalentry

Swift Structure

**Structure**

```swift theme={null}
struct ApprovalEntry
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```


# Approvals
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/approvals

Swift Structure

**Structure**

```swift theme={null}
struct Approvals
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```


# AttestationPublicKeyParser
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/attestationpublickeyparser

Swift Structure

**Structure**

```swift theme={null}
struct AttestationPublicKeyParser
```

## Type Methods

### parse(attestationObjectData:)

```swift theme={null}
static func parse(attestationObjectData: Data) throws -> ParsedPublicKeyP256
```


# AuthenticationExtensionsClientInputs
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/authenticationextensionsclientinputs

Swift Structure

**Structure**

Specification reference: [https://w3c.github.io/webauthn/#dictdef-authenticationextensionsclientinputs](https://w3c.github.io/webauthn/#dictdef-authenticationextensionsclientinputs)

```swift theme={null}
struct AuthenticationExtensionsClientInputs
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

### init(largeBlob:)

```swift theme={null}
init(largeBlob: AuthenticationExtensionsLargeBlobInputs? = nil)
```


# AuthenticationExtensionsClientOutputsJSON
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/authenticationextensionsclientoutputsjson

Swift Structure

**Structure**

Specification reference: [https://w3c.github.io/webauthn/#dictdef-authenticationextensionsclientoutputsjson](https://w3c.github.io/webauthn/#dictdef-authenticationextensionsclientoutputsjson)

```swift theme={null}
struct AuthenticationExtensionsClientOutputsJSON
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```


# AuthenticationExtensionsLargeBlobInputs
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/authenticationextensionslargeblobinputs

Swift Structure

**Structure**

Specification reference: [https://w3c.github.io/webauthn/#dictdef-authenticationextensionslargeblobinputs](https://w3c.github.io/webauthn/#dictdef-authenticationextensionslargeblobinputs)

```swift theme={null}
struct AuthenticationExtensionsLargeBlobInputs
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

### init(support:read:write:)

```swift theme={null}
init(support: LargeBlobSupport? = nil, read: Bool? = nil, write: Data? = nil)
```


# AuthenticationExtensionsLargeBlobOutputsJSON
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/authenticationextensionslargebloboutputsjson

Swift Structure

**Structure**

We convert this to `AuthenticationExtensionsLargeBlobOutputsJSON` instead of `AuthenticationExtensionsLargeBlobOutputs` for consistency and because it is what is actually returned to RN

```swift theme={null}
struct AuthenticationExtensionsLargeBlobOutputsJSON
```

Specification reference: [https://w3c.github.io/webauthn/#dictdef-authenticationextensionslargebloboutputs](https://w3c.github.io/webauthn/#dictdef-authenticationextensionslargebloboutputs)

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```


# AuthenticationResponseJSON
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/authenticationresponsejson

Swift Structure

**Structure**

Specification reference: [https://w3c.github.io/webauthn/#dictdef-authenticationresponsejson](https://w3c.github.io/webauthn/#dictdef-authenticationresponsejson)

```swift theme={null}
struct AuthenticationResponseJSON
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

## Instance Properties

### clientExtensionResults

```swift theme={null}
let clientExtensionResults: AuthenticationExtensionsClientOutputsJSON?
```

### id

```swift theme={null}
let id: Data
```

### rawId

```swift theme={null}
let rawId: Data?
```

### response

```swift theme={null}
let response: AuthenticatorAssertionResponseJSON
```

### type

```swift theme={null}
let type: PublicKeyCredentialType
```


# AuthenticatorAssertionResponseJSON
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/authenticatorassertionresponsejson

Swift Structure

**Structure**

Specification reference: [https://w3c.github.io/webauthn/#dictdef-authenticatorassertionresponsejson](https://w3c.github.io/webauthn/#dictdef-authenticatorassertionresponsejson)

```swift theme={null}
struct AuthenticatorAssertionResponseJSON
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

## Instance Properties

### authenticatorData

```swift theme={null}
let authenticatorData: Data
```

### clientDataJSON

```swift theme={null}
let clientDataJSON: Data
```

### signature

```swift theme={null}
let signature: Data
```

### userHandle

```swift theme={null}
let userHandle: Base64URLString?
```


# AuthenticatorAttestationResponseJSON
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/authenticatorattestationresponsejson

Swift Structure

**Structure**

Specification reference: [https://w3c.github.io/webauthn/#dictdef-authenticatorattestationresponsejson](https://w3c.github.io/webauthn/#dictdef-authenticatorattestationresponsejson)

```swift theme={null}
struct AuthenticatorAttestationResponseJSON
```

## Instance Properties

### attestationObject

```swift theme={null}
var attestationObject: Data
```

### authenticatorData

```swift theme={null}
var authenticatorData: Data?
```

### clientDataJSON

```swift theme={null}
var clientDataJSON: Data
```

### publicKey

```swift theme={null}
var publicKey: ParsedPublicKeyP256?
```

### publicKeyAlgorithm

```swift theme={null}
var publicKeyAlgorithm: Int?
```

### transports

```swift theme={null}
var transports: [AuthenticatorTransport]?
```


# AuthenticatorSelectionCriteria
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/authenticatorselectioncriteria

Swift Structure

**Structure**

Specification reference: [https://w3c.github.io/webauthn/#dictionary-authenticatorSelection](https://w3c.github.io/webauthn/#dictionary-authenticatorSelection)

```swift theme={null}
struct AuthenticatorSelectionCriteria
```

## Initializers

### init(authenticatorAttachment:requireResidentKey:residentKey:userVerification:)

```swift theme={null}
init(authenticatorAttachment: AuthenticatorAttachment? = nil, requireResidentKey: Bool? = false, residentKey: ResidentKeyRequirement? = nil, userVerification: UserVerificationRequirement? = UserVerificationRequirement.preferred)
```

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```


# Balance
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/balance

Swift Structure

**Structure**

```swift theme={null}
struct Balance
```

## Initializers

### init(nativeToken:usdc:tokens:)

```swift theme={null}
init(nativeToken: TokenBalance, usdc: TokenBalance, tokens: [TokenBalance])
```

## Instance Properties

### nativeToken

```swift theme={null}
let nativeToken: TokenBalance
```

### tokens

```swift theme={null}
let tokens: [TokenBalance]
```

### usdc

```swift theme={null}
let usdc: TokenBalance
```


# Balances
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/balances

Swift Structure

**Structure**

```swift theme={null}
struct Balances
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

## Instance Properties

### isEmpty

```swift theme={null}
var isEmpty: Bool { get }
```

### tokens

```swift theme={null}
var tokens: [CryptoCurrency] { get }
```

## Instance Methods

### filter(\_:)

```swift theme={null}
func filter(_ isIncluded: (CryptoCurrency, ChainBalances) -> Bool) -> Balances
```

### nonZeroBalances()

```swift theme={null}
func nonZeroBalances() -> Balances
```

## Subscripts

### subscript(\_:)

```swift theme={null}
subscript(currency: CryptoCurrency) -> ChainBalances? { get }
```


# BalanceTransformer
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/balancetransformer

Swift Structure

**Structure**

```swift theme={null}
struct BalanceTransformer
```

## Type Methods

### transform(from:nativeToken:requestedTokens:)

```swift theme={null}
static func transform(from balances: Balances, nativeToken: CryptoCurrency, requestedTokens: [CryptoCurrency]) -> Balance
```


# BlockchainAddressLink
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/blockchainaddresslink

Swift Structure

**Structure**

```swift theme={null}
struct BlockchainAddressLink
```

## Instance Properties

### address

```swift theme={null}
let address: String
```

### chain

```swift theme={null}
let chain: Chain
```


# BlockchainTokenLink
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/blockchaintokenlink

Swift Structure

**Structure**

```swift theme={null}
struct BlockchainTokenLink
```

## Instance Properties

### options

```swift theme={null}
let options: TokenLinkOptions?
```

### tokenLocator

```swift theme={null}
let tokenLocator: String
```


# BlockchainTransactionLink
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/blockchaintransactionlink

Swift Structure

**Structure**

```swift theme={null}
struct BlockchainTransactionLink
```

## Instance Properties

### chain

```swift theme={null}
let chain: Chain
```

### txId

```swift theme={null}
let txId: String
```


# ChainBalances
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/chainbalances

Swift Structure

**Structure**

```swift theme={null}
struct ChainBalances
```

## Instance Properties

### chainBalances

```swift theme={null}
let chainBalances: [Chain : Decimal]
```

### decimals

```swift theme={null}
let decimals: Int
```

### total

```swift theme={null}
let total: Decimal
```

## Instance Methods

### convertToBaseUnits(\_:)

```swift theme={null}
func convertToBaseUnits(_ value: String) -> String?
```

### merge(with:)

```swift theme={null}
func merge(with other: ChainBalances?) -> ChainBalances
```

## Subscripts

### subscript(\_:)

```swift theme={null}
subscript(chain: Chain) -> Decimal { get }
```


# CreateEVMTransactionRequest
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/createevmtransactionrequest

Swift Structure

**Structure**

```swift theme={null}
struct CreateEVMTransactionRequest
```

## Instance Methods

### encode(to:)

Inherited from `Encodable.encode(to:)`.

```swift theme={null}
func encode(to encoder: Encoder) throws
```


# CreateSignatureRequest
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/createsignaturerequest

Swift Structure

**Structure**

```swift theme={null}
struct CreateSignatureRequest
```

## Initializers

### init(signMessageRequest:chainType:)

```swift theme={null}
init(signMessageRequest: SignMessageRequest, chainType: ChainType)
```

### init(signTypedDataRequest:chainType:)

```swift theme={null}
init(signTypedDataRequest: SignTypedDataRequest, chainType: ChainType)
```


# CreateSolanaTransactionRequest
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/createsolanatransactionrequest

Swift Structure

**Structure**

```swift theme={null}
struct CreateSolanaTransactionRequest
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: Decoder) throws
```

### init(transaction:)

```swift theme={null}
init(transaction: String)
```

## Instance Properties

### transaction

```swift theme={null}
let transaction: String
```

## Instance Methods

### encode(to:)

Inherited from `Encodable.encode(to:)`.

```swift theme={null}
func encode(to encoder: Encoder) throws
```


# CreateStellarTransactionRequest
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/createstellartransactionrequest

Swift Structure

**Structure**

```swift theme={null}
struct CreateStellarTransactionRequest
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: Decoder) throws
```

### init(transaction:)

```swift theme={null}
init(transaction: String)
```

## Instance Properties

### transaction

```swift theme={null}
let transaction: String
```

## Instance Methods

### encode(to:)

Inherited from `Encodable.encode(to:)`.

```swift theme={null}
func encode(to encoder: Encoder) throws
```


# CreateTransactionRequest
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/createtransactionrequest

Swift Structure

**Structure**

```swift theme={null}
struct CreateTransactionRequest
```


# CreateWalletParams
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/createwalletparams

Swift Structure

**Structure**

```swift theme={null}
struct CreateWalletParams
```


# DefaultCrossmintService
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/defaultcrossmintservice

Swift Structure

**Structure**

```swift theme={null}
struct DefaultCrossmintService
```

## Initializers

### init(apiKey:appIdentifier:httpClient:requestBuilder:jsonCoder:)

```swift theme={null}
init(apiKey: ApiKey, appIdentifier: String, httpClient: HTTPClient = .live, requestBuilder: RequestBuilder = DefaultRequestBuilder(), jsonCoder: JSONCoder = DefaultJSONCoder())
```

## Instance Properties

### isProductionEnvironment

Inherited from `CrossmintService.isProductionEnvironment`.

```swift theme={null}
var isProductionEnvironment: Bool { get }
```

## Instance Methods

### executeRequest(*:errorType:*:)

Inherited from `CrossmintService.executeRequest(_:errorType:_:)`.

```swift theme={null}
func executeRequest<E>(_ endpoint: Endpoint, errorType: E.Type, _ transform: (NetworkError) -> E? = { _ in nil }) async throws(E) where E : ServiceError
```

### executeRequest(*:errorType:*:)

Inherited from `CrossmintService.executeRequest(_:errorType:_:)`.

```swift theme={null}
func executeRequest<T, E>(_ endpoint: Endpoint, errorType: E.Type, _ transform: (NetworkError) -> E? = { _ in nil }) async throws(E) -> T where T : Decodable, E : ServiceError
```

### executeRequestForRawData(*:errorType:*:)

Inherited from `CrossmintService.executeRequestForRawData(_:errorType:_:)`.

```swift theme={null}
func executeRequestForRawData<E>(_ endpoint: Endpoint, errorType: E.Type, _ transform: (NetworkError) -> E? = { _ in nil }) async throws(E) -> Data where E : ServiceError
```

### getApiBaseURL()

Inherited from `CrossmintService.getApiBaseURL()`.

```swift theme={null}
func getApiBaseURL() throws(CrossmintServiceError) -> URL
```


# DefaultJSONCoder
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/defaultjsoncoder

Swift Structure

**Structure**

```swift theme={null}
struct DefaultJSONCoder
```

## Initializers

### init()

```swift theme={null}
init()
```

## Instance Methods

### decode(\_:from:)

Inherited from `JSONCoder.decode(_:from:)`.

```swift theme={null}
func decode<T>(_ type: T.Type, from data: Data) throws(CrossmintServiceError) -> T where T : Decodable
```

### encode(\_:)

Inherited from `JSONCoder.encode(_:)`.

```swift theme={null}
func encode<T>(_ instance: T) throws(CrossmintServiceError) -> Data where T : Encodable
```


# DefaultRequestBuilder
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/defaultrequestbuilder

Swift Structure

**Structure**

```swift theme={null}
struct DefaultRequestBuilder
```

## Initializers

### init()

```swift theme={null}
init()
```

## Instance Methods

### getApiBaseURL(forApiKey:)

Inherited from `RequestBuilder.getApiBaseURL(forApiKey:)`.

```swift theme={null}
func getApiBaseURL(forApiKey key: ApiKey) throws(RequestBuilderError) -> URL
```

### getRequest(forEndpoint:withKey:andAppIdentifier:)

Inherited from `RequestBuilder.getRequest(forEndpoint:withKey:andAppIdentifier:)`.

```swift theme={null}
func getRequest(forEndpoint endpoint: Endpoint, withKey key: ApiKey, andAppIdentifier appIdentifier: String) throws(RequestBuilderError) -> URLRequest
```


# EmailSignerApiModel
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/emailsignerapimodel

Swift Structure

**Structure**

```swift theme={null}
struct EmailSignerApiModel
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

## Instance Properties

### email

```swift theme={null}
let email: String
```

### locator

```swift theme={null}
let locator: String
```

### toDomain

Inherited from `AdminSignerApiModel.toDomain`.

```swift theme={null}
var toDomain: any AdminSignerData { get }
```

### type

Inherited from `AdminSignerApiModel.type`.

```swift theme={null}
let type: AdminSignerDataType
```


# EmailSignerData
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/emailsignerdata

Swift Structure

**Structure**

```swift theme={null}
struct EmailSignerData
```

## Initializers

### init(email:)

```swift theme={null}
init(email: String)
```

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: Decoder) throws
```

## Instance Properties

### email

```swift theme={null}
let email: String
```

### locatorId

Inherited from `AdminSignerData.locatorId`.

```swift theme={null}
var locatorId: String { get }
```

### type

Inherited from `AdminSignerData.type`.

```swift theme={null}
var type: AdminSignerDataType { get }
```

## Instance Methods

### encode(to:)

Inherited from `Encodable.encode(to:)`.

```swift theme={null}
nonisolated func encode(to encoder: Encoder) throws
```


# ERC20Encoder
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/erc20encoder

Swift Structure

**Structure**

```swift theme={null}
struct ERC20Encoder
```

## Type Methods

### encode(functionName:arguments:)

```swift theme={null}
static func encode(functionName: String, arguments: [ABI.Argument]) throws(ERC20Encoder.Error) -> String
```

## Enumerations

### ERC20Encoder.Error

```swift theme={null}
enum Error
```


# EVMAddress
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/evmaddress

Swift Structure

**Structure**

```swift theme={null}
struct EVMAddress
```

## Initializers

### init(address:)

Inherited from `BlockchainAddress.init(address:)`.

```swift theme={null}
init(address: String) throws(BlockchainAddressError)
```

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

## Instance Properties

### address

```swift theme={null}
var address: String { get }
```

### description

Inherited from `CustomStringConvertible.description`.

```swift theme={null}
var description: String { get }
```

## Instance Methods

### encode(to:)

Inherited from `Encodable.encode(to:)`.

```swift theme={null}
func encode(to encoder: Encoder) throws
```


# EvmPasskeySignerApiModel
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/evmpasskeysignerapimodel

Swift Structure

**Structure**

```swift theme={null}
struct EvmPasskeySignerApiModel
```

## Structures

### EvmPasskeySignerApiModel.PublicKey

```swift theme={null}
struct PublicKey
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

## Instance Properties

### id

```swift theme={null}
let id: String
```

### locator

```swift theme={null}
let locator: String
```

### name

```swift theme={null}
let name: String
```

### publicKey

```swift theme={null}
let publicKey: PublicKey
```

### toDomain

Inherited from `AdminSignerApiModel.toDomain`.

```swift theme={null}
var toDomain: any AdminSignerData { get }
```

### type

Inherited from `AdminSignerApiModel.type`.

```swift theme={null}
let type: AdminSignerDataType
```

### validatorContractVersion

```swift theme={null}
let validatorContractVersion: String
```


# EVMTransactionApiModel
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/evmtransactionapimodel

Swift Structure

**Structure**

```swift theme={null}
struct EVMTransactionApiModel
```

## Structures

### EVMTransactionApiModel.Call

```swift theme={null}
struct Call
```

### EVMTransactionApiModel.OnChainData

```swift theme={null}
struct OnChainData
```

### EVMTransactionApiModel.Params

```swift theme={null}
struct Params
```

### EVMTransactionApiModel.UserOperation

```swift theme={null}
struct UserOperation
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

## Instance Properties

### approvals

```swift theme={null}
let approvals: Approvals?
```

### createdAt

```swift theme={null}
let createdAt: Date
```

### error

```swift theme={null}
let error: TransactionErrorApiModel?
```

### id

Inherited from `Identifiable.id`.

```swift theme={null}
let id: String
```

### onChain

```swift theme={null}
let onChain: OnChainData
```

### params

```swift theme={null}
let params: Params
```

### status

```swift theme={null}
let status: TransactionStatusApiModel
```

### walletType

```swift theme={null}
let walletType: WalletType
```

## Instance Methods

### toDomain(withService:)

Inherited from `TransactionApiModel.toDomain(withService:)`.

```swift theme={null}
func toDomain(withService service: SmartWalletService) -> Transaction?
```


# ExternalWalletSignerApiModel
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/externalwalletsignerapimodel

Swift Structure

**Structure**

```swift theme={null}
struct ExternalWalletSignerApiModel
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

## Instance Properties

### address

```swift theme={null}
let address: String
```

### locator

```swift theme={null}
let locator: String
```

### toDomain

Inherited from `AdminSignerApiModel.toDomain`.

```swift theme={null}
var toDomain: any AdminSignerData { get }
```

### type

Inherited from `AdminSignerApiModel.type`.

```swift theme={null}
let type: AdminSignerDataType
```


# ExternalWalletSignerData
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/externalwalletsignerdata

Swift Structure

**Structure**

```swift theme={null}
struct ExternalWalletSignerData
```

## Initializers

### init(address:)

```swift theme={null}
init(address: String)
```

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: Decoder) throws
```

## Instance Properties

### address

```swift theme={null}
let address: String
```

### locatorId

Inherited from `AdminSignerData.locatorId`.

```swift theme={null}
var locatorId: String { get }
```

### type

Inherited from `AdminSignerData.type`.

```swift theme={null}
var type: AdminSignerDataType { get }
```

## Instance Methods

### encode(to:)

Inherited from `Encodable.encode(to:)`.

```swift theme={null}
nonisolated func encode(to encoder: Encoder) throws
```


# FetchTransactionRequest
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/fetchtransactionrequest

Swift Structure

**Structure**

```swift theme={null}
struct FetchTransactionRequest
```


# FundWalletApiRequest
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/fundwalletapirequest

Swift Structure

**Structure**

```swift theme={null}
struct FundWalletApiRequest
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

### init(token:amount:chain:)

```swift theme={null}
init(token: String, amount: Int, chain: String)
```


# FundWalletRequest
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/fundwalletrequest

Swift Structure

**Structure**

```swift theme={null}
struct FundWalletRequest
```


# GetBalanceQueryParams
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/getbalancequeryparams

Swift Structure

**Structure**

```swift theme={null}
struct GetBalanceQueryParams
```

## Initializers

### init(walletLocator:token:chain:)

```swift theme={null}
init(walletLocator: WalletLocator, token: CryptoCurrency, chain: Chain)
```

### init(walletLocator:tokens:chains:)

```swift theme={null}
init(walletLocator: WalletLocator, tokens: [CryptoCurrency], chains: [AnyChain] = [])
```


# GetMeWalletRequest
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/getmewalletrequest

Swift Structure

**Structure**

```swift theme={null}
struct GetMeWalletRequest
```

## Initializers

### init(chainType:)

```swift theme={null}
init(chainType: ChainType)
```


# GetNTFQueryParams
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/getntfqueryparams

Swift Structure

**Structure**

```swift theme={null}
struct GetNTFQueryParams
```

## Initializers

### init(walletLocator:chain:page:perPage:)

```swift theme={null}
init(walletLocator: WalletLocator, chain: AnyChain, page: Int, perPage: Int)
```


# GetTransationQueryParams
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/gettransationqueryparams

Swift Structure

**Structure**

```swift theme={null}
struct GetTransationQueryParams
```

## Initializers

### init(walletLocator:transactionId:)

```swift theme={null}
init(walletLocator: WalletLocator, transactionId: String)
```


# LogoutRequest
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/logoutrequest

Swift Structure

**Structure**

```swift theme={null}
struct LogoutRequest
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```


# MessageSignatureResponse
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/messagesignatureresponse

Swift Structure

**Structure**

```swift theme={null}
struct MessageSignatureResponse
```

## Structures

### MessageSignatureResponse.MessageParams

```swift theme={null}
struct MessageParams
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

## Instance Properties

### approvals

Inherited from `SignatureApiModel.approvals`.

```swift theme={null}
let approvals: Approvals
```

### chainType

Inherited from `SignatureApiModel.chainType`.

```swift theme={null}
let chainType: String?
```

### createdAt

Inherited from `SignatureApiModel.createdAt`.

```swift theme={null}
let createdAt: Date
```

### id

Inherited from `SignatureApiModel.id`.

```swift theme={null}
let id: String
```

### params

```swift theme={null}
let params: MessageParams
```

### status

Inherited from `SignatureApiModel.status`.

```swift theme={null}
let status: String
```

### type

Inherited from `SignatureApiModel.type`.

```swift theme={null}
let type: String
```

### walletType

Inherited from `SignatureApiModel.walletType`.

```swift theme={null}
let walletType: String?
```


# NFT
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/nft

Swift Structure

**Structure**

```swift theme={null}
struct NFT
```

## Structures

### NFT.Locator

```swift theme={null}
struct Locator
```

### NFT.Metadata

```swift theme={null}
struct Metadata
```

## Instance Properties

### chain

```swift theme={null}
let chain: Chain
```

### contractAddress

```swift theme={null}
let contractAddress: String
```

### id

Inherited from `Identifiable.id`.

```swift theme={null}
var id: String { get }
```

### locator

```swift theme={null}
var locator: Locator { get }
```

### metadata

```swift theme={null}
let metadata: Metadata
```

### tokenId

```swift theme={null}
let tokenId: String
```

### tokenStandard

```swift theme={null}
let tokenStandard: String
```


# NonCustodialSignerCallback
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/noncustodialsignercallback

Swift Structure

**Structure**

```swift theme={null}
struct NonCustodialSignerCallback
```

## Instance Properties

### otpCancelled

```swift theme={null}
let otpCancelled: () -> Void
```

### otpCode

```swift theme={null}
let otpCode: (String) -> Void
```

## Type Properties

### noOp

```swift theme={null}
static var noOp: NonCustodialSignerCallback { get }
```


# NoOpSecureStorage
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/noopsecurestorage

Swift Structure

**Structure**

```swift theme={null}
struct NoOpSecureStorage
```

## Initializers

### init()

```swift theme={null}
init()
```

## Instance Methods

### clear()

Inherited from `SecureStorage.clear()`.

```swift theme={null}
func clear()
```

### getEmail()

Inherited from `SecureStorage.getEmail()`.

```swift theme={null}
func getEmail() async throws(SecureStorageError) -> String?
```

### getJWT()

Inherited from `SecureStorage.getJWT()`.

```swift theme={null}
func getJWT() async throws(SecureStorageError) -> String?
```

### getOneTimeSecret()

Inherited from `SecureStorage.getOneTimeSecret()`.

```swift theme={null}
func getOneTimeSecret() async throws(SecureStorageError) -> String?
```

### getPrivateKey(forEmail:)

```swift theme={null}
func getPrivateKey(forEmail email: String) -> String?
```

### savePrivateKey(\_:forEmail:)

```swift theme={null}
func savePrivateKey(_ privateKey: String, forEmail email: String)
```

### storeEmail(\_:)

Inherited from `SecureStorage.storeEmail(_:)`.

```swift theme={null}
func storeEmail(_ email: String) async throws(SecureStorageError)
```

### storeJWT(\_:)

Inherited from `SecureStorage.storeJWT(_:)`.

```swift theme={null}
func storeJWT(_ secret: String) async throws(SecureStorageError)
```

### storeOneTimeSecret(\_:)

Inherited from `SecureStorage.storeOneTimeSecret(_:)`.

```swift theme={null}
func storeOneTimeSecret(_ secret: String) async throws(SecureStorageError)
```


# NoOpSecureWalletStorage
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/noopsecurewalletstorage

Swift Structure

**Structure**

```swift theme={null}
struct NoOpSecureWalletStorage
```

## Initializers

### init()

```swift theme={null}
init()
```

## Instance Methods

### getPrivateKey(forEmail:)

Inherited from `SecureWalletStorage.getPrivateKey(forEmail:)`.

```swift theme={null}
func getPrivateKey(forEmail email: String) -> String?
```

### savePrivateKey(\_:forEmail:)

Inherited from `SecureWalletStorage.savePrivateKey(_:forEmail:)`.

```swift theme={null}
func savePrivateKey(_ privateKey: String, forEmail email: String)
```


# ParsedCredentialPublicKey
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/parsedcredentialpublickey

Swift Structure

**Structure**

```swift theme={null}
struct ParsedCredentialPublicKey
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

## Instance Properties

### algorithm

```swift theme={null}
let algorithm: String
```

### curve

```swift theme={null}
let curve: Int
```

### keyType

```swift theme={null}
let keyType: String
```

### x

```swift theme={null}
let x: String
```

### y

```swift theme={null}
let y: String
```


# ParsedPublicKeyP256
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/parsedpublickeyp256

Swift Structure

**Structure**

```swift theme={null}
struct ParsedPublicKeyP256
```

## Instance Properties

### prefix

```swift theme={null}
let prefix: String
```

### x

```swift theme={null}
let x: String
```

### y

```swift theme={null}
let y: String
```


# PasskeyAuthenticatorData
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/passkeyauthenticatordata

Swift Structure

**Structure**

```swift theme={null}
struct PasskeyAuthenticatorData
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

## Instance Properties

### aaguid

```swift theme={null}
let aaguid: String
```

### counter

```swift theme={null}
let counter: Int
```

### credentialID

```swift theme={null}
let credentialID: String
```

### credentialPublicKey

```swift theme={null}
let credentialPublicKey: String
```

### flags

```swift theme={null}
let flags: PasskeyAuthenticatorFlags
```

### parsedCredentialPublicKey

```swift theme={null}
let parsedCredentialPublicKey: ParsedCredentialPublicKey
```

### rpIdHash

```swift theme={null}
let rpIdHash: String
```


# PasskeyAuthenticatorFlags
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/passkeyauthenticatorflags

Swift Structure

**Structure**

```swift theme={null}
struct PasskeyAuthenticatorFlags
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

## Instance Properties

### attestedData

```swift theme={null}
let attestedData: Bool
```

### backupEligible

```swift theme={null}
let backupEligible: Bool
```

### backupStatus

```swift theme={null}
let backupStatus: Bool
```

### extensionData

```swift theme={null}
let extensionData: Bool
```

### userPresent

```swift theme={null}
let userPresent: Bool
```

### userVerified

```swift theme={null}
let userVerified: Bool
```


# PasskeyCredentialCreationOptions
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/passkeycredentialcreationoptions

Swift Structure

**Structure**

navigator.credentials.create request options

```swift theme={null}
struct PasskeyCredentialCreationOptions
```

Specification reference: [https://w3c.github.io/webauthn/#dictionary-makecredentialoptions](https://w3c.github.io/webauthn/#dictionary-makecredentialoptions)

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

### init(rp:user:challenge:pubKeyCredParams:timeout:excludeCredentials:authenticatorSelection:attestation:extensions:)

```swift theme={null}
init(rp: PublicKeyCredentialRpEntity, user: PublicKeyCredentialUserEntity, challenge: Base64URLString, pubKeyCredParams: [PublicKeyCredentialParameters], timeout: Int? = nil, excludeCredentials: [PublicKeyCredentialDescriptor]? = nil, authenticatorSelection: AuthenticatorSelectionCriteria? = nil, attestation: AttestationConveyancePreference? = nil, extensions: AuthenticationExtensionsClientInputs? = nil)
```


# PasskeyCredentialRequestOptions
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/passkeycredentialrequestoptions

Swift Structure

**Structure**

navigator.credentials.get request options

```swift theme={null}
struct PasskeyCredentialRequestOptions
```

Specification reference: [https://w3c.github.io/webauthn/#dictionary-assertion-options](https://w3c.github.io/webauthn/#dictionary-assertion-options)

## Initializers

### init(challenge:rpId:timeout:allowCredentials:userVerification:extensions:)

```swift theme={null}
init(challenge: Data, rpId: String, timeout: Int? = 60000, allowCredentials: [PublicKeyCredentialDescriptor]? = nil, userVerification: UserVerificationRequirement? = nil, extensions: AuthenticationExtensionsClientInputs? = nil)
```

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```


# PasskeyError
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/passkeyerror

Swift Structure

**Structure**

```swift theme={null}
struct PasskeyError
```


# PasskeySignerData
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/passkeysignerdata

Swift Structure

**Structure**

```swift theme={null}
struct PasskeySignerData
```

## Structures

### PasskeySignerData.PublicKey

```swift theme={null}
struct PublicKey
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: Decoder) throws
```

### init(id:name:publicKey:validatorContractVersion:)

```swift theme={null}
init(id: String, name: String, publicKey: PublicKey, validatorContractVersion: String? = nil)
```

## Instance Properties

### id

```swift theme={null}
let id: String
```

### locatorId

Inherited from `AdminSignerData.locatorId`.

```swift theme={null}
var locatorId: String { get }
```

### name

```swift theme={null}
let name: String
```

### publicKey

```swift theme={null}
let publicKey: PublicKey
```

### type

Inherited from `AdminSignerData.type`.

```swift theme={null}
var type: AdminSignerDataType { get }
```

### validatorContractVersion

```swift theme={null}
let validatorContractVersion: String?
```

## Instance Methods

### encode(to:)

Inherited from `Encodable.encode(to:)`.

```swift theme={null}
nonisolated func encode(to encoder: Encoder) throws
```


# PhoneSignerApiModel
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/phonesignerapimodel

Swift Structure

**Structure**

```swift theme={null}
struct PhoneSignerApiModel
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

## Instance Properties

### locator

```swift theme={null}
let locator: String
```

### phone

```swift theme={null}
let phone: String
```

### toDomain

Inherited from `AdminSignerApiModel.toDomain`.

```swift theme={null}
var toDomain: any AdminSignerData { get }
```

### type

Inherited from `AdminSignerApiModel.type`.

```swift theme={null}
let type: AdminSignerDataType
```


# PhoneSignerData
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/phonesignerdata

Swift Structure

**Structure**

```swift theme={null}
struct PhoneSignerData
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: Decoder) throws
```

### init(phone:)

```swift theme={null}
init(phone: String)
```

## Instance Properties

### locatorId

Inherited from `AdminSignerData.locatorId`.

```swift theme={null}
var locatorId: String { get }
```

### phone

```swift theme={null}
let phone: String
```

### type

Inherited from `AdminSignerData.type`.

```swift theme={null}
var type: AdminSignerDataType { get }
```

## Instance Methods

### encode(to:)

Inherited from `Encodable.encode(to:)`.

```swift theme={null}
nonisolated func encode(to encoder: Encoder) throws
```


# PublicKeyCredentialDescriptor
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/publickeycredentialdescriptor

Swift Structure

**Structure**

Specification reference: [https://w3c.github.io/webauthn/#dictdef-publickeycredentialdescriptor](https://w3c.github.io/webauthn/#dictdef-publickeycredentialdescriptor)

```swift theme={null}
struct PublicKeyCredentialDescriptor
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

### init(id:transports:type:)

```swift theme={null}
init(id: String, transports: [AuthenticatorTransport]? = nil, type: PublicKeyCredentialType)
```

## Enumerations

### PublicKeyCredentialDescriptor.Error

```swift theme={null}
enum Error
```


# PublicKeyCredentialParameters
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/publickeycredentialparameters

Swift Structure

**Structure**

Specification reference: [https://w3c.github.io/webauthn/#dictionary-credential-params](https://w3c.github.io/webauthn/#dictionary-credential-params)

```swift theme={null}
struct PublicKeyCredentialParameters
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

### init(type:alg:)

```swift theme={null}
init(type: String, alg: Int)
```


# PublicKeyCredentialRpEntity
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/publickeycredentialrpentity

Swift Structure

**Structure**

Specification reference: [https://w3c.github.io/webauthn/#dictionary-rp-credential-params](https://w3c.github.io/webauthn/#dictionary-rp-credential-params)

```swift theme={null}
struct PublicKeyCredentialRpEntity
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

### init(name:)

```swift theme={null}
init(name: String)
```

### init(name:id:)

```swift theme={null}
init(name: String, id: String? = nil)
```


# PublicKeyCredentialUserEntity
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/publickeycredentialuserentity

Swift Structure

**Structure**

Specification reference: [https://w3c.github.io/webauthn/#dictdef-publickeycredentialuserentity](https://w3c.github.io/webauthn/#dictdef-publickeycredentialuserentity)

```swift theme={null}
struct PublicKeyCredentialUserEntity
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

### init(name:)

```swift theme={null}
init(name: String)
```

### init(name:displayName:id:)

```swift theme={null}
init(name: String, displayName: String, id: String)
```


# RefreshJWTRequest
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/refreshjwtrequest

Swift Structure

**Structure**

```swift theme={null}
struct RefreshJWTRequest
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```


# RefreshJWTResponse
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/refreshjwtresponse

Swift Structure

**Structure**

```swift theme={null}
struct RefreshJWTResponse
```

## Structures

### RefreshJWTResponse.RefreshToken

```swift theme={null}
struct RefreshToken
```

### RefreshJWTResponse.User

```swift theme={null}
struct User
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```


# RegistrationResponseJSON
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/registrationresponsejson

Swift Structure

**Structure**

Specification reference: [https://w3c.github.io/webauthn/#dictdef-registrationresponsejson](https://w3c.github.io/webauthn/#dictdef-registrationresponsejson)

```swift theme={null}
struct RegistrationResponseJSON
```

## Instance Properties

### authenticatorAttachment

```swift theme={null}
var authenticatorAttachment: AuthenticatorAttachment?
```

### clientExtensionResults

```swift theme={null}
var clientExtensionResults: AuthenticationExtensionsClientOutputsJSON?
```

### id

```swift theme={null}
var id: Data
```

### rawId

```swift theme={null}
var rawId: Data
```

### response

```swift theme={null}
var response: AuthenticatorAttestationResponseJSON
```

### type

```swift theme={null}
var type: PublicKeyCredentialType
```


# SignerApiModel
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/signerapimodel

Swift Structure

**Structure**

```swift theme={null}
struct SignerApiModel
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

## Instance Properties

### locator

```swift theme={null}
let locator: String
```


# SignMessageRequest
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/signmessagerequest

Swift Structure

**Structure**

```swift theme={null}
struct SignMessageRequest
```

## Structures

### SignMessageRequest.Params

```swift theme={null}
struct Params
```

## Initializers

### init(params:)

```swift theme={null}
init(params: Params)
```

## Instance Properties

### params

```swift theme={null}
let params: Params
```

### type

```swift theme={null}
let type: String
```


# SignRequest
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/signrequest

Swift Structure

**Structure**

```swift theme={null}
struct SignRequest
```


# SignRequestApi
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/signrequestapi

Swift Structure

**Structure**

```swift theme={null}
struct SignRequestApi
```

## Initializers

### init(approvals:)

```swift theme={null}
init(approvals: [Approval])
```

## Instance Properties

### approvals

```swift theme={null}
let approvals: [Approval]
```

## Enumerations

### SignRequestApi.Approval

```swift theme={null}
enum Approval
```


# SignTypedDataRequest
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/signtypeddatarequest

Swift Structure

**Structure**

```swift theme={null}
struct SignTypedDataRequest
```

## Structures

### SignTypedDataRequest.Params

```swift theme={null}
struct Params
```

### SignTypedDataRequest.TypedData

```swift theme={null}
struct TypedData
```

## Initializers

### init(params:)

```swift theme={null}
init(params: Params)
```

## Instance Properties

### params

```swift theme={null}
let params: Params
```

### type

```swift theme={null}
let type: String
```


# SmartWalletConfigRequest
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/smartwalletconfigrequest

Swift Structure

**Structure**

```swift theme={null}
struct SmartWalletConfigRequest
```

## Initializers

### init(chain:)

```swift theme={null}
init(chain: Chain)
```

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```


# SolanaAddress
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/solanaaddress

Swift Structure

**Structure**

```swift theme={null}
struct SolanaAddress
```

## Initializers

### init(address:)

Inherited from `BlockchainAddress.init(address:)`.

```swift theme={null}
init(address: String) throws(BlockchainAddressError)
```

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

## Instance Properties

### address

```swift theme={null}
var address: String { get }
```

### description

Inherited from `CustomStringConvertible.description`.

```swift theme={null}
var description: String { get }
```

### publicKey

```swift theme={null}
var publicKey: String { get }
```

## Instance Methods

### encode(to:)

Inherited from `Encodable.encode(to:)`.

```swift theme={null}
func encode(to encoder: Encoder) throws
```


# SolanaTransactionApiModel
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/solanatransactionapimodel

Swift Structure

**Structure**

```swift theme={null}
struct SolanaTransactionApiModel
```

## Structures

### SolanaTransactionApiModel.FeeConfig

```swift theme={null}
struct FeeConfig
```

### SolanaTransactionApiModel.OnChainData

```swift theme={null}
struct OnChainData
```

### SolanaTransactionApiModel.Params

```swift theme={null}
struct Params
```

### SolanaTransactionApiModel.SendParams

```swift theme={null}
struct SendParams
```

### SolanaTransactionApiModel.SolanaApprovalEntry

```swift theme={null}
struct SolanaApprovalEntry
```

### SolanaTransactionApiModel.SolanaApprovals

```swift theme={null}
struct SolanaApprovals
```

### SolanaTransactionApiModel.SolanaSubmittedApprovalEntry

```swift theme={null}
struct SolanaSubmittedApprovalEntry
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

## Instance Properties

### approvals

```swift theme={null}
let approvals: SolanaApprovals?
```

### chainType

```swift theme={null}
let chainType: String?
```

### createdAt

```swift theme={null}
let createdAt: Date
```

### error

```swift theme={null}
let error: TransactionErrorApiModel?
```

### id

Inherited from `Identifiable.id`.

```swift theme={null}
let id: String
```

### onChain

```swift theme={null}
let onChain: OnChainData
```

### params

```swift theme={null}
let params: Params
```

### sendParams

```swift theme={null}
let sendParams: SendParams?
```

### status

```swift theme={null}
let status: TransactionStatusApiModel
```

### walletType

```swift theme={null}
let walletType: WalletType
```

## Instance Methods

### toDomain(withService:)

Inherited from `TransactionApiModel.toDomain(withService:)`.

```swift theme={null}
func toDomain(withService service: SmartWalletService) -> Transaction?
```


# StellarAddress
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/stellaraddress

Swift Structure

**Structure**

```swift theme={null}
struct StellarAddress
```

## Initializers

### init(address:)

Inherited from `BlockchainAddress.init(address:)`.

```swift theme={null}
init(address: String) throws(BlockchainAddressError)
```

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

## Instance Properties

### address

```swift theme={null}
var address: String { get }
```

### description

Inherited from `CustomStringConvertible.description`.

```swift theme={null}
var description: String { get }
```

## Instance Methods

### encode(to:)

Inherited from `Encodable.encode(to:)`.

```swift theme={null}
func encode(to encoder: Encoder) throws
```


# StellarTransactionApiModel
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/stellartransactionapimodel

Swift Structure

**Structure**

```swift theme={null}
struct StellarTransactionApiModel
```

## Structures

### StellarTransactionApiModel.FeeConfig

```swift theme={null}
struct FeeConfig
```

### StellarTransactionApiModel.OnChainData

```swift theme={null}
struct OnChainData
```

### StellarTransactionApiModel.Params

```swift theme={null}
struct Params
```

### StellarTransactionApiModel.SendParams

```swift theme={null}
struct SendParams
```

### StellarTransactionApiModel.StellarApprovalEntry

```swift theme={null}
struct StellarApprovalEntry
```

### StellarTransactionApiModel.StellarApprovals

```swift theme={null}
struct StellarApprovals
```

### StellarTransactionApiModel.StellarSubmittedApprovalEntry

```swift theme={null}
struct StellarSubmittedApprovalEntry
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

## Instance Properties

### approvals

```swift theme={null}
let approvals: StellarApprovals?
```

### chainType

```swift theme={null}
let chainType: String?
```

### createdAt

```swift theme={null}
let createdAt: Date
```

### error

```swift theme={null}
let error: TransactionErrorApiModel?
```

### id

Inherited from `Identifiable.id`.

```swift theme={null}
let id: String
```

### onChain

```swift theme={null}
let onChain: OnChainData
```

### params

```swift theme={null}
let params: Params
```

### sendParams

```swift theme={null}
let sendParams: SendParams?
```

### status

```swift theme={null}
let status: TransactionStatusApiModel
```

### walletType

```swift theme={null}
let walletType: WalletType
```

## Instance Methods

### toDomain(withService:)

Inherited from `TransactionApiModel.toDomain(withService:)`.

```swift theme={null}
func toDomain(withService service: SmartWalletService) -> Transaction?
```


# SubmittedApprovalEntry
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/submittedapprovalentry

Swift Structure

**Structure**

```swift theme={null}
struct SubmittedApprovalEntry
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```


# TokenBalance
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/tokenbalance

Swift Structure

**Structure**

```swift theme={null}
struct TokenBalance
```

## Initializers

### init(symbol:name:amount:contractAddress:decimals:rawAmount:)

```swift theme={null}
init(symbol: Symbol, name: String, amount: String, contractAddress: String? = nil, decimals: Int? = nil, rawAmount: String? = nil)
```

## Instance Properties

### amount

```swift theme={null}
let amount: String
```

### contractAddress

```swift theme={null}
let contractAddress: String?
```

### decimals

```swift theme={null}
let decimals: Int?
```

### name

```swift theme={null}
let name: String
```

### rawAmount

```swift theme={null}
let rawAmount: String?
```

### symbol

```swift theme={null}
let symbol: Symbol
```

### token

```swift theme={null}
var token: CryptoCurrency { get }
```

## Enumerations

### TokenBalance.Symbol

```swift theme={null}
enum Symbol
```


# TokenLinkOptions
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/tokenlinkoptions

Swift Structure

**Structure**

```swift theme={null}
struct TokenLinkOptions
```

## Instance Properties

### isCompressed

```swift theme={null}
let isCompressed: Bool?
```


# Transaction
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/transaction

Swift Structure

**Structure**

```swift theme={null}
struct Transaction
```

## Structures

### Transaction.Approvals

```swift theme={null}
struct Approvals
```

### Transaction.Call

```swift theme={null}
struct Call
```

### Transaction.Error

```swift theme={null}
struct Error
```

### Transaction.FeeConfig

```swift theme={null}
struct FeeConfig
```

### Transaction.OnChainData

```swift theme={null}
struct OnChainData
```

### Transaction.Params

```swift theme={null}
struct Params
```

### Transaction.UserOperation

```swift theme={null}
struct UserOperation
```

## Initializers

### init(smartWalletService:id:status:onChain:params:walletType:createdAt:approvals:error:)

```swift theme={null}
init(smartWalletService: SmartWalletService, id: String, status: Status, onChain: OnChainData, params: Params, walletType: WalletType, createdAt: Date, approvals: Approvals?, error: Error?)
```

## Instance Properties

### approvals

```swift theme={null}
let approvals: Approvals?
```

### createdAt

```swift theme={null}
let createdAt: Date
```

### description

Inherited from `CustomStringConvertible.description`.

```swift theme={null}
var description: String { get }
```

### error

```swift theme={null}
let error: Error?
```

### id

```swift theme={null}
let id: String
```

### onChain

```swift theme={null}
let onChain: OnChainData
```

### params

```swift theme={null}
let params: Params
```

### status

```swift theme={null}
let status: Status
```

### walletType

```swift theme={null}
let walletType: WalletType
```

## Enumerations

### Transaction.Status

```swift theme={null}
enum Status
```


# TransactionErrorApiModel
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/transactionerrorapimodel

Swift Structure

**Structure**

```swift theme={null}
struct TransactionErrorApiModel
```

## Structures

### TransactionErrorApiModel.Revert

```swift theme={null}
struct Revert
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

## Instance Properties

### message

```swift theme={null}
let message: String
```

### reason

```swift theme={null}
let reason: String
```

### revert

```swift theme={null}
let revert: Revert?
```


# TransactionSummary
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/transactionsummary

Swift Structure

**Structure**

```swift theme={null}
struct TransactionSummary
```

## Instance Properties

### explorerLink

```swift theme={null}
let explorerLink: URL
```

### hash

```swift theme={null}
let hash: String
```

### transactionID

```swift theme={null}
let transactionID: String
```


# TransferTokenRequest
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/transfertokenrequest

Swift Structure

**Structure**

```swift theme={null}
struct TransferTokenRequest
```


# TypedDataSignatureResponse
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/typeddatasignatureresponse

Swift Structure

**Structure**

```swift theme={null}
struct TypedDataSignatureResponse
```

## Structures

### TypedDataSignatureResponse.TypedDataParams

```swift theme={null}
struct TypedDataParams
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

## Instance Properties

### approvals

Inherited from `SignatureApiModel.approvals`.

```swift theme={null}
let approvals: Approvals
```

### chainType

Inherited from `SignatureApiModel.chainType`.

```swift theme={null}
let chainType: String?
```

### createdAt

Inherited from `SignatureApiModel.createdAt`.

```swift theme={null}
let createdAt: Date
```

### id

Inherited from `SignatureApiModel.id`.

```swift theme={null}
let id: String
```

### params

```swift theme={null}
let params: TypedDataParams
```

### status

Inherited from `SignatureApiModel.status`.

```swift theme={null}
let status: String
```

### type

Inherited from `SignatureApiModel.type`.

```swift theme={null}
let type: String
```

### walletType

Inherited from `SignatureApiModel.walletType`.

```swift theme={null}
let walletType: String?
```


# UnknownApiTransaction
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/unknownapitransaction

Swift Structure

**Structure**

```swift theme={null}
struct UnknownApiTransaction
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

## Instance Properties

### id

Inherited from `Identifiable.id`.

```swift theme={null}
var id: String
```

## Instance Methods

### toDomain(withService:)

Inherited from `TransactionApiModel.toDomain(withService:)`.

```swift theme={null}
func toDomain(withService service: any SmartWalletService) -> Transaction?
```


# ValidateEmailRequest
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/validateemailrequest

Swift Structure

**Structure**

```swift theme={null}
struct ValidateEmailRequest
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```


# ValidateEmailResponse
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/validateemailresponse

Swift Structure

**Structure**

```swift theme={null}
struct ValidateEmailResponse
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```


# ValidateTokenRequest
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/validatetokenrequest

Swift Structure

**Structure**

```swift theme={null}
struct ValidateTokenRequest
```


# ValidateTokenResponse
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/validatetokenresponse

Swift Structure

**Structure**

```swift theme={null}
struct ValidateTokenResponse
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```


# WalletApiModel
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/walletapimodel

Swift Structure

**Structure**

```swift theme={null}
struct WalletApiModel
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: any Decoder) throws
```

## Instance Properties

### address

```swift theme={null}
let address: String
```

### chainType

```swift theme={null}
let chainType: ChainType
```

### config

```swift theme={null}
let config: WalletConfigApiModel
```

### createdAt

```swift theme={null}
let createdAt: Date
```

### owner

```swift theme={null}
let owner: Owner?
```

### type

```swift theme={null}
let type: WalletType
```


# WalletConfig
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/walletconfig

Swift Structure

**Structure**

```swift theme={null}
struct WalletConfig
```

## Instance Properties

### adminSigner

```swift theme={null}
let adminSigner: AdminSignerData
```


# WalletConfigApiModel
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/walletconfigapimodel

Swift Structure

**Structure**

```swift theme={null}
struct WalletConfigApiModel
```

## Initializers

### init(from:)

Inherited from `Decodable.init(from:)`.

```swift theme={null}
init(from decoder: Decoder) throws
```

## Instance Properties

### adminSigner

```swift theme={null}
let adminSigner: AdminSignerApiModel
```


# WalletOptions
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/structs/walletoptions

Swift Structure

**Structure**

```swift theme={null}
struct WalletOptions
```


# Base64URLString
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/type-aliases/base64urlstring

Swift Type Alias

**Type Alias**

```swift theme={null}
typealias Base64URLString = String
```


# PublicKeyCredentialJSON
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/type-aliases/publickeycredentialjson

Swift Type Alias

**Type Alias**

Specification reference: [https://w3c.github.io/webauthn/#typedefdef-publickeycredentialjson](https://w3c.github.io/webauthn/#typedefdef-publickeycredentialjson)

```swift theme={null}
typealias PublicKeyCredentialJSON = Either<RegistrationResponseJSON, AuthenticationResponseJSON>
```


# Secp256k1PrivateKey
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/type-aliases/secp256k1privatekey

Swift Type Alias

**Type Alias**

```swift theme={null}
typealias Secp256k1PrivateKey = secp256k1.Signing.PrivateKey
```


# Secp256k1PublicKey
Source: https://docs.crossmint.com/sdk-reference/wallets/swift/type-aliases/secp256k1publickey

Swift Type Alias

**Type Alias**

```swift theme={null}
typealias Secp256k1PublicKey = secp256k1.Signing.PublicKey
```


# CrossmintWallets
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/classes/CrossmintWallets



Defined in: [packages/wallets/src/sdk.ts:9](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/sdk.ts#L9)

## Methods

### createWallet()

> **createWallet**\<`C`>(`options`): `Promise`\<[`Wallet`](./Wallet)\<`C`>>

Defined in: [packages/wallets/src/sdk.ts:54](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/sdk.ts#L54)

Create a new wallet, can only be called on the server side

#### Type Parameters

| Type Parameter                                 |
| ---------------------------------------------- |
| `C` *extends* [`Chain`](../type-aliases/Chain) |

#### Parameters

| Parameter | Type                                                   | Description    |
| --------- | ------------------------------------------------------ | -------------- |
| `options` | [`WalletArgsFor`](../type-aliases/WalletArgsFor)\<`C`> | Wallet options |

#### Returns

`Promise`\<[`Wallet`](./Wallet)\<`C`>>

A new wallet

***

### getOrCreateWallet()

> **getOrCreateWallet**\<`C`>(`options`): `Promise`\<[`Wallet`](./Wallet)\<`C`>>

Defined in: [packages/wallets/src/sdk.ts:35](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/sdk.ts#L35)

Get or create a wallet, can only be called on the client side

#### Type Parameters

| Type Parameter                                 |
| ---------------------------------------------- |
| `C` *extends* [`Chain`](../type-aliases/Chain) |

#### Parameters

| Parameter | Type                                                   | Description    |
| --------- | ------------------------------------------------------ | -------------- |
| `options` | [`WalletArgsFor`](../type-aliases/WalletArgsFor)\<`C`> | Wallet options |

#### Returns

`Promise`\<[`Wallet`](./Wallet)\<`C`>>

An existing wallet or a new wallet

***

### getWallet()

> **getWallet**\<`C`>(`walletLocator`, `options`): `Promise`\<[`Wallet`](./Wallet)\<`C`>>

Defined in: [packages/wallets/src/sdk.ts:45](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/sdk.ts#L45)

Get an existing wallet by its locator, can only be called on the server side

#### Type Parameters

| Type Parameter                                 |
| ---------------------------------------------- |
| `C` *extends* [`Chain`](../type-aliases/Chain) |

#### Parameters

| Parameter       | Type                                                   | Description    |
| --------------- | ------------------------------------------------------ | -------------- |
| `walletLocator` | `string`                                               | Wallet locator |
| `options`       | [`WalletArgsFor`](../type-aliases/WalletArgsFor)\<`C`> | Wallet options |

#### Returns

`Promise`\<[`Wallet`](./Wallet)\<`C`>>

A wallet if found, throws WalletNotAvailableError if not found

***

### from()

> `static` **from**(`crossmint`): `CrossmintWallets`

Defined in: [packages/wallets/src/sdk.ts:25](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/sdk.ts#L25)

Initialize the Wallets SDK

#### Parameters

| Parameter   | Type        | Description                                          |
| ----------- | ----------- | ---------------------------------------------------- |
| `crossmint` | `Crossmint` | Crossmint data (use `createCrossmint` to initialize) |

#### Returns

`CrossmintWallets`

A new CrossmintWallets instance


# EVMWallet
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/classes/EVMWallet



Defined in: [packages/wallets/src/wallets/evm.ts:20](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/evm.ts#L20)

## Extends

* [`Wallet`](./Wallet)\<[`EVMChain`](../type-aliases/EVMChain)>

## Constructors

### new EVMWallet()

> **new EVMWallet**(`wallet`): `EVMWallet`

Defined in: [packages/wallets/src/wallets/evm.ts:21](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/evm.ts#L21)

#### Parameters

| Parameter | Type                                         |
| --------- | -------------------------------------------- |
| `wallet`  | [`Wallet`](./Wallet)\<`EVMSmartWalletChain`> |

#### Returns

`EVMWallet`

#### Overrides

[`Wallet`](./Wallet).[`constructor`](./Wallet#constructor)

## Properties

| Property        | Type                             | Inherited from                                     | Defined in                                                                                                                                   |
| --------------- | -------------------------------- | -------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| <a /> `address` | `string`                         | [`Wallet`](./Wallet).[`address`](./Wallet#address) | [packages/wallets/src/wallets/wallet.ts:62](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L62) |
| <a /> `alias?`  | `string`                         | [`Wallet`](./Wallet).[`alias`](./Wallet#alias)     | [packages/wallets/src/wallets/wallet.ts:64](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L64) |
| <a /> `chain`   | `EVMSmartWalletChain`            | [`Wallet`](./Wallet).[`chain`](./Wallet#chain)     | [packages/wallets/src/wallets/wallet.ts:61](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L61) |
| <a /> `owner?`  | `string`                         | [`Wallet`](./Wallet).[`owner`](./Wallet#owner)     | [packages/wallets/src/wallets/wallet.ts:63](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L63) |
| <a /> `signer`  | [`Signer`](../interfaces/Signer) | [`Wallet`](./Wallet).[`signer`](./Wallet#signer)   | [packages/wallets/src/wallets/wallet.ts:65](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L65) |

## Methods

### addDelegatedSigner()

> **addDelegatedSigner**\<`T`>(`params`): `Promise`\<`T` *extends* `PrepareOnly`\<`true`> ? `object` : `void`>

Defined in: [packages/wallets/src/wallets/wallet.ts:465](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L465)

Add a delegated signer to the wallet

#### Type Parameters

| Type Parameter                                           | Default type |
| -------------------------------------------------------- | ------------ |
| `T` *extends* `AddDelegatedSignerOptions` \| `undefined` | `undefined`  |

#### Parameters

| Parameter         | Type                                                                                                                                                     |
| ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `params`          | \{ `options`: `T`; `signer`: `string` \| \{ `id`: `string`; `name`: `string`; `publicKey`: \{ `x`: `string`; `y`: `string`; }; `type`: `"passkey"`; }; } |
| `params.options`? | `T`                                                                                                                                                      |
| `params.signer`   | `string` \| \{ `id`: `string`; `name`: `string`; `publicKey`: \{ `x`: `string`; `y`: `string`; }; `type`: `"passkey"`; }                                 |

#### Returns

`Promise`\<`T` *extends* `PrepareOnly`\<`true`> ? `object` : `void`>

#### Inherited from

[`Wallet`](./Wallet).[`addDelegatedSigner`](./Wallet#adddelegatedsigner)

***

### approve()

> **approve**\<`T`>(`params`): `Promise`\<`ApproveResult`\<`T`>>

Defined in: [packages/wallets/src/wallets/wallet.ts:423](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L423)

Approve a transaction or signature

#### Type Parameters

| Type Parameter                |
| ----------------------------- |
| `T` *extends* `ApproveParams` |

#### Parameters

| Parameter | Type | Description    |
| --------- | ---- | -------------- |
| `params`  | `T`  | The parameters |

#### Returns

`Promise`\<`ApproveResult`\<`T`>>

The transaction or signature

#### Inherited from

[`Wallet`](./Wallet).[`approve`](./Wallet#approve)

***

### ~~approveTransaction()~~

> **approveTransaction**(`params`): `Promise`\<`Error`>

Defined in: [packages/wallets/src/wallets/wallet.ts:399](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L399)

#### Parameters

| Parameter | Type            | Description    |
| --------- | --------------- | -------------- |
| `params`  | `ApproveParams` | The parameters |

#### Returns

`Promise`\<`Error`>

The transaction

#### Deprecated

Use `approve` instead.
Approve a transaction

#### Inherited from

[`Wallet`](./Wallet).[`approveTransaction`](./Wallet#approvetransaction)

***

### balances()

> **balances**(`tokens`?): `Promise`\<[`Balances`](../type-aliases/Balances)\<`EVMSmartWalletChain`>>

Defined in: [packages/wallets/src/wallets/wallet.ts:118](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L118)

Get the wallet balances - always includes USDC and native token (ETH/SOL)

#### Parameters

| Parameter | Type        | Description                                                                        |
| --------- | ----------- | ---------------------------------------------------------------------------------- |
| `tokens`? | `string`\[] | Additional tokens to request (optional: native token and usdc are always included) |

#### Returns

`Promise`\<[`Balances`](../type-aliases/Balances)\<`EVMSmartWalletChain`>>

The balances returns nativeToken, usdc, tokens

#### Throws

If the balances cannot be retrieved

#### Inherited from

[`Wallet`](./Wallet).[`balances`](./Wallet#balances)

***

### delegatedSigners()

> **delegatedSigners**(): `Promise`\<[`DelegatedSigner`](../type-aliases/DelegatedSigner)\[]>

Defined in: [packages/wallets/src/wallets/wallet.ts:554](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L554)

List the delegated signers for this wallet.

#### Returns

`Promise`\<[`DelegatedSigner`](../type-aliases/DelegatedSigner)\[]>

The delegated signers

#### Inherited from

[`Wallet`](./Wallet).[`delegatedSigners`](./Wallet#delegatedsigners)

***

### experimental\_activity()

> **experimental\_activity**(): `Promise`\<`WalletsV1Alpha2ActivityResponseDto`>

Defined in: [packages/wallets/src/wallets/wallet.ts:312](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L312)

**`Experimental`**

Get the wallet activity

#### Returns

`Promise`\<`WalletsV1Alpha2ActivityResponseDto`>

The activity
This API is experimental and may change in the future

#### Throws

If the activity cannot be retrieved

#### Inherited from

[`Wallet`](./Wallet).[`experimental_activity`](./Wallet#experimental_activity)

***

### experimental\_apiClient()

> **experimental\_apiClient**(): [`WalletsApiClient`](./WalletsApiClient)

Defined in: [packages/wallets/src/wallets/wallet.ts:101](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L101)

**`Experimental`**

Get the API client

#### Returns

[`WalletsApiClient`](./WalletsApiClient)

The API client
This API is experimental and may change in the future

#### Inherited from

[`Wallet`](./Wallet).[`experimental_apiClient`](./Wallet#experimental_apiclient)

***

### experimental\_nfts()

> **experimental\_nfts**(`params`): `Promise`\<`WalletNftsResponseDto`>

Defined in: [packages/wallets/src/wallets/wallet.ts:272](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L272)

**`Experimental`**

Get the wallet NFTs

#### Parameters

| Parameter        | Type                                        | Description                 |
| ---------------- | ------------------------------------------- | --------------------------- |
| `params`         | \{ `page`: `number`; `perPage`: `number`; } | The parameters              |
| `params.page`    | `number`                                    | The page number             |
| `params.perPage` | `number`                                    | The number of NFTs per page |

#### Returns

`Promise`\<`WalletNftsResponseDto`>

The NFTs
This API is experimental and may change in the future

#### Inherited from

[`Wallet`](./Wallet).[`experimental_nfts`](./Wallet#experimental_nfts)

***

### experimental\_transaction()

> **experimental\_transaction**(`transactionId`): `Promise`\<`WalletsTransactionV2025ResponseDto`>

Defined in: [packages/wallets/src/wallets/wallet.ts:298](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L298)

Get a transaction by id

#### Parameters

| Parameter       | Type     |
| --------------- | -------- |
| `transactionId` | `string` |

#### Returns

`Promise`\<`WalletsTransactionV2025ResponseDto`>

The transaction

#### Throws

If the transaction cannot be retrieved

#### Inherited from

[`Wallet`](./Wallet).[`experimental_transaction`](./Wallet#experimental_transaction)

***

### experimental\_transactions()

> **experimental\_transactions**(): `Promise`\<`GetTransactionsResponse`>

Defined in: [packages/wallets/src/wallets/wallet.ts:285](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L285)

Get the wallet transactions

#### Returns

`Promise`\<`GetTransactionsResponse`>

The transactions

#### Throws

If the transactions cannot be retrieved

#### Inherited from

[`Wallet`](./Wallet).[`experimental_transactions`](./Wallet#experimental_transactions)

***

### getViemClient()

> **getViemClient**(`params`?): `object`

Defined in: [packages/wallets/src/wallets/evm.ts:203](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/evm.ts#L203)

Get a Viem public client instance configured for this wallet's chain.

#### Parameters

| Parameter           | Type                               | Description                      |
| ------------------- | ---------------------------------- | -------------------------------- |
| `params`?           | \{ `transport`: `HttpTransport`; } | Optional transport configuration |
| `params.transport`? | `HttpTransport`                    | -                                |

#### Returns

`object`

A Viem public client

##### account

> **account**: `undefined`

The Account of the Client.

##### batch?

> `optional` **batch**: `object`

Flags for batch settings.

###### batch.multicall?

> `optional` **multicall**: `boolean` | \{ `batchSize`: `number`; `wait`: `number`; }

Toggle to enable `eth_call` multicall aggregation.

###### Type Declaration

`boolean`

\{ `batchSize`: `number`; `wait`: `number`; }

##### cacheTime

> **cacheTime**: `number`

Time (in ms) that cached data will remain in memory.

##### call()

> **call**: (`parameters`) => `Promise`\<`CallReturnType`>

Executes a new message call immediately without submitting a transaction to the network.

* Docs: [https://viem.sh/docs/actions/public/call](https://viem.sh/docs/actions/public/call)
* JSON-RPC Methods: [`eth_call`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_call)

###### Parameters

| Parameter    | Type                       |
| ------------ | -------------------------- |
| `parameters` | `CallParameters`\<`Chain`> |

###### Returns

`Promise`\<`CallReturnType`>

The call data. CallReturnType

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const data = await client.call({
  account: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
  data: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
  to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
})
```

##### ccipRead?

> `optional` **ccipRead**: `false` | \{ `request`: (`parameters`) => `Promise`\<`` `0x${string}` ``>; }

[CCIP Read](https://eips.ethereum.org/EIPS/eip-3668) configuration.

###### Type Declaration

`false`

\{ `request`: (`parameters`) => `Promise`\<`` `0x${string}` ``>; }

##### chain

> **chain**: `Chain`

Chain for the client.

##### createAccessList()

> **createAccessList**: (`parameters`) => `Promise`\<\{ `accessList`: `AccessList`; `gasUsed`: `bigint`; }>

Creates an EIP-2930 access list that you can include in a transaction.

* Docs: [https://viem.sh/docs/actions/public/createAccessList](https://viem.sh/docs/actions/public/createAccessList)
* JSON-RPC Methods: `eth_createAccessList`

###### Parameters

| Parameter    | Type                                   |
| ------------ | -------------------------------------- |
| `parameters` | `CreateAccessListParameters`\<`Chain`> |

###### Returns

`Promise`\<\{ `accessList`: `AccessList`; `gasUsed`: `bigint`; }>

The call data. CreateAccessListReturnType

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})

const data = await client.createAccessList({
  data: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
  to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
})
```

##### createBlockFilter()

> **createBlockFilter**: () => `Promise`\<\{ `id`: `` `0x${string}` ``; `request`: `EIP1193RequestFn`\<readonly \[\{ `Method`: `"eth_getFilterChanges"`; `Parameters`: \[`` `0x${string}` ``]; `ReturnType`: `` `0x${string}` ``\[] | `RpcLog`\[]; }, \{ `Method`: `"eth_getFilterLogs"`; `Parameters`: \[`` `0x${string}` ``]; `ReturnType`: `RpcLog`\[]; }, \{ `Method`: `"eth_uninstallFilter"`; `Parameters`: \[`` `0x${string}` ``]; `ReturnType`: `boolean`; }]>; `type`: `"block"`; }>

Creates a Filter to listen for new block hashes that can be used with [`getFilterChanges`](https://viem.sh/docs/actions/public/getFilterChanges).

* Docs: [https://viem.sh/docs/actions/public/createBlockFilter](https://viem.sh/docs/actions/public/createBlockFilter)
* JSON-RPC Methods: [`eth_newBlockFilter`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_newBlockFilter)

###### Returns

`Promise`\<\{ `id`: `` `0x${string}` ``; `request`: `EIP1193RequestFn`\<readonly \[\{ `Method`: `"eth_getFilterChanges"`; `Parameters`: \[`` `0x${string}` ``]; `ReturnType`: `` `0x${string}` ``\[] | `RpcLog`\[]; }, \{ `Method`: `"eth_getFilterLogs"`; `Parameters`: \[`` `0x${string}` ``]; `ReturnType`: `RpcLog`\[]; }, \{ `Method`: `"eth_uninstallFilter"`; `Parameters`: \[`` `0x${string}` ``]; `ReturnType`: `boolean`; }]>; `type`: `"block"`; }>

Filter. CreateBlockFilterReturnType

###### Example

```ts theme={null}
import { createPublicClient, createBlockFilter, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const filter = await createBlockFilter(client)
// { id: "0x345a6572337856574a76364e457a4366", type: 'block' }
```

##### createContractEventFilter()

> **createContractEventFilter**: \<`abi`, `eventName`, `args`, `strict`, `fromBlock`, `toBlock`>(`args`) => `Promise`\<`CreateContractEventFilterReturnType`\<`abi`, `eventName`, `args`, `strict`, `fromBlock`, `toBlock`>>

Creates a Filter to retrieve event logs that can be used with [`getFilterChanges`](https://viem.sh/docs/actions/public/getFilterChanges) or [`getFilterLogs`](https://viem.sh/docs/actions/public/getFilterLogs).

* Docs: [https://viem.sh/docs/contract/createContractEventFilter](https://viem.sh/docs/contract/createContractEventFilter)

###### Type Parameters

| Type Parameter                                                                          | Default type |
| --------------------------------------------------------------------------------------- | ------------ |
| `abi` *extends* readonly `unknown`\[] \| `Abi`                                          | -            |
| `eventName` *extends* `string` \| `undefined`                                           | -            |
| `args` *extends* readonly `unknown`\[] \| `Record`\<`string`, `unknown`> \| `undefined` | -            |
| `strict` *extends* `boolean` \| `undefined`                                             | `undefined`  |
| `fromBlock` *extends* `bigint` \| `BlockTag` \| `undefined`                             | `undefined`  |
| `toBlock` *extends* `bigint` \| `BlockTag` \| `undefined`                               | `undefined`  |

###### Parameters

| Parameter | Type                                                                                                 | Description                         |
| --------- | ---------------------------------------------------------------------------------------------------- | ----------------------------------- |
| `args`    | `CreateContractEventFilterParameters`\<`abi`, `eventName`, `args`, `strict`, `fromBlock`, `toBlock`> | CreateContractEventFilterParameters |

###### Returns

`Promise`\<`CreateContractEventFilterReturnType`\<`abi`, `eventName`, `args`, `strict`, `fromBlock`, `toBlock`>>

[`Filter`](https://viem.sh/docs/glossary/types#filter). CreateContractEventFilterReturnType

###### Example

```ts theme={null}
import { createPublicClient, http, parseAbi } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const filter = await client.createContractEventFilter({
  abi: parseAbi(['event Transfer(address indexed, address indexed, uint256)']),
})
```

##### createEventFilter()

> **createEventFilter**: \<`abiEvent`, `abiEvents`, `strict`, `fromBlock`, `toBlock`, `_EventName`, `_Args`>(`args`?) => `Promise`\<\{ \[K in string | number | symbol]: Filter\<"event", abiEvents, \_EventName, \_Args, strict, fromBlock, toBlock>\[K] }>

Creates a [`Filter`](https://viem.sh/docs/glossary/types#filter) to listen for new events that can be used with [`getFilterChanges`](https://viem.sh/docs/actions/public/getFilterChanges).

* Docs: [https://viem.sh/docs/actions/public/createEventFilter](https://viem.sh/docs/actions/public/createEventFilter)
* JSON-RPC Methods: [`eth_newFilter`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_newfilter)

###### Type Parameters

| Type Parameter                                                                           | Default type                                                  |
| ---------------------------------------------------------------------------------------- | ------------------------------------------------------------- |
| `abiEvent` *extends* `AbiEvent` \| `undefined`                                           | `undefined`                                                   |
| `abiEvents` *extends* readonly `unknown`\[] \| readonly `AbiEvent`\[] \| `undefined`     | `abiEvent` *extends* `AbiEvent` ? \[`abiEvent`] : `undefined` |
| `strict` *extends* `boolean` \| `undefined`                                              | `undefined`                                                   |
| `fromBlock` *extends* `bigint` \| `BlockTag` \| `undefined`                              | `undefined`                                                   |
| `toBlock` *extends* `bigint` \| `BlockTag` \| `undefined`                                | `undefined`                                                   |
| `_EventName` *extends* `string` \| `undefined`                                           | `MaybeAbiEventName`\<`abiEvent`>                              |
| `_Args` *extends* readonly `unknown`\[] \| `Record`\<`string`, `unknown`> \| `undefined` | `undefined`                                                   |

###### Parameters

| Parameter | Type                                                                                                             | Description                 |
| --------- | ---------------------------------------------------------------------------------------------------------------- | --------------------------- |
| `args`?   | `CreateEventFilterParameters`\<`abiEvent`, `abiEvents`, `strict`, `fromBlock`, `toBlock`, `_EventName`, `_Args`> | CreateEventFilterParameters |

###### Returns

`Promise`\<\{ \[K in string | number | symbol]: Filter\<"event", abiEvents, \_EventName, \_Args, strict, fromBlock, toBlock>\[K] }>

[`Filter`](https://viem.sh/docs/glossary/types#filter). CreateEventFilterReturnType

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const filter = await client.createEventFilter({
  address: '0xfba3912ca04dd458c843e2ee08967fc04f3579c2',
})
```

##### createPendingTransactionFilter()

> **createPendingTransactionFilter**: () => `Promise`\<\{ `id`: `` `0x${string}` ``; `request`: `EIP1193RequestFn`\<readonly \[\{ `Method`: `"eth_getFilterChanges"`; `Parameters`: \[`` `0x${string}` ``]; `ReturnType`: `` `0x${string}` ``\[] | `RpcLog`\[]; }, \{ `Method`: `"eth_getFilterLogs"`; `Parameters`: \[`` `0x${string}` ``]; `ReturnType`: `RpcLog`\[]; }, \{ `Method`: `"eth_uninstallFilter"`; `Parameters`: \[`` `0x${string}` ``]; `ReturnType`: `boolean`; }]>; `type`: `"transaction"`; }>

Creates a Filter to listen for new pending transaction hashes that can be used with [`getFilterChanges`](https://viem.sh/docs/actions/public/getFilterChanges).

* Docs: [https://viem.sh/docs/actions/public/createPendingTransactionFilter](https://viem.sh/docs/actions/public/createPendingTransactionFilter)
* JSON-RPC Methods: [`eth_newPendingTransactionFilter`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_newpendingtransactionfilter)

###### Returns

`Promise`\<\{ `id`: `` `0x${string}` ``; `request`: `EIP1193RequestFn`\<readonly \[\{ `Method`: `"eth_getFilterChanges"`; `Parameters`: \[`` `0x${string}` ``]; `ReturnType`: `` `0x${string}` ``\[] | `RpcLog`\[]; }, \{ `Method`: `"eth_getFilterLogs"`; `Parameters`: \[`` `0x${string}` ``]; `ReturnType`: `RpcLog`\[]; }, \{ `Method`: `"eth_uninstallFilter"`; `Parameters`: \[`` `0x${string}` ``]; `ReturnType`: `boolean`; }]>; `type`: `"transaction"`; }>

[`Filter`](https://viem.sh/docs/glossary/types#filter). CreateBlockFilterReturnType

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const filter = await client.createPendingTransactionFilter()
// { id: "0x345a6572337856574a76364e457a4366", type: 'transaction' }
```

##### estimateContractGas()

> **estimateContractGas**: \<`chain`, `abi`, `functionName`, `args`>(`args`) => `Promise`\<`bigint`>

Estimates the gas required to successfully execute a contract write function call.

* Docs: [https://viem.sh/docs/contract/estimateContractGas](https://viem.sh/docs/contract/estimateContractGas)

###### Type Parameters

| Type Parameter                                 |
| ---------------------------------------------- |
| `chain` *extends* `Chain` \| `undefined`       |
| `abi` *extends* readonly `unknown`\[] \| `Abi` |
| `functionName` *extends* `string`              |
| `args` *extends* `unknown`                     |

###### Parameters

| Parameter | Type                                                                     | Description                   |
| --------- | ------------------------------------------------------------------------ | ----------------------------- |
| `args`    | `EstimateContractGasParameters`\<`abi`, `functionName`, `args`, `chain`> | EstimateContractGasParameters |

###### Returns

`Promise`\<`bigint`>

The gas estimate (in wei). EstimateContractGasReturnType

###### Remarks

Internally, uses a [Public Client](https://viem.sh/docs/clients/public) to call the [`estimateGas` action](https://viem.sh/docs/actions/public/estimateGas) with [ABI-encoded `data`](https://viem.sh/docs/contract/encodeFunctionData).

###### Example

```ts theme={null}
import { createPublicClient, http, parseAbi } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const gas = await client.estimateContractGas({
  address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
  abi: parseAbi(['function mint() public']),
  functionName: 'mint',
  account: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
})
```

##### estimateFeesPerGas()

> **estimateFeesPerGas**: \<`chainOverride`, `type`>(`args`?) => `Promise`\<`EstimateFeesPerGasReturnType`\<`type`>>

Returns an estimate for the fees per gas for a transaction to be included
in the next block.

* Docs: [https://viem.sh/docs/actions/public/estimateFeesPerGas](https://viem.sh/docs/actions/public/estimateFeesPerGas)

###### Type Parameters

| Type Parameter                                   | Default type |
| ------------------------------------------------ | ------------ |
| `chainOverride` *extends* `Chain` \| `undefined` | `undefined`  |
| `type` *extends* `FeeValuesType`                 | `"eip1559"`  |

###### Parameters

| Parameter | Type                                                              |
| --------- | ----------------------------------------------------------------- |
| `args`?   | `EstimateFeesPerGasParameters`\<`Chain`, `chainOverride`, `type`> |

###### Returns

`Promise`\<`EstimateFeesPerGasReturnType`\<`type`>>

An estimate (in wei) for the fees per gas. EstimateFeesPerGasReturnType

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const maxPriorityFeePerGas = await client.estimateFeesPerGas()
// { maxFeePerGas: ..., maxPriorityFeePerGas: ... }
```

##### estimateGas()

> **estimateGas**: (`args`) => `Promise`\<`bigint`>

Estimates the gas necessary to complete a transaction without submitting it to the network.

* Docs: [https://viem.sh/docs/actions/public/estimateGas](https://viem.sh/docs/actions/public/estimateGas)
* JSON-RPC Methods: [`eth_estimateGas`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_estimategas)

###### Parameters

| Parameter | Type                              | Description           |
| --------- | --------------------------------- | --------------------- |
| `args`    | `EstimateGasParameters`\<`Chain`> | EstimateGasParameters |

###### Returns

`Promise`\<`bigint`>

The gas estimate (in wei). EstimateGasReturnType

###### Example

```ts theme={null}
import { createPublicClient, http, parseEther } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const gasEstimate = await client.estimateGas({
  account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
  to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
  value: parseEther('1'),
})
```

##### estimateMaxPriorityFeePerGas()

> **estimateMaxPriorityFeePerGas**: \<`chainOverride`>(`args`?) => `Promise`\<`bigint`>

Returns an estimate for the max priority fee per gas (in wei) for a transaction
to be included in the next block.

* Docs: [https://viem.sh/docs/actions/public/estimateMaxPriorityFeePerGas](https://viem.sh/docs/actions/public/estimateMaxPriorityFeePerGas)

###### Type Parameters

| Type Parameter                                   | Default type |
| ------------------------------------------------ | ------------ |
| `chainOverride` *extends* `Chain` \| `undefined` | `undefined`  |

###### Parameters

| Parameter     | Type                                     |
| ------------- | ---------------------------------------- |
| `args`?       | \{ `chain`: `chainOverride` \| `null`; } |
| `args.chain`? | `chainOverride` \| `null`                |

###### Returns

`Promise`\<`bigint`>

An estimate (in wei) for the max priority fee per gas. EstimateMaxPriorityFeePerGasReturnType

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const maxPriorityFeePerGas = await client.estimateMaxPriorityFeePerGas()
// 10000000n
```

##### experimental\_blockTag?

> `optional` **experimental\_blockTag**: `BlockTag`

Default block tag to use for RPC requests.

##### extend()

> **extend**: \<`client`>(`fn`) => `Client`\<`HttpTransport`, `Chain`, `undefined`, `PublicRpcSchema`, \{ \[K in string | number | symbol]: client\[K] } & `PublicActions`\<`HttpTransport`, `Chain`>>

###### Type Parameters

| Type Parameter                                                                                                      |
| ------------------------------------------------------------------------------------------------------------------- |
| `client` *extends* `object` & `ExactPartial`\<`ExtendableProtectedActions`\<`HttpTransport`, `Chain`, `undefined`>> |

###### Parameters

| Parameter | Type                   |
| --------- | ---------------------- |
| `fn`      | (`client`) => `client` |

###### Returns

`Client`\<`HttpTransport`, `Chain`, `undefined`, `PublicRpcSchema`, \{ \[K in string | number | symbol]: client\[K] } & `PublicActions`\<`HttpTransport`, `Chain`>>

##### getBalance()

> **getBalance**: (`args`) => `Promise`\<`bigint`>

Returns the balance of an address in wei.

* Docs: [https://viem.sh/docs/actions/public/getBalance](https://viem.sh/docs/actions/public/getBalance)
* JSON-RPC Methods: [`eth_getBalance`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getbalance)

###### Parameters

| Parameter | Type                   | Description          |
| --------- | ---------------------- | -------------------- |
| `args`    | `GetBalanceParameters` | GetBalanceParameters |

###### Returns

`Promise`\<`bigint`>

The balance of the address in wei. GetBalanceReturnType

###### Remarks

You can convert the balance to ether units with [`formatEther`](https://viem.sh/docs/utilities/formatEther).

```ts theme={null}
const balance = await getBalance(client, {
  address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
  blockTag: 'safe'
})
const balanceAsEther = formatEther(balance)
// "6.942"
```

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const balance = await client.getBalance({
  address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
})
// 10000000000000000000000n (wei)
```

##### getBlobBaseFee()

> **getBlobBaseFee**: () => `Promise`\<`bigint`>

Returns the base fee per blob gas in wei.

* Docs: [https://viem.sh/docs/actions/public/getBlobBaseFee](https://viem.sh/docs/actions/public/getBlobBaseFee)
* JSON-RPC Methods: [`eth_blobBaseFee`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_blobBaseFee)

###### Returns

`Promise`\<`bigint`>

The blob base fee (in wei). GetBlobBaseFeeReturnType

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'
import { getBlobBaseFee } from 'viem/public'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const blobBaseFee = await client.getBlobBaseFee()
```

##### getBlock()

> **getBlock**: \<`includeTransactions`, `blockTag`>(`args`?) => `Promise`\<\{ `baseFeePerGas`: `bigint` | `null`; `blobGasUsed`: `bigint`; `difficulty`: `bigint`; `excessBlobGas`: `bigint`; `extraData`: `` `0x${string}` ``; `gasLimit`: `bigint`; `gasUsed`: `bigint`; `hash`: `blockTag` *extends* `"pending"` ? `null` : `` `0x${string}` ``; `logsBloom`: `blockTag` *extends* `"pending"` ? `null` : `` `0x${string}` ``; `miner`: `` `0x${string}` ``; `mixHash`: `` `0x${string}` ``; `nonce`: `blockTag` *extends* `"pending"` ? `null` : `` `0x${string}` ``; `number`: `blockTag` *extends* `"pending"` ? `null` : `bigint`; `parentBeaconBlockRoot`: `` `0x${string}` ``; `parentHash`: `` `0x${string}` ``; `receiptsRoot`: `` `0x${string}` ``; `sealFields`: `` `0x${string}` ``\[]; `sha3Uncles`: `` `0x${string}` ``; `size`: `bigint`; `stateRoot`: `` `0x${string}` ``; `timestamp`: `bigint`; `totalDifficulty`: `bigint` | `null`; `transactions`: `includeTransactions` *extends* `true` ? (\{ `accessList`: `undefined`; `authorizationList`: `undefined`; `blobVersionedHashes`: `undefined`; `blockHash`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `` `0x${string}` ``; `blockNumber`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `bigint`; `chainId`: `number`; `from`: `` `0x${string}` ``; `gas`: `bigint`; `gasPrice`: `bigint`; `hash`: `` `0x${string}` ``; `input`: `` `0x${string}` ``; `maxFeePerBlobGas`: `undefined`; `maxFeePerGas`: `undefined`; `maxPriorityFeePerGas`: `undefined`; `nonce`: `number`; `r`: `` `0x${string}` ``; `s`: `` `0x${string}` ``; `to`: `` `0x${string}` `` | `null`; `transactionIndex`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `number`; `type`: `"legacy"`; `typeHex`: `` `0x${string}` `` | `null`; `v`: `bigint`; `value`: `bigint`; `yParity`: `undefined`; } | \{ `accessList`: `AccessList`; `authorizationList`: `undefined`; `blobVersionedHashes`: `undefined`; `blockHash`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `` `0x${string}` ``; `blockNumber`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `bigint`; `chainId`: `number`; `from`: `` `0x${string}` ``; `gas`: `bigint`; `gasPrice`: `bigint`; `hash`: `` `0x${string}` ``; `input`: `` `0x${string}` ``; `maxFeePerBlobGas`: `undefined`; `maxFeePerGas`: `undefined`; `maxPriorityFeePerGas`: `undefined`; `nonce`: `number`; `r`: `` `0x${string}` ``; `s`: `` `0x${string}` ``; `to`: `` `0x${string}` `` | `null`; `transactionIndex`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `number`; `type`: `"eip2930"`; `typeHex`: `` `0x${string}` `` | `null`; `v`: `bigint`; `value`: `bigint`; `yParity`: `number`; } | \{ `accessList`: `AccessList`; `authorizationList`: `undefined`; `blobVersionedHashes`: `undefined`; `blockHash`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `` `0x${string}` ``; `blockNumber`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `bigint`; `chainId`: `number`; `from`: `` `0x${string}` ``; `gas`: `bigint`; `gasPrice`: `undefined`; `hash`: `` `0x${string}` ``; `input`: `` `0x${string}` ``; `maxFeePerBlobGas`: `undefined`; `maxFeePerGas`: `bigint`; `maxPriorityFeePerGas`: `bigint`; `nonce`: `number`; `r`: `` `0x${string}` ``; `s`: `` `0x${string}` ``; `to`: `` `0x${string}` `` | `null`; `transactionIndex`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `number`; `type`: `"eip1559"`; `typeHex`: `` `0x${string}` `` | `null`; `v`: `bigint`; `value`: `bigint`; `yParity`: `number`; } | \{ `accessList`: `AccessList`; `authorizationList`: `undefined`; `blobVersionedHashes`: readonly `` `0x${string}` ``\[]; `blockHash`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `` `0x${string}` ``; `blockNumber`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `bigint`; `chainId`: `number`; `from`: `` `0x${string}` ``; `gas`: `bigint`; `gasPrice`: `undefined`; `hash`: `` `0x${string}` ``; `input`: `` `0x${string}` ``; `maxFeePerBlobGas`: `bigint`; `maxFeePerGas`: `bigint`; `maxPriorityFeePerGas`: `bigint`; `nonce`: `number`; `r`: `` `0x${string}` ``; `s`: `` `0x${string}` ``; `to`: `` `0x${string}` `` | `null`; `transactionIndex`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `number`; `type`: `"eip4844"`; `typeHex`: `` `0x${string}` `` | `null`; `v`: `bigint`; `value`: `bigint`; `yParity`: `number`; } | \{ `accessList`: `AccessList`; `authorizationList`: `SignedAuthorizationList`; `blobVersionedHashes`: `undefined`; `blockHash`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `` `0x${string}` ``; `blockNumber`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `bigint`; `chainId`: `number`; `from`: `` `0x${string}` ``; `gas`: `bigint`; `gasPrice`: `undefined`; `hash`: `` `0x${string}` ``; `input`: `` `0x${string}` ``; `maxFeePerBlobGas`: `undefined`; `maxFeePerGas`: `bigint`; `maxPriorityFeePerGas`: `bigint`; `nonce`: `number`; `r`: `` `0x${string}` ``; `s`: `` `0x${string}` ``; `to`: `` `0x${string}` `` | `null`; `transactionIndex`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `number`; `type`: `"eip7702"`; `typeHex`: `` `0x${string}` `` | `null`; `v`: `bigint`; `value`: `bigint`; `yParity`: `number`; })\[] : `` `0x${string}` ``\[]; `transactionsRoot`: `` `0x${string}` ``; `uncles`: `` `0x${string}` ``\[]; `withdrawals`: `Withdrawal`\[]; `withdrawalsRoot`: `` `0x${string}` ``; }>

Returns information about a block at a block number, hash, or tag.

* Docs: [https://viem.sh/docs/actions/public/getBlock](https://viem.sh/docs/actions/public/getBlock)
* Examples: [https://stackblitz.com/github/wevm/viem/tree/main/examples/blocks\_fetching-blocks](https://stackblitz.com/github/wevm/viem/tree/main/examples/blocks_fetching-blocks)
* JSON-RPC Methods:
  * Calls [`eth_getBlockByNumber`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getblockbynumber) for `blockNumber` & `blockTag`.
  * Calls [`eth_getBlockByHash`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getblockbyhash) for `blockHash`.

###### Type Parameters

| Type Parameter                            | Default type |
| ----------------------------------------- | ------------ |
| `includeTransactions` *extends* `boolean` | `false`      |
| `blockTag` *extends* `BlockTag`           | `"latest"`   |

###### Parameters

| Parameter | Type                                                     | Description        |
| --------- | -------------------------------------------------------- | ------------------ |
| `args`?   | `GetBlockParameters`\<`includeTransactions`, `blockTag`> | GetBlockParameters |

###### Returns

`Promise`\<\{ `baseFeePerGas`: `bigint` | `null`; `blobGasUsed`: `bigint`; `difficulty`: `bigint`; `excessBlobGas`: `bigint`; `extraData`: `` `0x${string}` ``; `gasLimit`: `bigint`; `gasUsed`: `bigint`; `hash`: `blockTag` *extends* `"pending"` ? `null` : `` `0x${string}` ``; `logsBloom`: `blockTag` *extends* `"pending"` ? `null` : `` `0x${string}` ``; `miner`: `` `0x${string}` ``; `mixHash`: `` `0x${string}` ``; `nonce`: `blockTag` *extends* `"pending"` ? `null` : `` `0x${string}` ``; `number`: `blockTag` *extends* `"pending"` ? `null` : `bigint`; `parentBeaconBlockRoot`: `` `0x${string}` ``; `parentHash`: `` `0x${string}` ``; `receiptsRoot`: `` `0x${string}` ``; `sealFields`: `` `0x${string}` ``\[]; `sha3Uncles`: `` `0x${string}` ``; `size`: `bigint`; `stateRoot`: `` `0x${string}` ``; `timestamp`: `bigint`; `totalDifficulty`: `bigint` | `null`; `transactions`: `includeTransactions` *extends* `true` ? (\{ `accessList`: `undefined`; `authorizationList`: `undefined`; `blobVersionedHashes`: `undefined`; `blockHash`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `` `0x${string}` ``; `blockNumber`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `bigint`; `chainId`: `number`; `from`: `` `0x${string}` ``; `gas`: `bigint`; `gasPrice`: `bigint`; `hash`: `` `0x${string}` ``; `input`: `` `0x${string}` ``; `maxFeePerBlobGas`: `undefined`; `maxFeePerGas`: `undefined`; `maxPriorityFeePerGas`: `undefined`; `nonce`: `number`; `r`: `` `0x${string}` ``; `s`: `` `0x${string}` ``; `to`: `` `0x${string}` `` | `null`; `transactionIndex`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `number`; `type`: `"legacy"`; `typeHex`: `` `0x${string}` `` | `null`; `v`: `bigint`; `value`: `bigint`; `yParity`: `undefined`; } | \{ `accessList`: `AccessList`; `authorizationList`: `undefined`; `blobVersionedHashes`: `undefined`; `blockHash`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `` `0x${string}` ``; `blockNumber`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `bigint`; `chainId`: `number`; `from`: `` `0x${string}` ``; `gas`: `bigint`; `gasPrice`: `bigint`; `hash`: `` `0x${string}` ``; `input`: `` `0x${string}` ``; `maxFeePerBlobGas`: `undefined`; `maxFeePerGas`: `undefined`; `maxPriorityFeePerGas`: `undefined`; `nonce`: `number`; `r`: `` `0x${string}` ``; `s`: `` `0x${string}` ``; `to`: `` `0x${string}` `` | `null`; `transactionIndex`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `number`; `type`: `"eip2930"`; `typeHex`: `` `0x${string}` `` | `null`; `v`: `bigint`; `value`: `bigint`; `yParity`: `number`; } | \{ `accessList`: `AccessList`; `authorizationList`: `undefined`; `blobVersionedHashes`: `undefined`; `blockHash`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `` `0x${string}` ``; `blockNumber`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `bigint`; `chainId`: `number`; `from`: `` `0x${string}` ``; `gas`: `bigint`; `gasPrice`: `undefined`; `hash`: `` `0x${string}` ``; `input`: `` `0x${string}` ``; `maxFeePerBlobGas`: `undefined`; `maxFeePerGas`: `bigint`; `maxPriorityFeePerGas`: `bigint`; `nonce`: `number`; `r`: `` `0x${string}` ``; `s`: `` `0x${string}` ``; `to`: `` `0x${string}` `` | `null`; `transactionIndex`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `number`; `type`: `"eip1559"`; `typeHex`: `` `0x${string}` `` | `null`; `v`: `bigint`; `value`: `bigint`; `yParity`: `number`; } | \{ `accessList`: `AccessList`; `authorizationList`: `undefined`; `blobVersionedHashes`: readonly `` `0x${string}` ``\[]; `blockHash`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `` `0x${string}` ``; `blockNumber`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `bigint`; `chainId`: `number`; `from`: `` `0x${string}` ``; `gas`: `bigint`; `gasPrice`: `undefined`; `hash`: `` `0x${string}` ``; `input`: `` `0x${string}` ``; `maxFeePerBlobGas`: `bigint`; `maxFeePerGas`: `bigint`; `maxPriorityFeePerGas`: `bigint`; `nonce`: `number`; `r`: `` `0x${string}` ``; `s`: `` `0x${string}` ``; `to`: `` `0x${string}` `` | `null`; `transactionIndex`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `number`; `type`: `"eip4844"`; `typeHex`: `` `0x${string}` `` | `null`; `v`: `bigint`; `value`: `bigint`; `yParity`: `number`; } | \{ `accessList`: `AccessList`; `authorizationList`: `SignedAuthorizationList`; `blobVersionedHashes`: `undefined`; `blockHash`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `` `0x${string}` ``; `blockNumber`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `bigint`; `chainId`: `number`; `from`: `` `0x${string}` ``; `gas`: `bigint`; `gasPrice`: `undefined`; `hash`: `` `0x${string}` ``; `input`: `` `0x${string}` ``; `maxFeePerBlobGas`: `undefined`; `maxFeePerGas`: `bigint`; `maxPriorityFeePerGas`: `bigint`; `nonce`: `number`; `r`: `` `0x${string}` ``; `s`: `` `0x${string}` ``; `to`: `` `0x${string}` `` | `null`; `transactionIndex`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `number`; `type`: `"eip7702"`; `typeHex`: `` `0x${string}` `` | `null`; `v`: `bigint`; `value`: `bigint`; `yParity`: `number`; })\[] : `` `0x${string}` ``\[]; `transactionsRoot`: `` `0x${string}` ``; `uncles`: `` `0x${string}` ``\[]; `withdrawals`: `Withdrawal`\[]; `withdrawalsRoot`: `` `0x${string}` ``; }>

Information about the block. GetBlockReturnType

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const block = await client.getBlock()
```

##### getBlockNumber()

> **getBlockNumber**: (`args`?) => `Promise`\<`bigint`>

Returns the number of the most recent block seen.

* Docs: [https://viem.sh/docs/actions/public/getBlockNumber](https://viem.sh/docs/actions/public/getBlockNumber)
* Examples: [https://stackblitz.com/github/wevm/viem/tree/main/examples/blocks\_fetching-blocks](https://stackblitz.com/github/wevm/viem/tree/main/examples/blocks_fetching-blocks)
* JSON-RPC Methods: [`eth_blockNumber`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_blocknumber)

###### Parameters

| Parameter | Type                       | Description              |
| --------- | -------------------------- | ------------------------ |
| `args`?   | `GetBlockNumberParameters` | GetBlockNumberParameters |

###### Returns

`Promise`\<`bigint`>

The number of the block. GetBlockNumberReturnType

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const blockNumber = await client.getBlockNumber()
// 69420n
```

##### getBlockTransactionCount()

> **getBlockTransactionCount**: (`args`?) => `Promise`\<`number`>

Returns the number of Transactions at a block number, hash, or tag.

* Docs: [https://viem.sh/docs/actions/public/getBlockTransactionCount](https://viem.sh/docs/actions/public/getBlockTransactionCount)
* JSON-RPC Methods:
  * Calls [`eth_getBlockTransactionCountByNumber`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getblocktransactioncountbynumber) for `blockNumber` & `blockTag`.
  * Calls [`eth_getBlockTransactionCountByHash`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getblocktransactioncountbyhash) for `blockHash`.

###### Parameters

| Parameter | Type                                 | Description                        |
| --------- | ------------------------------------ | ---------------------------------- |
| `args`?   | `GetBlockTransactionCountParameters` | GetBlockTransactionCountParameters |

###### Returns

`Promise`\<`number`>

The block transaction count. GetBlockTransactionCountReturnType

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const count = await client.getBlockTransactionCount()
```

##### ~~getBytecode()~~

> **getBytecode**: (`args`) => `Promise`\<`GetCodeReturnType`>

###### Parameters

| Parameter | Type                |
| --------- | ------------------- |
| `args`    | `GetCodeParameters` |

###### Returns

`Promise`\<`GetCodeReturnType`>

###### Deprecated

Use `getCode` instead.

##### getChainId()

> **getChainId**: () => `Promise`\<`number`>

Returns the chain ID associated with the current network.

* Docs: [https://viem.sh/docs/actions/public/getChainId](https://viem.sh/docs/actions/public/getChainId)
* JSON-RPC Methods: [`eth_chainId`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_chainid)

###### Returns

`Promise`\<`number`>

The current chain ID. GetChainIdReturnType

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const chainId = await client.getChainId()
// 1
```

##### getCode()

> **getCode**: (`args`) => `Promise`\<`GetCodeReturnType`>

Retrieves the bytecode at an address.

* Docs: [https://viem.sh/docs/contract/getCode](https://viem.sh/docs/contract/getCode)
* JSON-RPC Methods: [`eth_getCode`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getcode)

###### Parameters

| Parameter | Type                | Description           |
| --------- | ------------------- | --------------------- |
| `args`    | `GetCodeParameters` | GetBytecodeParameters |

###### Returns

`Promise`\<`GetCodeReturnType`>

The contract's bytecode. GetBytecodeReturnType

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const code = await client.getCode({
  address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
})
```

##### getContractEvents()

> **getContractEvents**: \<`abi`, `eventName`, `strict`, `fromBlock`, `toBlock`>(`args`) => `Promise`\<`GetContractEventsReturnType`\<`abi`, `eventName`, `strict`, `fromBlock`, `toBlock`>>

Returns a list of event logs emitted by a contract.

* Docs: [https://viem.sh/docs/actions/public/getContractEvents](https://viem.sh/docs/actions/public/getContractEvents)
* JSON-RPC Methods: [`eth_getLogs`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getlogs)

###### Type Parameters

| Type Parameter                                              | Default type |
| ----------------------------------------------------------- | ------------ |
| `abi` *extends* readonly `unknown`\[] \| `Abi`              | -            |
| `eventName` *extends* `string` \| `undefined`               | `undefined`  |
| `strict` *extends* `boolean` \| `undefined`                 | `undefined`  |
| `fromBlock` *extends* `bigint` \| `BlockTag` \| `undefined` | `undefined`  |
| `toBlock` *extends* `bigint` \| `BlockTag` \| `undefined`   | `undefined`  |

###### Parameters

| Parameter | Type                                                                                 |
| --------- | ------------------------------------------------------------------------------------ |
| `args`    | `GetContractEventsParameters`\<`abi`, `eventName`, `strict`, `fromBlock`, `toBlock`> |

###### Returns

`Promise`\<`GetContractEventsReturnType`\<`abi`, `eventName`, `strict`, `fromBlock`, `toBlock`>>

A list of event logs. GetContractEventsReturnType

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'
import { wagmiAbi } from './abi'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const logs = await client.getContractEvents(client, {
 address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
 abi: wagmiAbi,
 eventName: 'Transfer'
})
```

##### getEip712Domain()

> **getEip712Domain**: (`args`) => `Promise`\<`GetEip712DomainReturnType`>

Reads the EIP-712 domain from a contract, based on the ERC-5267 specification.

###### Parameters

| Parameter | Type                        |
| --------- | --------------------------- |
| `args`    | `GetEip712DomainParameters` |

###### Returns

`Promise`\<`GetEip712DomainReturnType`>

The EIP-712 domain, fields, and extensions. GetEip712DomainReturnType

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})

const domain = await client.getEip712Domain({
  address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
})
// {
//   domain: {
//     name: 'ExampleContract',
//     version: '1',
//     chainId: 1,
//     verifyingContract: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
//   },
//   fields: '0x0f',
//   extensions: [],
// }
```

##### getEnsAddress()

> **getEnsAddress**: (`args`) => `Promise`\<`GetEnsAddressReturnType`>

Gets address for ENS name.

* Docs: [https://viem.sh/docs/ens/actions/getEnsAddress](https://viem.sh/docs/ens/actions/getEnsAddress)
* Examples: [https://stackblitz.com/github/wevm/viem/tree/main/examples/ens](https://stackblitz.com/github/wevm/viem/tree/main/examples/ens)

###### Parameters

| Parameter                        | Type                                                                                                                                                                                            | Description                                                                         |
| -------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- |
| `args`                           | \{ `blockNumber`: `bigint`; `blockTag`: `BlockTag`; `coinType`: `number`; `gatewayUrls`: `string`\[]; `name`: `string`; `strict`: `boolean`; `universalResolverAddress`: `` `0x${string}` ``; } | GetEnsAddressParameters                                                             |
| `args.blockNumber`?              | `bigint`                                                                                                                                                                                        | The balance of the account at a block number.                                       |
| `args.blockTag`?                 | `BlockTag`                                                                                                                                                                                      | The balance of the account at a block tag. **Default** `'latest'`                   |
| `args.coinType`?                 | `number`                                                                                                                                                                                        | ENSIP-9 compliant coinType used to resolve addresses for other chains               |
| `args.gatewayUrls`?              | `string`\[]                                                                                                                                                                                     | Universal Resolver gateway URLs to use for resolving CCIP-read requests.            |
| `args.name`                      | `string`                                                                                                                                                                                        | Name to get the address for.                                                        |
| `args.strict`?                   | `boolean`                                                                                                                                                                                       | Whether or not to throw errors propagated from the ENS Universal Resolver Contract. |
| `args.universalResolverAddress`? | `` `0x${string}` ``                                                                                                                                                                             | Address of ENS Universal Resolver Contract.                                         |

###### Returns

`Promise`\<`GetEnsAddressReturnType`>

Address for ENS name or `null` if not found. GetEnsAddressReturnType

###### Remarks

Calls `resolve(bytes, bytes)` on ENS Universal Resolver Contract.

Since ENS names prohibit certain forbidden characters (e.g. underscore) and have other validation rules, you likely want to [normalize ENS names](https://docs.ens.domains/contract-api-reference/name-processing#normalising-names) with [UTS-46 normalization](https://unicode.org/reports/tr46) before passing them to `getEnsAddress`. You can use the built-in [`normalize`](https://viem.sh/docs/ens/utilities/normalize) function for this.

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'
import { normalize } from 'viem/ens'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const ensAddress = await client.getEnsAddress({
  name: normalize('wevm.eth'),
})
// '0xd2135CfB216b74109775236E36d4b433F1DF507B'
```

##### getEnsAvatar()

> **getEnsAvatar**: (`args`) => `Promise`\<`GetEnsAvatarReturnType`>

Gets the avatar of an ENS name.

* Docs: [https://viem.sh/docs/ens/actions/getEnsAvatar](https://viem.sh/docs/ens/actions/getEnsAvatar)
* Examples: [https://stackblitz.com/github/wevm/viem/tree/main/examples/ens](https://stackblitz.com/github/wevm/viem/tree/main/examples/ens)

###### Parameters

| Parameter                        | Type                                                                                                                                                                                                              | Description                                                                         |
| -------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- |
| `args`                           | \{ `assetGatewayUrls`: `AssetGatewayUrls`; `blockNumber`: `bigint`; `blockTag`: `BlockTag`; `gatewayUrls`: `string`\[]; `name`: `string`; `strict`: `boolean`; `universalResolverAddress`: `` `0x${string}` ``; } | GetEnsAvatarParameters                                                              |
| `args.assetGatewayUrls`?         | `AssetGatewayUrls`                                                                                                                                                                                                | Gateway urls to resolve IPFS and/or Arweave assets.                                 |
| `args.blockNumber`?              | `bigint`                                                                                                                                                                                                          | The balance of the account at a block number.                                       |
| `args.blockTag`?                 | `BlockTag`                                                                                                                                                                                                        | The balance of the account at a block tag. **Default** `'latest'`                   |
| `args.gatewayUrls`?              | `string`\[]                                                                                                                                                                                                       | Universal Resolver gateway URLs to use for resolving CCIP-read requests.            |
| `args.name`                      | `string`                                                                                                                                                                                                          | ENS name to get Text for.                                                           |
| `args.strict`?                   | `boolean`                                                                                                                                                                                                         | Whether or not to throw errors propagated from the ENS Universal Resolver Contract. |
| `args.universalResolverAddress`? | `` `0x${string}` ``                                                                                                                                                                                               | Address of ENS Universal Resolver Contract.                                         |

###### Returns

`Promise`\<`GetEnsAvatarReturnType`>

Avatar URI or `null` if not found. GetEnsAvatarReturnType

###### Remarks

Calls [`getEnsText`](https://viem.sh/docs/ens/actions/getEnsText) with `key` set to `'avatar'`.

Since ENS names prohibit certain forbidden characters (e.g. underscore) and have other validation rules, you likely want to [normalize ENS names](https://docs.ens.domains/contract-api-reference/name-processing#normalising-names) with [UTS-46 normalization](https://unicode.org/reports/tr46) before passing them to `getEnsAddress`. You can use the built-in [`normalize`](https://viem.sh/docs/ens/utilities/normalize) function for this.

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'
import { normalize } from 'viem/ens'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const ensAvatar = await client.getEnsAvatar({
  name: normalize('wevm.eth'),
})
// 'https://ipfs.io/ipfs/Qma8mnp6xV3J2cRNf3mTth5C8nV11CAnceVinc3y8jSbio'
```

##### getEnsName()

> **getEnsName**: (`args`) => `Promise`\<`GetEnsNameReturnType`>

Gets primary name for specified address.

* Docs: [https://viem.sh/docs/ens/actions/getEnsName](https://viem.sh/docs/ens/actions/getEnsName)
* Examples: [https://stackblitz.com/github/wevm/viem/tree/main/examples/ens](https://stackblitz.com/github/wevm/viem/tree/main/examples/ens)

###### Parameters

| Parameter                        | Type                                                                                                                                                                                    | Description                                                                         |
| -------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- |
| `args`                           | \{ `address`: `` `0x${string}` ``; `blockNumber`: `bigint`; `blockTag`: `BlockTag`; `gatewayUrls`: `string`\[]; `strict`: `boolean`; `universalResolverAddress`: `` `0x${string}` ``; } | GetEnsNameParameters                                                                |
| `args.address`                   | `` `0x${string}` ``                                                                                                                                                                     | Address to get ENS name for.                                                        |
| `args.blockNumber`?              | `bigint`                                                                                                                                                                                | The balance of the account at a block number.                                       |
| `args.blockTag`?                 | `BlockTag`                                                                                                                                                                              | The balance of the account at a block tag. **Default** `'latest'`                   |
| `args.gatewayUrls`?              | `string`\[]                                                                                                                                                                             | Universal Resolver gateway URLs to use for resolving CCIP-read requests.            |
| `args.strict`?                   | `boolean`                                                                                                                                                                               | Whether or not to throw errors propagated from the ENS Universal Resolver Contract. |
| `args.universalResolverAddress`? | `` `0x${string}` ``                                                                                                                                                                     | Address of ENS Universal Resolver Contract.                                         |

###### Returns

`Promise`\<`GetEnsNameReturnType`>

Name or `null` if not found. GetEnsNameReturnType

###### Remarks

Calls `reverse(bytes)` on ENS Universal Resolver Contract to "reverse resolve" the address to the primary ENS name.

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const ensName = await client.getEnsName({
  address: '0xd2135CfB216b74109775236E36d4b433F1DF507B',
})
// 'wevm.eth'
```

##### getEnsResolver()

> **getEnsResolver**: (`args`) => `Promise`\<`` `0x${string}` ``>

Gets resolver for ENS name.

* Docs: [https://viem.sh/docs/ens/actions/getEnsResolver](https://viem.sh/docs/ens/actions/getEnsResolver)
* Examples: [https://stackblitz.com/github/wevm/viem/tree/main/examples/ens](https://stackblitz.com/github/wevm/viem/tree/main/examples/ens)

###### Parameters

| Parameter                        | Type                                                                                                                     | Description                                                       |
| -------------------------------- | ------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------- |
| `args`                           | \{ `blockNumber`: `bigint`; `blockTag`: `BlockTag`; `name`: `string`; `universalResolverAddress`: `` `0x${string}` ``; } | GetEnsResolverParameters                                          |
| `args.blockNumber`?              | `bigint`                                                                                                                 | The balance of the account at a block number.                     |
| `args.blockTag`?                 | `BlockTag`                                                                                                               | The balance of the account at a block tag. **Default** `'latest'` |
| `args.name`                      | `string`                                                                                                                 | Name to get the address for.                                      |
| `args.universalResolverAddress`? | `` `0x${string}` ``                                                                                                      | Address of ENS Universal Resolver Contract.                       |

###### Returns

`Promise`\<`` `0x${string}` ``>

Address for ENS resolver. GetEnsResolverReturnType

###### Remarks

Calls `findResolver(bytes)` on ENS Universal Resolver Contract to retrieve the resolver of an ENS name.

Since ENS names prohibit certain forbidden characters (e.g. underscore) and have other validation rules, you likely want to [normalize ENS names](https://docs.ens.domains/contract-api-reference/name-processing#normalising-names) with [UTS-46 normalization](https://unicode.org/reports/tr46) before passing them to `getEnsAddress`. You can use the built-in [`normalize`](https://viem.sh/docs/ens/utilities/normalize) function for this.

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'
import { normalize } from 'viem/ens'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const resolverAddress = await client.getEnsResolver({
  name: normalize('wevm.eth'),
})
// '0x4976fb03C32e5B8cfe2b6cCB31c09Ba78EBaBa41'
```

##### getEnsText()

> **getEnsText**: (`args`) => `Promise`\<`GetEnsTextReturnType`>

Gets a text record for specified ENS name.

* Docs: [https://viem.sh/docs/ens/actions/getEnsResolver](https://viem.sh/docs/ens/actions/getEnsResolver)
* Examples: [https://stackblitz.com/github/wevm/viem/tree/main/examples/ens](https://stackblitz.com/github/wevm/viem/tree/main/examples/ens)

###### Parameters

| Parameter                        | Type                                                                                                                                                                                       | Description                                                                         |
| -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------- |
| `args`                           | \{ `blockNumber`: `bigint`; `blockTag`: `BlockTag`; `gatewayUrls`: `string`\[]; `key`: `string`; `name`: `string`; `strict`: `boolean`; `universalResolverAddress`: `` `0x${string}` ``; } | GetEnsTextParameters                                                                |
| `args.blockNumber`?              | `bigint`                                                                                                                                                                                   | The balance of the account at a block number.                                       |
| `args.blockTag`?                 | `BlockTag`                                                                                                                                                                                 | The balance of the account at a block tag. **Default** `'latest'`                   |
| `args.gatewayUrls`?              | `string`\[]                                                                                                                                                                                | Universal Resolver gateway URLs to use for resolving CCIP-read requests.            |
| `args.key`                       | `string`                                                                                                                                                                                   | Text record to retrieve.                                                            |
| `args.name`                      | `string`                                                                                                                                                                                   | ENS name to get Text for.                                                           |
| `args.strict`?                   | `boolean`                                                                                                                                                                                  | Whether or not to throw errors propagated from the ENS Universal Resolver Contract. |
| `args.universalResolverAddress`? | `` `0x${string}` ``                                                                                                                                                                        | Address of ENS Universal Resolver Contract.                                         |

###### Returns

`Promise`\<`GetEnsTextReturnType`>

Address for ENS resolver. GetEnsTextReturnType

###### Remarks

Calls `resolve(bytes, bytes)` on ENS Universal Resolver Contract.

Since ENS names prohibit certain forbidden characters (e.g. underscore) and have other validation rules, you likely want to [normalize ENS names](https://docs.ens.domains/contract-api-reference/name-processing#normalising-names) with [UTS-46 normalization](https://unicode.org/reports/tr46) before passing them to `getEnsAddress`. You can use the built-in [`normalize`](https://viem.sh/docs/ens/utilities/normalize) function for this.

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'
import { normalize } from 'viem/ens'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const twitterRecord = await client.getEnsText({
  name: normalize('wevm.eth'),
  key: 'com.twitter',
})
// 'wevm_dev'
```

##### getFeeHistory()

> **getFeeHistory**: (`args`) => `Promise`\<`GetFeeHistoryReturnType`>

Returns a collection of historical gas information.

* Docs: [https://viem.sh/docs/actions/public/getFeeHistory](https://viem.sh/docs/actions/public/getFeeHistory)
* JSON-RPC Methods: [`eth_feeHistory`](https://docs.alchemy.com/reference/eth-feehistory)

###### Parameters

| Parameter | Type                      | Description             |
| --------- | ------------------------- | ----------------------- |
| `args`    | `GetFeeHistoryParameters` | GetFeeHistoryParameters |

###### Returns

`Promise`\<`GetFeeHistoryReturnType`>

The gas estimate (in wei). GetFeeHistoryReturnType

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const feeHistory = await client.getFeeHistory({
  blockCount: 4,
  rewardPercentiles: [25, 75],
})
```

##### getFilterChanges()

> **getFilterChanges**: \<`filterType`, `abi`, `eventName`, `strict`, `fromBlock`, `toBlock`>(`args`) => `Promise`\<`GetFilterChangesReturnType`\<`filterType`, `abi`, `eventName`, `strict`, `fromBlock`, `toBlock`>>

Returns a list of logs or hashes based on a [Filter](https://viem.sh/docs/glossary/terms#filter) since the last time it was called.

* Docs: [https://viem.sh/docs/actions/public/getFilterChanges](https://viem.sh/docs/actions/public/getFilterChanges)
* JSON-RPC Methods: [`eth_getFilterChanges`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getfilterchanges)

###### Type Parameters

| Type Parameter                                                | Default type |
| ------------------------------------------------------------- | ------------ |
| `filterType` *extends* `FilterType`                           | -            |
| `abi` *extends* readonly `unknown`\[] \| `Abi` \| `undefined` | -            |
| `eventName` *extends* `string` \| `undefined`                 | -            |
| `strict` *extends* `boolean` \| `undefined`                   | `undefined`  |
| `fromBlock` *extends* `bigint` \| `BlockTag` \| `undefined`   | `undefined`  |
| `toBlock` *extends* `bigint` \| `BlockTag` \| `undefined`     | `undefined`  |

###### Parameters

| Parameter | Type                                                                                              | Description                |
| --------- | ------------------------------------------------------------------------------------------------- | -------------------------- |
| `args`    | `GetFilterChangesParameters`\<`filterType`, `abi`, `eventName`, `strict`, `fromBlock`, `toBlock`> | GetFilterChangesParameters |

###### Returns

`Promise`\<`GetFilterChangesReturnType`\<`filterType`, `abi`, `eventName`, `strict`, `fromBlock`, `toBlock`>>

Logs or hashes. GetFilterChangesReturnType

###### Remarks

A Filter can be created from the following actions:

* [`createBlockFilter`](https://viem.sh/docs/actions/public/createBlockFilter)
* [`createContractEventFilter`](https://viem.sh/docs/contract/createContractEventFilter)
* [`createEventFilter`](https://viem.sh/docs/actions/public/createEventFilter)
* [`createPendingTransactionFilter`](https://viem.sh/docs/actions/public/createPendingTransactionFilter)

Depending on the type of filter, the return value will be different:

* If the filter was created with `createContractEventFilter` or `createEventFilter`, it returns a list of logs.
* If the filter was created with `createPendingTransactionFilter`, it returns a list of transaction hashes.
* If the filter was created with `createBlockFilter`, it returns a list of block hashes.

###### Examples

```ts theme={null}
// Blocks
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const filter = await client.createBlockFilter()
const hashes = await client.getFilterChanges({ filter })
```

```ts theme={null}
// Contract Events
import { createPublicClient, http, parseAbi } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const filter = await client.createContractEventFilter({
  address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
  abi: parseAbi(['event Transfer(address indexed, address indexed, uint256)']),
  eventName: 'Transfer',
})
const logs = await client.getFilterChanges({ filter })
```

```ts theme={null}
// Raw Events
import { createPublicClient, http, parseAbiItem } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const filter = await client.createEventFilter({
  address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
  event: parseAbiItem('event Transfer(address indexed, address indexed, uint256)'),
})
const logs = await client.getFilterChanges({ filter })
```

```ts theme={null}
// Transactions
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const filter = await client.createPendingTransactionFilter()
const hashes = await client.getFilterChanges({ filter })
```

##### getFilterLogs()

> **getFilterLogs**: \<`abi`, `eventName`, `strict`, `fromBlock`, `toBlock`>(`args`) => `Promise`\<`GetFilterLogsReturnType`\<`abi`, `eventName`, `strict`, `fromBlock`, `toBlock`>>

Returns a list of event logs since the filter was created.

* Docs: [https://viem.sh/docs/actions/public/getFilterLogs](https://viem.sh/docs/actions/public/getFilterLogs)
* JSON-RPC Methods: [`eth_getFilterLogs`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getfilterlogs)

###### Type Parameters

| Type Parameter                                                | Default type |
| ------------------------------------------------------------- | ------------ |
| `abi` *extends* readonly `unknown`\[] \| `Abi` \| `undefined` | -            |
| `eventName` *extends* `string` \| `undefined`                 | -            |
| `strict` *extends* `boolean` \| `undefined`                   | `undefined`  |
| `fromBlock` *extends* `bigint` \| `BlockTag` \| `undefined`   | `undefined`  |
| `toBlock` *extends* `bigint` \| `BlockTag` \| `undefined`     | `undefined`  |

###### Parameters

| Parameter | Type                                                                             | Description             |
| --------- | -------------------------------------------------------------------------------- | ----------------------- |
| `args`    | `GetFilterLogsParameters`\<`abi`, `eventName`, `strict`, `fromBlock`, `toBlock`> | GetFilterLogsParameters |

###### Returns

`Promise`\<`GetFilterLogsReturnType`\<`abi`, `eventName`, `strict`, `fromBlock`, `toBlock`>>

A list of event logs. GetFilterLogsReturnType

###### Remarks

`getFilterLogs` is only compatible with **event filters**.

###### Example

```ts theme={null}
import { createPublicClient, http, parseAbiItem } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const filter = await client.createEventFilter({
  address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
  event: parseAbiItem('event Transfer(address indexed, address indexed, uint256)'),
})
const logs = await client.getFilterLogs({ filter })
```

##### getGasPrice()

> **getGasPrice**: () => `Promise`\<`bigint`>

Returns the current price of gas (in wei).

* Docs: [https://viem.sh/docs/actions/public/getGasPrice](https://viem.sh/docs/actions/public/getGasPrice)
* JSON-RPC Methods: [`eth_gasPrice`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_gasprice)

###### Returns

`Promise`\<`bigint`>

The gas price (in wei). GetGasPriceReturnType

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const gasPrice = await client.getGasPrice()
```

##### getLogs()

> **getLogs**: \<`abiEvent`, `abiEvents`, `strict`, `fromBlock`, `toBlock`>(`args`?) => `Promise`\<`GetLogsReturnType`\<`abiEvent`, `abiEvents`, `strict`, `fromBlock`, `toBlock`>>

Returns a list of event logs matching the provided parameters.

* Docs: [https://viem.sh/docs/actions/public/getLogs](https://viem.sh/docs/actions/public/getLogs)
* Examples: [https://stackblitz.com/github/wevm/viem/tree/main/examples/logs\_event-logs](https://stackblitz.com/github/wevm/viem/tree/main/examples/logs_event-logs)
* JSON-RPC Methods: [`eth_getLogs`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getlogs)

###### Type Parameters

| Type Parameter                                                                       | Default type                                                  |
| ------------------------------------------------------------------------------------ | ------------------------------------------------------------- |
| `abiEvent` *extends* `AbiEvent` \| `undefined`                                       | `undefined`                                                   |
| `abiEvents` *extends* readonly `unknown`\[] \| readonly `AbiEvent`\[] \| `undefined` | `abiEvent` *extends* `AbiEvent` ? \[`abiEvent`] : `undefined` |
| `strict` *extends* `boolean` \| `undefined`                                          | `undefined`                                                   |
| `fromBlock` *extends* `bigint` \| `BlockTag` \| `undefined`                          | `undefined`                                                   |
| `toBlock` *extends* `bigint` \| `BlockTag` \| `undefined`                            | `undefined`                                                   |

###### Parameters

| Parameter | Type                                                                            | Description       |
| --------- | ------------------------------------------------------------------------------- | ----------------- |
| `args`?   | `GetLogsParameters`\<`abiEvent`, `abiEvents`, `strict`, `fromBlock`, `toBlock`> | GetLogsParameters |

###### Returns

`Promise`\<`GetLogsReturnType`\<`abiEvent`, `abiEvents`, `strict`, `fromBlock`, `toBlock`>>

A list of event logs. GetLogsReturnType

###### Example

```ts theme={null}
import { createPublicClient, http, parseAbiItem } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const logs = await client.getLogs()
```

##### getProof()

> **getProof**: (`args`) => `Promise`\<`GetProofReturnType`>

Returns the account and storage values of the specified account including the Merkle-proof.

* Docs: [https://viem.sh/docs/actions/public/getProof](https://viem.sh/docs/actions/public/getProof)
* JSON-RPC Methods:
  * Calls [`eth_getProof`](https://eips.ethereum.org/EIPS/eip-1186)

###### Parameters

| Parameter | Type                 |
| --------- | -------------------- |
| `args`    | `GetProofParameters` |

###### Returns

`Promise`\<`GetProofReturnType`>

Proof data. GetProofReturnType

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const block = await client.getProof({
 address: '0x...',
 storageKeys: ['0x...'],
})
```

##### getStorageAt()

> **getStorageAt**: (`args`) => `Promise`\<`GetStorageAtReturnType`>

Returns the value from a storage slot at a given address.

* Docs: [https://viem.sh/docs/contract/getStorageAt](https://viem.sh/docs/contract/getStorageAt)
* JSON-RPC Methods: [`eth_getStorageAt`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getstorageat)

###### Parameters

| Parameter | Type                     | Description            |
| --------- | ------------------------ | ---------------------- |
| `args`    | `GetStorageAtParameters` | GetStorageAtParameters |

###### Returns

`Promise`\<`GetStorageAtReturnType`>

The value of the storage slot. GetStorageAtReturnType

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'
import { getStorageAt } from 'viem/contract'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const code = await client.getStorageAt({
  address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
  slot: toHex(0),
})
```

##### getTransaction()

> **getTransaction**: \<`blockTag`>(`args`) => `Promise`\<\{ `accessList`: `undefined`; `authorizationList`: `undefined`; `blobVersionedHashes`: `undefined`; `blockHash`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `` `0x${string}` ``; `blockNumber`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `bigint`; `chainId`: `number`; `from`: `` `0x${string}` ``; `gas`: `bigint`; `gasPrice`: `bigint`; `hash`: `` `0x${string}` ``; `input`: `` `0x${string}` ``; `maxFeePerBlobGas`: `undefined`; `maxFeePerGas`: `undefined`; `maxPriorityFeePerGas`: `undefined`; `nonce`: `number`; `r`: `` `0x${string}` ``; `s`: `` `0x${string}` ``; `to`: `` `0x${string}` `` | `null`; `transactionIndex`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `number`; `type`: `"legacy"`; `typeHex`: `` `0x${string}` `` | `null`; `v`: `bigint`; `value`: `bigint`; `yParity`: `undefined`; } | \{ `accessList`: `AccessList`; `authorizationList`: `undefined`; `blobVersionedHashes`: `undefined`; `blockHash`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `` `0x${string}` ``; `blockNumber`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `bigint`; `chainId`: `number`; `from`: `` `0x${string}` ``; `gas`: `bigint`; `gasPrice`: `bigint`; `hash`: `` `0x${string}` ``; `input`: `` `0x${string}` ``; `maxFeePerBlobGas`: `undefined`; `maxFeePerGas`: `undefined`; `maxPriorityFeePerGas`: `undefined`; `nonce`: `number`; `r`: `` `0x${string}` ``; `s`: `` `0x${string}` ``; `to`: `` `0x${string}` `` | `null`; `transactionIndex`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `number`; `type`: `"eip2930"`; `typeHex`: `` `0x${string}` `` | `null`; `v`: `bigint`; `value`: `bigint`; `yParity`: `number`; } | \{ `accessList`: `AccessList`; `authorizationList`: `undefined`; `blobVersionedHashes`: `undefined`; `blockHash`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `` `0x${string}` ``; `blockNumber`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `bigint`; `chainId`: `number`; `from`: `` `0x${string}` ``; `gas`: `bigint`; `gasPrice`: `undefined`; `hash`: `` `0x${string}` ``; `input`: `` `0x${string}` ``; `maxFeePerBlobGas`: `undefined`; `maxFeePerGas`: `bigint`; `maxPriorityFeePerGas`: `bigint`; `nonce`: `number`; `r`: `` `0x${string}` ``; `s`: `` `0x${string}` ``; `to`: `` `0x${string}` `` | `null`; `transactionIndex`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `number`; `type`: `"eip1559"`; `typeHex`: `` `0x${string}` `` | `null`; `v`: `bigint`; `value`: `bigint`; `yParity`: `number`; } | \{ `accessList`: `AccessList`; `authorizationList`: `undefined`; `blobVersionedHashes`: readonly `` `0x${string}` ``\[]; `blockHash`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `` `0x${string}` ``; `blockNumber`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `bigint`; `chainId`: `number`; `from`: `` `0x${string}` ``; `gas`: `bigint`; `gasPrice`: `undefined`; `hash`: `` `0x${string}` ``; `input`: `` `0x${string}` ``; `maxFeePerBlobGas`: `bigint`; `maxFeePerGas`: `bigint`; `maxPriorityFeePerGas`: `bigint`; `nonce`: `number`; `r`: `` `0x${string}` ``; `s`: `` `0x${string}` ``; `to`: `` `0x${string}` `` | `null`; `transactionIndex`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `number`; `type`: `"eip4844"`; `typeHex`: `` `0x${string}` `` | `null`; `v`: `bigint`; `value`: `bigint`; `yParity`: `number`; } | \{ `accessList`: `AccessList`; `authorizationList`: `SignedAuthorizationList`; `blobVersionedHashes`: `undefined`; `blockHash`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `` `0x${string}` ``; `blockNumber`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `bigint`; `chainId`: `number`; `from`: `` `0x${string}` ``; `gas`: `bigint`; `gasPrice`: `undefined`; `hash`: `` `0x${string}` ``; `input`: `` `0x${string}` ``; `maxFeePerBlobGas`: `undefined`; `maxFeePerGas`: `bigint`; `maxPriorityFeePerGas`: `bigint`; `nonce`: `number`; `r`: `` `0x${string}` ``; `s`: `` `0x${string}` ``; `to`: `` `0x${string}` `` | `null`; `transactionIndex`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `number`; `type`: `"eip7702"`; `typeHex`: `` `0x${string}` `` | `null`; `v`: `bigint`; `value`: `bigint`; `yParity`: `number`; }>

Returns information about a [Transaction](https://viem.sh/docs/glossary/terms#transaction) given a hash or block identifier.

* Docs: [https://viem.sh/docs/actions/public/getTransaction](https://viem.sh/docs/actions/public/getTransaction)
* Example: [https://stackblitz.com/github/wevm/viem/tree/main/examples/transactions\_fetching-transactions](https://stackblitz.com/github/wevm/viem/tree/main/examples/transactions_fetching-transactions)
* JSON-RPC Methods: [`eth_getTransactionByHash`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getTransactionByHash)

###### Type Parameters

| Type Parameter                  | Default type |
| ------------------------------- | ------------ |
| `blockTag` *extends* `BlockTag` | `"latest"`   |

###### Parameters

| Parameter | Type                                    | Description              |
| --------- | --------------------------------------- | ------------------------ |
| `args`    | `GetTransactionParameters`\<`blockTag`> | GetTransactionParameters |

###### Returns

`Promise`\<\{ `accessList`: `undefined`; `authorizationList`: `undefined`; `blobVersionedHashes`: `undefined`; `blockHash`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `` `0x${string}` ``; `blockNumber`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `bigint`; `chainId`: `number`; `from`: `` `0x${string}` ``; `gas`: `bigint`; `gasPrice`: `bigint`; `hash`: `` `0x${string}` ``; `input`: `` `0x${string}` ``; `maxFeePerBlobGas`: `undefined`; `maxFeePerGas`: `undefined`; `maxPriorityFeePerGas`: `undefined`; `nonce`: `number`; `r`: `` `0x${string}` ``; `s`: `` `0x${string}` ``; `to`: `` `0x${string}` `` | `null`; `transactionIndex`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `number`; `type`: `"legacy"`; `typeHex`: `` `0x${string}` `` | `null`; `v`: `bigint`; `value`: `bigint`; `yParity`: `undefined`; } | \{ `accessList`: `AccessList`; `authorizationList`: `undefined`; `blobVersionedHashes`: `undefined`; `blockHash`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `` `0x${string}` ``; `blockNumber`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `bigint`; `chainId`: `number`; `from`: `` `0x${string}` ``; `gas`: `bigint`; `gasPrice`: `bigint`; `hash`: `` `0x${string}` ``; `input`: `` `0x${string}` ``; `maxFeePerBlobGas`: `undefined`; `maxFeePerGas`: `undefined`; `maxPriorityFeePerGas`: `undefined`; `nonce`: `number`; `r`: `` `0x${string}` ``; `s`: `` `0x${string}` ``; `to`: `` `0x${string}` `` | `null`; `transactionIndex`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `number`; `type`: `"eip2930"`; `typeHex`: `` `0x${string}` `` | `null`; `v`: `bigint`; `value`: `bigint`; `yParity`: `number`; } | \{ `accessList`: `AccessList`; `authorizationList`: `undefined`; `blobVersionedHashes`: `undefined`; `blockHash`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `` `0x${string}` ``; `blockNumber`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `bigint`; `chainId`: `number`; `from`: `` `0x${string}` ``; `gas`: `bigint`; `gasPrice`: `undefined`; `hash`: `` `0x${string}` ``; `input`: `` `0x${string}` ``; `maxFeePerBlobGas`: `undefined`; `maxFeePerGas`: `bigint`; `maxPriorityFeePerGas`: `bigint`; `nonce`: `number`; `r`: `` `0x${string}` ``; `s`: `` `0x${string}` ``; `to`: `` `0x${string}` `` | `null`; `transactionIndex`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `number`; `type`: `"eip1559"`; `typeHex`: `` `0x${string}` `` | `null`; `v`: `bigint`; `value`: `bigint`; `yParity`: `number`; } | \{ `accessList`: `AccessList`; `authorizationList`: `undefined`; `blobVersionedHashes`: readonly `` `0x${string}` ``\[]; `blockHash`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `` `0x${string}` ``; `blockNumber`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `bigint`; `chainId`: `number`; `from`: `` `0x${string}` ``; `gas`: `bigint`; `gasPrice`: `undefined`; `hash`: `` `0x${string}` ``; `input`: `` `0x${string}` ``; `maxFeePerBlobGas`: `bigint`; `maxFeePerGas`: `bigint`; `maxPriorityFeePerGas`: `bigint`; `nonce`: `number`; `r`: `` `0x${string}` ``; `s`: `` `0x${string}` ``; `to`: `` `0x${string}` `` | `null`; `transactionIndex`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `number`; `type`: `"eip4844"`; `typeHex`: `` `0x${string}` `` | `null`; `v`: `bigint`; `value`: `bigint`; `yParity`: `number`; } | \{ `accessList`: `AccessList`; `authorizationList`: `SignedAuthorizationList`; `blobVersionedHashes`: `undefined`; `blockHash`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `` `0x${string}` ``; `blockNumber`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `bigint`; `chainId`: `number`; `from`: `` `0x${string}` ``; `gas`: `bigint`; `gasPrice`: `undefined`; `hash`: `` `0x${string}` ``; `input`: `` `0x${string}` ``; `maxFeePerBlobGas`: `undefined`; `maxFeePerGas`: `bigint`; `maxPriorityFeePerGas`: `bigint`; `nonce`: `number`; `r`: `` `0x${string}` ``; `s`: `` `0x${string}` ``; `to`: `` `0x${string}` `` | `null`; `transactionIndex`: `blockTag` *extends* `"pending"` ? `true` : `false` *extends* `true` ? `null` : `number`; `type`: `"eip7702"`; `typeHex`: `` `0x${string}` `` | `null`; `v`: `bigint`; `value`: `bigint`; `yParity`: `number`; }>

The transaction information. GetTransactionReturnType

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const transaction = await client.getTransaction({
  hash: '0x4ca7ee652d57678f26e887c149ab0735f41de37bcad58c9f6d3ed5824f15b74d',
})
```

##### getTransactionConfirmations()

> **getTransactionConfirmations**: (`args`) => `Promise`\<`bigint`>

Returns the number of blocks passed (confirmations) since the transaction was processed on a block.

* Docs: [https://viem.sh/docs/actions/public/getTransactionConfirmations](https://viem.sh/docs/actions/public/getTransactionConfirmations)
* Example: [https://stackblitz.com/github/wevm/viem/tree/main/examples/transactions\_fetching-transactions](https://stackblitz.com/github/wevm/viem/tree/main/examples/transactions_fetching-transactions)
* JSON-RPC Methods: [`eth_getTransactionConfirmations`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getTransactionConfirmations)

###### Parameters

| Parameter | Type                                              | Description                           |
| --------- | ------------------------------------------------- | ------------------------------------- |
| `args`    | `GetTransactionConfirmationsParameters`\<`Chain`> | GetTransactionConfirmationsParameters |

###### Returns

`Promise`\<`bigint`>

The number of blocks passed since the transaction was processed. If confirmations is 0, then the Transaction has not been confirmed & processed yet. GetTransactionConfirmationsReturnType

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const confirmations = await client.getTransactionConfirmations({
  hash: '0x4ca7ee652d57678f26e887c149ab0735f41de37bcad58c9f6d3ed5824f15b74d',
})
```

##### getTransactionCount()

> **getTransactionCount**: (`args`) => `Promise`\<`number`>

Returns the number of [Transactions](https://viem.sh/docs/glossary/terms#transaction) an Account has broadcast / sent.

* Docs: [https://viem.sh/docs/actions/public/getTransactionCount](https://viem.sh/docs/actions/public/getTransactionCount)
* JSON-RPC Methods: [`eth_getTransactionCount`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_gettransactioncount)

###### Parameters

| Parameter | Type                            | Description                   |
| --------- | ------------------------------- | ----------------------------- |
| `args`    | `GetTransactionCountParameters` | GetTransactionCountParameters |

###### Returns

`Promise`\<`number`>

The number of transactions an account has sent. GetTransactionCountReturnType

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const transactionCount = await client.getTransactionCount({
  address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
})
```

##### getTransactionReceipt()

> **getTransactionReceipt**: (`args`) => `Promise`\<`TransactionReceipt`>

Returns the [Transaction Receipt](https://viem.sh/docs/glossary/terms#transaction-receipt) given a [Transaction](https://viem.sh/docs/glossary/terms#transaction) hash.

* Docs: [https://viem.sh/docs/actions/public/getTransactionReceipt](https://viem.sh/docs/actions/public/getTransactionReceipt)
* Example: [https://stackblitz.com/github/wevm/viem/tree/main/examples/transactions\_fetching-transactions](https://stackblitz.com/github/wevm/viem/tree/main/examples/transactions_fetching-transactions)
* JSON-RPC Methods: [`eth_getTransactionReceipt`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getTransactionReceipt)

###### Parameters

| Parameter | Type                              | Description                     |
| --------- | --------------------------------- | ------------------------------- |
| `args`    | `GetTransactionReceiptParameters` | GetTransactionReceiptParameters |

###### Returns

`Promise`\<`TransactionReceipt`>

The transaction receipt. GetTransactionReceiptReturnType

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const transactionReceipt = await client.getTransactionReceipt({
  hash: '0x4ca7ee652d57678f26e887c149ab0735f41de37bcad58c9f6d3ed5824f15b74d',
})
```

##### key

> **key**: `string`

A key for the client.

##### multicall()

> **multicall**: \<`contracts`, `allowFailure`>(`args`) => `Promise`\<`MulticallReturnType`\<`contracts`, `allowFailure`>>

Similar to [`readContract`](https://viem.sh/docs/contract/readContract), but batches up multiple functions on a contract in a single RPC call via the [`multicall3` contract](https://github.com/mds1/multicall).

* Docs: [https://viem.sh/docs/contract/multicall](https://viem.sh/docs/contract/multicall)

###### Type Parameters

| Type Parameter                              | Default type |
| ------------------------------------------- | ------------ |
| `contracts` *extends* readonly `unknown`\[] | -            |
| `allowFailure` *extends* `boolean`          | `true`       |

###### Parameters

| Parameter | Type                                                | Description         |
| --------- | --------------------------------------------------- | ------------------- |
| `args`    | `MulticallParameters`\<`contracts`, `allowFailure`> | MulticallParameters |

###### Returns

`Promise`\<`MulticallReturnType`\<`contracts`, `allowFailure`>>

An array of results with accompanying status. MulticallReturnType

###### Example

```ts theme={null}
import { createPublicClient, http, parseAbi } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const abi = parseAbi([
  'function balanceOf(address) view returns (uint256)',
  'function totalSupply() view returns (uint256)',
])
const result = await client.multicall({
  contracts: [
    {
      address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
      abi,
      functionName: 'balanceOf',
      args: ['0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'],
    },
    {
      address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
      abi,
      functionName: 'totalSupply',
    },
  ],
})
// [{ result: 424122n, status: 'success' }, { result: 1000000n, status: 'success' }]
```

##### name

> **name**: `string`

A name for the client.

##### pollingInterval

> **pollingInterval**: `number`

Frequency (in ms) for polling enabled actions & events. Defaults to 4\_000 milliseconds.

##### prepareTransactionRequest()

> **prepareTransactionRequest**: \<`request`, `chainOverride`, `accountOverride`>(`args`) => `Promise`\<\{ \[K in string | number | symbol]: (UnionRequiredBy\<Extract\<UnionOmit\<(...), (...)> & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)), IsNever\<(...)> extends true ? unknown : ExactPartial\<(...)>> & \{ chainId?: number }, ParameterTypeToParameters\<request\["parameters"] extends readonly PrepareTransactionRequestParameterType\[] ? any\[any]\[number] : "fees" | "gas" | "nonce" | "blobVersionedHashes" | "chainId" | "type">> & (unknown extends request\["kzg"] ? \{} : Pick\<request, "kzg">))\[K] }>

Prepares a transaction request for signing.

* Docs: [https://viem.sh/docs/actions/wallet/prepareTransactionRequest](https://viem.sh/docs/actions/wallet/prepareTransactionRequest)

###### Type Parameters

| Type Parameter                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | Default type |
| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------ |
| `request` *extends* `Omit`\<\{ `accessList`: `undefined`; `authorizationList`: `undefined`; `blobs`: `undefined`; `blobVersionedHashes`: `undefined`; `data`: `` `0x${string}` ``; `from`: `` `0x${string}` ``; `gas`: `bigint`; `gasPrice`: `bigint`; `kzg`: `undefined`; `maxFeePerBlobGas`: `undefined`; `maxFeePerGas`: `undefined`; `maxPriorityFeePerGas`: `undefined`; `nonce`: `number`; `sidecars`: `undefined`; `to`: `` `0x${string}` `` \| `null`; `type`: `"legacy"`; `value`: `bigint`; }, `"from"`> \| `Omit`\<\{ `accessList`: `AccessList`; `authorizationList`: `undefined`; `blobs`: `undefined`; `blobVersionedHashes`: `undefined`; `data`: `` `0x${string}` ``; `from`: `` `0x${string}` ``; `gas`: `bigint`; `gasPrice`: `bigint`; `kzg`: `undefined`; `maxFeePerBlobGas`: `undefined`; `maxFeePerGas`: `undefined`; `maxPriorityFeePerGas`: `undefined`; `nonce`: `number`; `sidecars`: `undefined`; `to`: `` `0x${string}` `` \| `null`; `type`: `"eip2930"`; `value`: `bigint`; }, `"from"`> \| `Omit`\<\{ `accessList`: `AccessList`; `authorizationList`: `undefined`; `blobs`: `undefined`; `blobVersionedHashes`: `undefined`; `data`: `` `0x${string}` ``; `from`: `` `0x${string}` ``; `gas`: `bigint`; `gasPrice`: `undefined`; `kzg`: `undefined`; `maxFeePerBlobGas`: `undefined`; `maxFeePerGas`: `bigint`; `maxPriorityFeePerGas`: `bigint`; `nonce`: `number`; `sidecars`: `undefined`; `to`: `` `0x${string}` `` \| `null`; `type`: `"eip1559"`; `value`: `bigint`; }, `"from"`> \| `Omit`\<\{ `accessList`: `AccessList`; `authorizationList`: `undefined`; `blobs`: readonly `` `0x${string}` ``\[] \| readonly `ByteArray`\[]; `blobVersionedHashes`: readonly `` `0x${string}` ``\[]; `data`: `` `0x${string}` ``; `from`: `` `0x${string}` ``; `gas`: `bigint`; `gasPrice`: `undefined`; `kzg`: `Kzg`; `maxFeePerBlobGas`: `bigint`; `maxFeePerGas`: `bigint`; `maxPriorityFeePerGas`: `bigint`; `nonce`: `number`; `sidecars`: readonly `BlobSidecar`\<`` `0x${string}` ``>\[]; `to`: `` `0x${string}` `` \| `null`; `type`: `"eip4844"`; `value`: `bigint`; }, `"from"`> \| `Omit`\<\{ `accessList`: `AccessList`; `authorizationList`: `AuthorizationList`\<`number`, `boolean`>; `blobs`: `undefined`; `blobVersionedHashes`: `undefined`; `data`: `` `0x${string}` ``; `from`: `` `0x${string}` ``; `gas`: `bigint`; `gasPrice`: `undefined`; `kzg`: `undefined`; `maxFeePerBlobGas`: `undefined`; `maxFeePerGas`: `bigint`; `maxPriorityFeePerGas`: `bigint`; `nonce`: `number`; `sidecars`: `undefined`; `to`: `` `0x${string}` `` \| `null`; `type`: `"eip7702"`; `value`: `bigint`; }, `"from"`> & `object` & `object` | -            |
| `chainOverride` *extends* `Chain` \| `undefined`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `undefined`  |
| `accountOverride` *extends* `` `0x${string}` `` \| `Account` \| `undefined`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `undefined`  |

###### Parameters

| Parameter | Type                                                                                                                     | Description                         |
| --------- | ------------------------------------------------------------------------------------------------------------------------ | ----------------------------------- |
| `args`    | `PrepareTransactionRequestParameters`\<`Chain`, `Account` \| `undefined`, `chainOverride`, `accountOverride`, `request`> | PrepareTransactionRequestParameters |

###### Returns

`Promise`\<\{ \[K in string | number | symbol]: (UnionRequiredBy\<Extract\<UnionOmit\<(...), (...)> & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)), IsNever\<(...)> extends true ? unknown : ExactPartial\<(...)>> & \{ chainId?: number }, ParameterTypeToParameters\<request\["parameters"] extends readonly PrepareTransactionRequestParameterType\[] ? any\[any]\[number] : "fees" | "gas" | "nonce" | "blobVersionedHashes" | "chainId" | "type">> & (unknown extends request\["kzg"] ? \{} : Pick\<request, "kzg">))\[K] }>

The transaction request. PrepareTransactionRequestReturnType

###### Examples

```ts theme={null}
import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})
const request = await client.prepareTransactionRequest({
  account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
  to: '0x0000000000000000000000000000000000000000',
  value: 1n,
})
```

```ts theme={null}
// Account Hoisting
import { createWalletClient, http } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  account: privateKeyToAccount('0x…'),
  chain: mainnet,
  transport: custom(window.ethereum),
})
const request = await client.prepareTransactionRequest({
  to: '0x0000000000000000000000000000000000000000',
  value: 1n,
})
```

##### readContract()

> **readContract**: \<`abi`, `functionName`, `args`>(`args`) => `Promise`\<`ReadContractReturnType`\<`abi`, `functionName`, `args`>>

Calls a read-only function on a contract, and returns the response.

* Docs: [https://viem.sh/docs/contract/readContract](https://viem.sh/docs/contract/readContract)
* Examples: [https://stackblitz.com/github/wevm/viem/tree/main/examples/contracts\_reading-contracts](https://stackblitz.com/github/wevm/viem/tree/main/examples/contracts_reading-contracts)

###### Type Parameters

| Type Parameter                                 |
| ---------------------------------------------- |
| `abi` *extends* readonly `unknown`\[] \| `Abi` |
| `functionName` *extends* `string`              |
| `args` *extends* `unknown`                     |

###### Parameters

| Parameter | Type                                                     | Description            |
| --------- | -------------------------------------------------------- | ---------------------- |
| `args`    | `ReadContractParameters`\<`abi`, `functionName`, `args`> | ReadContractParameters |

###### Returns

`Promise`\<`ReadContractReturnType`\<`abi`, `functionName`, `args`>>

The response from the contract. Type is inferred. ReadContractReturnType

###### Remarks

A "read-only" function (constant function) on a Solidity contract is denoted by a `view` or `pure` keyword. They can only read the state of the contract, and cannot make any changes to it. Since read-only methods do not change the state of the contract, they do not require any gas to be executed, and can be called by any user without the need to pay for gas.

Internally, uses a [Public Client](https://viem.sh/docs/clients/public) to call the [`call` action](https://viem.sh/docs/actions/public/call) with [ABI-encoded `data`](https://viem.sh/docs/contract/encodeFunctionData).

###### Example

```ts theme={null}
import { createPublicClient, http, parseAbi } from 'viem'
import { mainnet } from 'viem/chains'
import { readContract } from 'viem/contract'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const result = await client.readContract({
  address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
  abi: parseAbi(['function balanceOf(address) view returns (uint256)']),
  functionName: 'balanceOf',
  args: ['0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'],
})
// 424122n
```

##### request

> **request**: `EIP1193RequestFn`\<`PublicRpcSchema`>

Request function wrapped with friendly error handling

##### sendRawTransaction()

> **sendRawTransaction**: (`args`) => `Promise`\<`` `0x${string}` ``>

Sends a **signed** transaction to the network

* Docs: [https://viem.sh/docs/actions/wallet/sendRawTransaction](https://viem.sh/docs/actions/wallet/sendRawTransaction)
* JSON-RPC Method: [`eth_sendRawTransaction`](https://ethereum.github.io/execution-apis/api-documentation/)

###### Parameters

| Parameter | Type                           |
| --------- | ------------------------------ |
| `args`    | `SendRawTransactionParameters` |

###### Returns

`Promise`\<`` `0x${string}` ``>

The transaction hash. SendRawTransactionReturnType

###### Example

```ts theme={null}
import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'
import { sendRawTransaction } from 'viem/wallet'

const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum),
})

const hash = await client.sendRawTransaction({
  serializedTransaction: '0x02f850018203118080825208808080c080a04012522854168b27e5dc3d5839bab5e6b39e1a0ffd343901ce1622e3d64b48f1a04e00902ae0502c4728cbf12156290df99c3ed7de85b1dbfe20b5c36931733a33'
})
```

##### ~~simulate()~~

> **simulate**: \<`calls`>(`args`) => `Promise`\<`SimulateBlocksReturnType`\<`calls`>>

###### Type Parameters

| Type Parameter                          |
| --------------------------------------- |
| `calls` *extends* readonly `unknown`\[] |

###### Parameters

| Parameter | Type                                 |
| --------- | ------------------------------------ |
| `args`    | `SimulateBlocksParameters`\<`calls`> |

###### Returns

`Promise`\<`SimulateBlocksReturnType`\<`calls`>>

###### Deprecated

Use `simulateBlocks` instead.

##### simulateBlocks()

> **simulateBlocks**: \<`calls`>(`args`) => `Promise`\<`SimulateBlocksReturnType`\<`calls`>>

Simulates a set of calls on block(s) with optional block and state overrides.

###### Type Parameters

| Type Parameter                          |
| --------------------------------------- |
| `calls` *extends* readonly `unknown`\[] |

###### Parameters

| Parameter | Type                                 |
| --------- | ------------------------------------ |
| `args`    | `SimulateBlocksParameters`\<`calls`> |

###### Returns

`Promise`\<`SimulateBlocksReturnType`\<`calls`>>

Simulated blocks. SimulateReturnType

###### Example

```ts theme={null}
import { createPublicClient, http, parseEther } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})

const result = await client.simulateBlocks({
  blocks: [{
    blockOverrides: {
      number: 69420n,
    },
    calls: [{
      {
        account: '0x5a0b54d5dc17e482fe8b0bdca5320161b95fb929',
        data: '0xdeadbeef',
        to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
      },
      {
        account: '0x5a0b54d5dc17e482fe8b0bdca5320161b95fb929',
        to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
        value: parseEther('1'),
      },
    }],
    stateOverrides: [{
      address: '0x5a0b54d5dc17e482fe8b0bdca5320161b95fb929',
      balance: parseEther('10'),
    }],
  }]
})
```

##### simulateCalls()

> **simulateCalls**: \<`calls`>(`args`) => `Promise`\<`SimulateCallsReturnType`\<`calls`>>

Simulates a set of calls.

###### Type Parameters

| Type Parameter                          |
| --------------------------------------- |
| `calls` *extends* readonly `unknown`\[] |

###### Parameters

| Parameter | Type                                |
| --------- | ----------------------------------- |
| `args`    | `SimulateCallsParameters`\<`calls`> |

###### Returns

`Promise`\<`SimulateCallsReturnType`\<`calls`>>

Results. SimulateCallsReturnType

###### Example

```ts theme={null}
import { createPublicClient, http, parseEther } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})

const result = await client.simulateCalls({
  account: '0x5a0b54d5dc17e482fe8b0bdca5320161b95fb929',
  calls: [{
    {
      data: '0xdeadbeef',
      to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
    },
    {
      to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
      value: parseEther('1'),
    },
  ]
})
```

##### simulateContract()

> **simulateContract**: \<`abi`, `functionName`, `args`, `chainOverride`, `accountOverride`>(`args`) => `Promise`\<`SimulateContractReturnType`\<`abi`, `functionName`, `args`, `Chain`, `Account` | `undefined`, `chainOverride`, `accountOverride`>>

Simulates/validates a contract interaction. This is useful for retrieving **return data** and **revert reasons** of contract write functions.

* Docs: [https://viem.sh/docs/contract/simulateContract](https://viem.sh/docs/contract/simulateContract)
* Examples: [https://stackblitz.com/github/wevm/viem/tree/main/examples/contracts\_writing-to-contracts](https://stackblitz.com/github/wevm/viem/tree/main/examples/contracts_writing-to-contracts)

###### Type Parameters

| Type Parameter                                                              | Default type |
| --------------------------------------------------------------------------- | ------------ |
| `abi` *extends* readonly `unknown`\[] \| `Abi`                              | -            |
| `functionName` *extends* `string`                                           | -            |
| `args` *extends* `unknown`                                                  | -            |
| `chainOverride` *extends* `Chain` \| `undefined`                            | -            |
| `accountOverride` *extends* `` `0x${string}` `` \| `Account` \| `undefined` | `undefined`  |

###### Parameters

| Parameter | Type                                                                                                      | Description                |
| --------- | --------------------------------------------------------------------------------------------------------- | -------------------------- |
| `args`    | `SimulateContractParameters`\<`abi`, `functionName`, `args`, `Chain`, `chainOverride`, `accountOverride`> | SimulateContractParameters |

###### Returns

`Promise`\<`SimulateContractReturnType`\<`abi`, `functionName`, `args`, `Chain`, `Account` | `undefined`, `chainOverride`, `accountOverride`>>

The simulation result and write request. SimulateContractReturnType

###### Remarks

This function does not require gas to execute and ***does not*** change the state of the blockchain. It is almost identical to [`readContract`](https://viem.sh/docs/contract/readContract), but also supports contract write functions.

Internally, uses a [Public Client](https://viem.sh/docs/clients/public) to call the [`call` action](https://viem.sh/docs/actions/public/call) with [ABI-encoded `data`](https://viem.sh/docs/contract/encodeFunctionData).

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const result = await client.simulateContract({
  address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
  abi: parseAbi(['function mint(uint32) view returns (uint32)']),
  functionName: 'mint',
  args: ['69420'],
  account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
})
```

##### transport

> **transport**: `TransportConfig`\<`"http"`, `EIP1193RequestFn`> & `object`

The RPC transport

###### Type Declaration

###### fetchOptions?

> `optional` **fetchOptions**: `Omit`\<`RequestInit`, `"body"`>

###### url?

> `optional` **url**: `string`

##### type

> **type**: `string`

The type of client.

##### uid

> **uid**: `string`

A unique ID for the client.

##### uninstallFilter()

> **uninstallFilter**: (`args`) => `Promise`\<`boolean`>

Destroys a Filter that was created from one of the following Actions:

* [`createBlockFilter`](https://viem.sh/docs/actions/public/createBlockFilter)

* [`createEventFilter`](https://viem.sh/docs/actions/public/createEventFilter)

* [`createPendingTransactionFilter`](https://viem.sh/docs/actions/public/createPendingTransactionFilter)

* Docs: [https://viem.sh/docs/actions/public/uninstallFilter](https://viem.sh/docs/actions/public/uninstallFilter)

* JSON-RPC Methods: [`eth_uninstallFilter`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_uninstallFilter)

###### Parameters

| Parameter | Type                        | Description               |
| --------- | --------------------------- | ------------------------- |
| `args`    | `UninstallFilterParameters` | UninstallFilterParameters |

###### Returns

`Promise`\<`boolean`>

A boolean indicating if the Filter was successfully uninstalled. UninstallFilterReturnType

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'
import { createPendingTransactionFilter, uninstallFilter } from 'viem/public'

const filter = await client.createPendingTransactionFilter()
const uninstalled = await client.uninstallFilter({ filter })
// true
```

##### verifyMessage()

> **verifyMessage**: (`args`) => `Promise`\<`boolean`>

Verify that a message was signed by the provided address.

Compatible with Smart Contract Accounts & Externally Owned Accounts via [ERC-6492](https://eips.ethereum.org/EIPS/eip-6492).

* Docs [https://viem.sh/docs/actions/public/verifyMessage](https://viem.sh/docs/actions/public/verifyMessage)

###### Parameters

| Parameter                                 | Type                                                                                                                                                                                                                                                                                                              | Description                                                                             |
| ----------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------- |
| `args`                                    | \{ `address`: `` `0x${string}` ``; `blockNumber`: `bigint`; `blockTag`: `BlockTag`; `factory`: `` `0x${string}` ``; `factoryData`: `` `0x${string}` ``; `message`: `SignableMessage`; `signature`: `` `0x${string}` `` \| `Signature` \| `ByteArray`; `universalSignatureVerifierAddress`: `` `0x${string}` ``; } | -                                                                                       |
| `args.address`                            | `` `0x${string}` ``                                                                                                                                                                                                                                                                                               | The address that signed the original message.                                           |
| `args.blockNumber`?                       | `bigint`                                                                                                                                                                                                                                                                                                          | The balance of the account at a block number.                                           |
| `args.blockTag`?                          | `BlockTag`                                                                                                                                                                                                                                                                                                        | The balance of the account at a block tag. **Default** `'latest'`                       |
| `args.factory`?                           | `` `0x${string}` ``                                                                                                                                                                                                                                                                                               | -                                                                                       |
| `args.factoryData`?                       | `` `0x${string}` ``                                                                                                                                                                                                                                                                                               | -                                                                                       |
| `args.message`                            | `SignableMessage`                                                                                                                                                                                                                                                                                                 | The message to be verified.                                                             |
| `args.signature`                          | `` `0x${string}` `` \| `Signature` \| `ByteArray`                                                                                                                                                                                                                                                                 | The signature that was generated by signing the message with the address's private key. |
| `args.universalSignatureVerifierAddress`? | `` `0x${string}` ``                                                                                                                                                                                                                                                                                               | -                                                                                       |

###### Returns

`Promise`\<`boolean`>

Whether or not the signature is valid. VerifyMessageReturnType

##### verifySiweMessage()

> **verifySiweMessage**: (`args`) => `Promise`\<`boolean`>

Verifies [EIP-4361](https://eips.ethereum.org/EIPS/eip-4361) formatted message was signed.

Compatible with Smart Contract Accounts & Externally Owned Accounts via [ERC-6492](https://eips.ethereum.org/EIPS/eip-6492).

* Docs [https://viem.sh/docs/siwe/actions/verifySiweMessage](https://viem.sh/docs/siwe/actions/verifySiweMessage)

###### Parameters

| Parameter           | Type                                                                                                                                                                                                                    | Description                                                                                      |
| ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
| `args`              | \{ `address`: `` `0x${string}` ``; `blockNumber`: `bigint`; `blockTag`: `BlockTag`; `domain`: `string`; `message`: `string`; `nonce`: `string`; `scheme`: `string`; `signature`: `` `0x${string}` ``; `time`: `Date`; } | -                                                                                                |
| `args.address`?     | `` `0x${string}` ``                                                                                                                                                                                                     | Ethereum address to check against.                                                               |
| `args.blockNumber`? | `bigint`                                                                                                                                                                                                                | The balance of the account at a block number.                                                    |
| `args.blockTag`?    | `BlockTag`                                                                                                                                                                                                              | The balance of the account at a block tag. **Default** `'latest'`                                |
| `args.domain`?      | `string`                                                                                                                                                                                                                | [RFC 3986](https://www.rfc-editor.org/rfc/rfc3986) authority to check against.                   |
| `args.message`      | `string`                                                                                                                                                                                                                | EIP-4361 formatted message.                                                                      |
| `args.nonce`?       | `string`                                                                                                                                                                                                                | Random string to check against.                                                                  |
| `args.scheme`?      | `string`                                                                                                                                                                                                                | [RFC 3986](https://www.rfc-editor.org/rfc/rfc3986#section-3.1) URI scheme to check against.      |
| `args.signature`    | `` `0x${string}` ``                                                                                                                                                                                                     | Signature to check against.                                                                      |
| `args.time`?        | `Date`                                                                                                                                                                                                                  | Current time to check optional `expirationTime` and `notBefore` fields. **Default** `new Date()` |

###### Returns

`Promise`\<`boolean`>

Whether or not the signature is valid. VerifySiweMessageReturnType

##### verifyTypedData()

> **verifyTypedData**: (`args`) => `Promise`\<`boolean`>

Verify that typed data was signed by the provided address.

* Docs [https://viem.sh/docs/actions/public/verifyTypedData](https://viem.sh/docs/actions/public/verifyTypedData)

###### Parameters

| Parameter | Type                        |
| --------- | --------------------------- |
| `args`    | `VerifyTypedDataParameters` |

###### Returns

`Promise`\<`boolean`>

Whether or not the signature is valid. VerifyTypedDataReturnType

##### waitForTransactionReceipt()

> **waitForTransactionReceipt**: (`args`) => `Promise`\<`TransactionReceipt`>

Waits for the [Transaction](https://viem.sh/docs/glossary/terms#transaction) to be included on a [Block](https://viem.sh/docs/glossary/terms#block) (one confirmation), and then returns the [Transaction Receipt](https://viem.sh/docs/glossary/terms#transaction-receipt). If the Transaction reverts, then the action will throw an error.

* Docs: [https://viem.sh/docs/actions/public/waitForTransactionReceipt](https://viem.sh/docs/actions/public/waitForTransactionReceipt)
* Example: [https://stackblitz.com/github/wevm/viem/tree/main/examples/transactions\_sending-transactions](https://stackblitz.com/github/wevm/viem/tree/main/examples/transactions_sending-transactions)
* JSON-RPC Methods:
  * Polls [`eth_getTransactionReceipt`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getTransactionReceipt) on each block until it has been processed.
  * If a Transaction has been replaced:
    * Calls [`eth_getBlockByNumber`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getblockbynumber) and extracts the transactions
    * Checks if one of the Transactions is a replacement
    * If so, calls [`eth_getTransactionReceipt`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getTransactionReceipt).

###### Parameters

| Parameter | Type                                            | Description                         |
| --------- | ----------------------------------------------- | ----------------------------------- |
| `args`    | `WaitForTransactionReceiptParameters`\<`Chain`> | WaitForTransactionReceiptParameters |

###### Returns

`Promise`\<`TransactionReceipt`>

The transaction receipt. WaitForTransactionReceiptReturnType

###### Remarks

The `waitForTransactionReceipt` action additionally supports Replacement detection (e.g. sped up Transactions).

Transactions can be replaced when a user modifies their transaction in their wallet (to speed up or cancel). Transactions are replaced when they are sent from the same nonce.

There are 3 types of Transaction Replacement reasons:

* `repriced`: The gas price has been modified (e.g. different `maxFeePerGas`)
* `cancelled`: The Transaction has been cancelled (e.g. `value === 0n`)
* `replaced`: The Transaction has been replaced (e.g. different `value` or `data`)

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const transactionReceipt = await client.waitForTransactionReceipt({
  hash: '0x4ca7ee652d57678f26e887c149ab0735f41de37bcad58c9f6d3ed5824f15b74d',
})
```

##### watchBlockNumber()

> **watchBlockNumber**: (`args`) => `WatchBlockNumberReturnType`

Watches and returns incoming block numbers.

* Docs: [https://viem.sh/docs/actions/public/watchBlockNumber](https://viem.sh/docs/actions/public/watchBlockNumber)
* Examples: [https://stackblitz.com/github/wevm/viem/tree/main/examples/blocks\_watching-blocks](https://stackblitz.com/github/wevm/viem/tree/main/examples/blocks_watching-blocks)
* JSON-RPC Methods:
  * When `poll: true`, calls [`eth_blockNumber`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_blocknumber) on a polling interval.
  * When `poll: false` & WebSocket Transport, uses a WebSocket subscription via [`eth_subscribe`](https://docs.alchemy.com/reference/eth-subscribe-polygon) and the `"newHeads"` event.

###### Parameters

| Parameter | Type                         | Description                |
| --------- | ---------------------------- | -------------------------- |
| `args`    | `WatchBlockNumberParameters` | WatchBlockNumberParameters |

###### Returns

`WatchBlockNumberReturnType`

A function that can be invoked to stop watching for new block numbers. WatchBlockNumberReturnType

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const unwatch = await client.watchBlockNumber({
  onBlockNumber: (blockNumber) => console.log(blockNumber),
})
```

##### watchBlocks()

> **watchBlocks**: \<`includeTransactions`, `blockTag`>(`args`) => `WatchBlocksReturnType`

Watches and returns information for incoming blocks.

* Docs: [https://viem.sh/docs/actions/public/watchBlocks](https://viem.sh/docs/actions/public/watchBlocks)
* Examples: [https://stackblitz.com/github/wevm/viem/tree/main/examples/blocks\_watching-blocks](https://stackblitz.com/github/wevm/viem/tree/main/examples/blocks_watching-blocks)
* JSON-RPC Methods:
  * When `poll: true`, calls [`eth_getBlockByNumber`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getBlockByNumber) on a polling interval.
  * When `poll: false` & WebSocket Transport, uses a WebSocket subscription via [`eth_subscribe`](https://docs.alchemy.com/reference/eth-subscribe-polygon) and the `"newHeads"` event.

###### Type Parameters

| Type Parameter                            | Default type |
| ----------------------------------------- | ------------ |
| `includeTransactions` *extends* `boolean` | `false`      |
| `blockTag` *extends* `BlockTag`           | `"latest"`   |

###### Parameters

| Parameter | Type                                                                                  | Description           |
| --------- | ------------------------------------------------------------------------------------- | --------------------- |
| `args`    | `WatchBlocksParameters`\<`HttpTransport`, `Chain`, `includeTransactions`, `blockTag`> | WatchBlocksParameters |

###### Returns

`WatchBlocksReturnType`

A function that can be invoked to stop watching for new block numbers. WatchBlocksReturnType

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const unwatch = await client.watchBlocks({
  onBlock: (block) => console.log(block),
})
```

##### watchContractEvent()

> **watchContractEvent**: \<`abi`, `eventName`, `strict`>(`args`) => `WatchContractEventReturnType`

Watches and returns emitted contract event logs.

* Docs: [https://viem.sh/docs/contract/watchContractEvent](https://viem.sh/docs/contract/watchContractEvent)

###### Type Parameters

| Type Parameter                                 | Default type |
| ---------------------------------------------- | ------------ |
| `abi` *extends* readonly `unknown`\[] \| `Abi` | -            |
| `eventName` *extends* `string`                 | -            |
| `strict` *extends* `boolean` \| `undefined`    | `undefined`  |

###### Parameters

| Parameter | Type                                                                           | Description                  |
| --------- | ------------------------------------------------------------------------------ | ---------------------------- |
| `args`    | `WatchContractEventParameters`\<`abi`, `eventName`, `strict`, `HttpTransport`> | WatchContractEventParameters |

###### Returns

`WatchContractEventReturnType`

A function that can be invoked to stop watching for new event logs. WatchContractEventReturnType

###### Remarks

This Action will batch up all the event logs found within the [`pollingInterval`](https://viem.sh/docs/contract/watchContractEvent#pollinginterval-optional), and invoke them via [`onLogs`](https://viem.sh/docs/contract/watchContractEvent#onLogs).

`watchContractEvent` will attempt to create an [Event Filter](https://viem.sh/docs/contract/createContractEventFilter) and listen to changes to the Filter per polling interval, however, if the RPC Provider does not support Filters (e.g. `eth_newFilter`), then `watchContractEvent` will fall back to using [`getLogs`](https://viem.sh/docs/actions/public/getLogs) instead.

###### Example

```ts theme={null}
import { createPublicClient, http, parseAbi } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const unwatch = client.watchContractEvent({
  address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
  abi: parseAbi(['event Transfer(address indexed from, address indexed to, uint256 value)']),
  eventName: 'Transfer',
  args: { from: '0xc961145a54C96E3aE9bAA048c4F4D6b04C13916b' },
  onLogs: (logs) => console.log(logs),
})
```

##### watchEvent()

> **watchEvent**: \<`abiEvent`, `abiEvents`, `strict`>(`args`) => `WatchEventReturnType`

Watches and returns emitted [Event Logs](https://viem.sh/docs/glossary/terms#event-log).

* Docs: [https://viem.sh/docs/actions/public/watchEvent](https://viem.sh/docs/actions/public/watchEvent)
* JSON-RPC Methods:
  * **RPC Provider supports `eth_newFilter`:**
    * Calls [`eth_newFilter`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_newfilter) to create a filter (called on initialize).
    * On a polling interval, it will call [`eth_getFilterChanges`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getfilterchanges).
  * **RPC Provider does not support `eth_newFilter`:**
    * Calls [`eth_getLogs`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getlogs) for each block between the polling interval.

###### Type Parameters

| Type Parameter                                                                       | Default type                                                  |
| ------------------------------------------------------------------------------------ | ------------------------------------------------------------- |
| `abiEvent` *extends* `AbiEvent` \| `undefined`                                       | `undefined`                                                   |
| `abiEvents` *extends* readonly `unknown`\[] \| readonly `AbiEvent`\[] \| `undefined` | `abiEvent` *extends* `AbiEvent` ? \[`abiEvent`] : `undefined` |
| `strict` *extends* `boolean` \| `undefined`                                          | `undefined`                                                   |

###### Parameters

| Parameter | Type                                                                        | Description          |
| --------- | --------------------------------------------------------------------------- | -------------------- |
| `args`    | `WatchEventParameters`\<`abiEvent`, `abiEvents`, `strict`, `HttpTransport`> | WatchEventParameters |

###### Returns

`WatchEventReturnType`

A function that can be invoked to stop watching for new Event Logs. WatchEventReturnType

###### Remarks

This Action will batch up all the Event Logs found within the [`pollingInterval`](https://viem.sh/docs/actions/public/watchEvent#pollinginterval-optional), and invoke them via [`onLogs`](https://viem.sh/docs/actions/public/watchEvent#onLogs).

`watchEvent` will attempt to create an [Event Filter](https://viem.sh/docs/actions/public/createEventFilter) and listen to changes to the Filter per polling interval, however, if the RPC Provider does not support Filters (e.g. `eth_newFilter`), then `watchEvent` will fall back to using [`getLogs`](https://viem.sh/docs/actions/public/getLogs) instead.

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const unwatch = client.watchEvent({
  onLogs: (logs) => console.log(logs),
})
```

##### watchPendingTransactions()

> **watchPendingTransactions**: (`args`) => `WatchPendingTransactionsReturnType`

Watches and returns pending transaction hashes.

* Docs: [https://viem.sh/docs/actions/public/watchPendingTransactions](https://viem.sh/docs/actions/public/watchPendingTransactions)
* JSON-RPC Methods:
  * When `poll: true`
    * Calls [`eth_newPendingTransactionFilter`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_newpendingtransactionfilter) to initialize the filter.
    * Calls [`eth_getFilterChanges`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getFilterChanges) on a polling interval.
  * When `poll: false` & WebSocket Transport, uses a WebSocket subscription via [`eth_subscribe`](https://docs.alchemy.com/reference/eth-subscribe-polygon) and the `"newPendingTransactions"` event.

###### Parameters

| Parameter | Type                                                   | Description                        |
| --------- | ------------------------------------------------------ | ---------------------------------- |
| `args`    | `WatchPendingTransactionsParameters`\<`HttpTransport`> | WatchPendingTransactionsParameters |

###### Returns

`WatchPendingTransactionsReturnType`

A function that can be invoked to stop watching for new pending transaction hashes. WatchPendingTransactionsReturnType

###### Remarks

This Action will batch up all the pending transactions found within the [`pollingInterval`](https://viem.sh/docs/actions/public/watchPendingTransactions#pollinginterval-optional), and invoke them via [`onTransactions`](https://viem.sh/docs/actions/public/watchPendingTransactions#ontransactions).

###### Example

```ts theme={null}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
const unwatch = await client.watchPendingTransactions({
  onTransactions: (hashes) => console.log(hashes),
})
```

***

### send()

> **send**\<`T`>(`to`, `token`, `amount`, `options`?): `Promise`\<[`Transaction`](../type-aliases/Transaction)\<`T` *extends* `PrepareOnly`\<`true`> ? `true` : `false`>>

Defined in: [packages/wallets/src/wallets/wallet.ts:335](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L335)

Send a token to a wallet or user locator

#### Type Parameters

| Type Parameter                                             | Default type |
| ---------------------------------------------------------- | ------------ |
| `T` *extends* `SendTokenTransactionOptions` \| `undefined` | `undefined`  |

#### Parameters

| Parameter  | Type                      | Description                             |
| ---------- | ------------------------- | --------------------------------------- |
| `to`       | `string` \| `UserLocator` | The recipient (address or user locator) |
| `token`    | `string`                  | The token (address or currency symbol)  |
| `amount`   | `string`                  | The amount to send (decimal units)      |
| `options`? | `T`                       | The options for the transaction         |

#### Returns

`Promise`\<[`Transaction`](../type-aliases/Transaction)\<`T` *extends* `PrepareOnly`\<`true`> ? `true` : `false`>>

The transaction

#### Inherited from

[`Wallet`](./Wallet).[`send`](./Wallet#send)

***

### sendTransaction()

> **sendTransaction**\<`T`>(`params`): `Promise`\<[`Transaction`](../type-aliases/Transaction)\<`T`\[`"options"`] *extends* `PrepareOnly`\<`true`> ? `true` : `false`>>

Defined in: [packages/wallets/src/wallets/evm.ts:55](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/evm.ts#L55)

Send a raw EVM transaction.

#### Type Parameters

| Type Parameter                                                             |
| -------------------------------------------------------------------------- |
| `T` *extends* [`EVMTransactionInput`](../type-aliases/EVMTransactionInput) |

#### Parameters

| Parameter | Type | Description                                                             |
| --------- | ---- | ----------------------------------------------------------------------- |
| `params`  | `T`  | The transaction parameters (raw transaction, ABI call, or encoded data) |

#### Returns

`Promise`\<[`Transaction`](../type-aliases/Transaction)\<`T`\[`"options"`] *extends* `PrepareOnly`\<`true`> ? `true` : `false`>>

The transaction result

***

### signMessage()

> **signMessage**\<`T`>(`params`): `Promise`\<[`Signature`](../type-aliases/Signature)\<`T`\[`"options"`] *extends* `PrepareOnly`\<`true`> ? `true` : `false`>>

Defined in: [packages/wallets/src/wallets/evm.ts:95](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/evm.ts#L95)

Sign a message with the wallet's private key.

#### Type Parameters

| Type Parameter                   |
| -------------------------------- |
| `T` *extends* `SignMessageInput` |

#### Parameters

| Parameter | Type | Description         |
| --------- | ---- | ------------------- |
| `params`  | `T`  | The message to sign |

#### Returns

`Promise`\<[`Signature`](../type-aliases/Signature)\<`T`\[`"options"`] *extends* `PrepareOnly`\<`true`> ? `true` : `false`>>

The signature

***

### signTypedData()

> **signTypedData**\<`T`>(`params`): `Promise`\<[`Signature`](../type-aliases/Signature)\<`T`\[`"options"`] *extends* `PrepareOnly`\<`true`> ? `true` : `false`>>

Defined in: [packages/wallets/src/wallets/evm.ts:141](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/evm.ts#L141)

Sign EIP-712 typed data.

#### Type Parameters

| Type Parameter                     |
| ---------------------------------- |
| `T` *extends* `SignTypedDataInput` |

#### Parameters

| Parameter | Type | Description                                                            |
| --------- | ---- | ---------------------------------------------------------------------- |
| `params`  | `T`  | The typed data parameters (domain, types, message, primaryType, chain) |

#### Returns

`Promise`\<[`Signature`](../type-aliases/Signature)\<`T`\[`"options"`] *extends* `PrepareOnly`\<`true`> ? `true` : `false`>>

The signature

***

### stagingFund()

> **stagingFund**(`amount`, `chain`?): `Promise`\<`FundWalletResponse`>

Defined in: [packages/wallets/src/wallets/wallet.ts:166](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L166)

Funds the wallet with Crossmint's stablecoin (USDXM).

**Note:** This method is only available in staging environments and exclusively supports USDXM tokens.
It cannot be used in production environments.

#### Parameters

| Parameter | Type                             | Description                                                                 |
| --------- | -------------------------------- | --------------------------------------------------------------------------- |
| `amount`  | `number`                         | The amount of USDXM to fund the wallet with                                 |
| `chain`?  | [`Chain`](../type-aliases/Chain) | Optional chain to fund on. If not provided, uses the wallet's default chain |

#### Returns

`Promise`\<`FundWalletResponse`>

The funding response

#### Throws

If the funding operation fails or if called in a production environment

#### Inherited from

[`Wallet`](./Wallet).[`stagingFund`](./Wallet#stagingfund)

***

### from()

> `static` **from**(`wallet`): `EVMWallet`

Defined in: [packages/wallets/src/wallets/evm.ts:35](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/evm.ts#L35)

#### Parameters

| Parameter | Type                                                    |
| --------- | ------------------------------------------------------- |
| `wallet`  | [`Wallet`](./Wallet)\<[`Chain`](../type-aliases/Chain)> |

#### Returns

`EVMWallet`


# SolanaWallet
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/classes/SolanaWallet



Defined in: [packages/wallets/src/wallets/solana.ts:17](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/solana.ts#L17)

## Extends

* [`Wallet`](./Wallet)\<[`SolanaChain`](../type-aliases/SolanaChain)>

## Constructors

### new SolanaWallet()

> **new SolanaWallet**(`wallet`): `SolanaWallet`

Defined in: [packages/wallets/src/wallets/solana.ts:18](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/solana.ts#L18)

#### Parameters

| Parameter | Type                              |
| --------- | --------------------------------- |
| `wallet`  | [`Wallet`](./Wallet)\<`"solana"`> |

#### Returns

`SolanaWallet`

#### Overrides

[`Wallet`](./Wallet).[`constructor`](./Wallet#constructor)

## Properties

| Property        | Type                             | Inherited from                                     | Defined in                                                                                                                                   |
| --------------- | -------------------------------- | -------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| <a /> `address` | `string`                         | [`Wallet`](./Wallet).[`address`](./Wallet#address) | [packages/wallets/src/wallets/wallet.ts:62](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L62) |
| <a /> `alias?`  | `string`                         | [`Wallet`](./Wallet).[`alias`](./Wallet#alias)     | [packages/wallets/src/wallets/wallet.ts:64](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L64) |
| <a /> `chain`   | `"solana"`                       | [`Wallet`](./Wallet).[`chain`](./Wallet#chain)     | [packages/wallets/src/wallets/wallet.ts:61](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L61) |
| <a /> `owner?`  | `string`                         | [`Wallet`](./Wallet).[`owner`](./Wallet#owner)     | [packages/wallets/src/wallets/wallet.ts:63](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L63) |
| <a /> `signer`  | [`Signer`](../interfaces/Signer) | [`Wallet`](./Wallet).[`signer`](./Wallet#signer)   | [packages/wallets/src/wallets/wallet.ts:65](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L65) |

## Methods

### addDelegatedSigner()

> **addDelegatedSigner**\<`T`>(`params`): `Promise`\<`T` *extends* `PrepareOnly`\<`true`> ? `object` : `void`>

Defined in: [packages/wallets/src/wallets/wallet.ts:465](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L465)

Add a delegated signer to the wallet

#### Type Parameters

| Type Parameter                                           | Default type |
| -------------------------------------------------------- | ------------ |
| `T` *extends* `AddDelegatedSignerOptions` \| `undefined` | `undefined`  |

#### Parameters

| Parameter         | Type                                                                                                                                                     |
| ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `params`          | \{ `options`: `T`; `signer`: `string` \| \{ `id`: `string`; `name`: `string`; `publicKey`: \{ `x`: `string`; `y`: `string`; }; `type`: `"passkey"`; }; } |
| `params.options`? | `T`                                                                                                                                                      |
| `params.signer`   | `string` \| \{ `id`: `string`; `name`: `string`; `publicKey`: \{ `x`: `string`; `y`: `string`; }; `type`: `"passkey"`; }                                 |

#### Returns

`Promise`\<`T` *extends* `PrepareOnly`\<`true`> ? `object` : `void`>

#### Inherited from

[`Wallet`](./Wallet).[`addDelegatedSigner`](./Wallet#adddelegatedsigner)

***

### approve()

> **approve**\<`T`>(`params`): `Promise`\<`ApproveResult`\<`T`>>

Defined in: [packages/wallets/src/wallets/wallet.ts:423](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L423)

Approve a transaction or signature

#### Type Parameters

| Type Parameter                |
| ----------------------------- |
| `T` *extends* `ApproveParams` |

#### Parameters

| Parameter | Type | Description    |
| --------- | ---- | -------------- |
| `params`  | `T`  | The parameters |

#### Returns

`Promise`\<`ApproveResult`\<`T`>>

The transaction or signature

#### Inherited from

[`Wallet`](./Wallet).[`approve`](./Wallet#approve)

***

### ~~approveTransaction()~~

> **approveTransaction**(`params`): `Promise`\<`Error`>

Defined in: [packages/wallets/src/wallets/wallet.ts:399](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L399)

#### Parameters

| Parameter | Type            | Description    |
| --------- | --------------- | -------------- |
| `params`  | `ApproveParams` | The parameters |

#### Returns

`Promise`\<`Error`>

The transaction

#### Deprecated

Use `approve` instead.
Approve a transaction

#### Inherited from

[`Wallet`](./Wallet).[`approveTransaction`](./Wallet#approvetransaction)

***

### balances()

> **balances**(`tokens`?): `Promise`\<[`Balances`](../type-aliases/Balances)\<`"solana"`>>

Defined in: [packages/wallets/src/wallets/wallet.ts:118](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L118)

Get the wallet balances - always includes USDC and native token (ETH/SOL)

#### Parameters

| Parameter | Type        | Description                                                                        |
| --------- | ----------- | ---------------------------------------------------------------------------------- |
| `tokens`? | `string`\[] | Additional tokens to request (optional: native token and usdc are always included) |

#### Returns

`Promise`\<[`Balances`](../type-aliases/Balances)\<`"solana"`>>

The balances returns nativeToken, usdc, tokens

#### Throws

If the balances cannot be retrieved

#### Inherited from

[`Wallet`](./Wallet).[`balances`](./Wallet#balances)

***

### delegatedSigners()

> **delegatedSigners**(): `Promise`\<[`DelegatedSigner`](../type-aliases/DelegatedSigner)\[]>

Defined in: [packages/wallets/src/wallets/wallet.ts:554](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L554)

List the delegated signers for this wallet.

#### Returns

`Promise`\<[`DelegatedSigner`](../type-aliases/DelegatedSigner)\[]>

The delegated signers

#### Inherited from

[`Wallet`](./Wallet).[`delegatedSigners`](./Wallet#delegatedsigners)

***

### experimental\_activity()

> **experimental\_activity**(): `Promise`\<`WalletsV1Alpha2ActivityResponseDto`>

Defined in: [packages/wallets/src/wallets/wallet.ts:312](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L312)

**`Experimental`**

Get the wallet activity

#### Returns

`Promise`\<`WalletsV1Alpha2ActivityResponseDto`>

The activity
This API is experimental and may change in the future

#### Throws

If the activity cannot be retrieved

#### Inherited from

[`Wallet`](./Wallet).[`experimental_activity`](./Wallet#experimental_activity)

***

### experimental\_apiClient()

> **experimental\_apiClient**(): [`WalletsApiClient`](./WalletsApiClient)

Defined in: [packages/wallets/src/wallets/wallet.ts:101](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L101)

**`Experimental`**

Get the API client

#### Returns

[`WalletsApiClient`](./WalletsApiClient)

The API client
This API is experimental and may change in the future

#### Inherited from

[`Wallet`](./Wallet).[`experimental_apiClient`](./Wallet#experimental_apiclient)

***

### experimental\_nfts()

> **experimental\_nfts**(`params`): `Promise`\<`WalletNftsResponseDto`>

Defined in: [packages/wallets/src/wallets/wallet.ts:272](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L272)

**`Experimental`**

Get the wallet NFTs

#### Parameters

| Parameter        | Type                                        | Description                 |
| ---------------- | ------------------------------------------- | --------------------------- |
| `params`         | \{ `page`: `number`; `perPage`: `number`; } | The parameters              |
| `params.page`    | `number`                                    | The page number             |
| `params.perPage` | `number`                                    | The number of NFTs per page |

#### Returns

`Promise`\<`WalletNftsResponseDto`>

The NFTs
This API is experimental and may change in the future

#### Inherited from

[`Wallet`](./Wallet).[`experimental_nfts`](./Wallet#experimental_nfts)

***

### experimental\_transaction()

> **experimental\_transaction**(`transactionId`): `Promise`\<`WalletsTransactionV2025ResponseDto`>

Defined in: [packages/wallets/src/wallets/wallet.ts:298](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L298)

Get a transaction by id

#### Parameters

| Parameter       | Type     |
| --------------- | -------- |
| `transactionId` | `string` |

#### Returns

`Promise`\<`WalletsTransactionV2025ResponseDto`>

The transaction

#### Throws

If the transaction cannot be retrieved

#### Inherited from

[`Wallet`](./Wallet).[`experimental_transaction`](./Wallet#experimental_transaction)

***

### experimental\_transactions()

> **experimental\_transactions**(): `Promise`\<`GetTransactionsResponse`>

Defined in: [packages/wallets/src/wallets/wallet.ts:285](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L285)

Get the wallet transactions

#### Returns

`Promise`\<`GetTransactionsResponse`>

The transactions

#### Throws

If the transactions cannot be retrieved

#### Inherited from

[`Wallet`](./Wallet).[`experimental_transactions`](./Wallet#experimental_transactions)

***

### send()

> **send**\<`T`>(`to`, `token`, `amount`, `options`?): `Promise`\<[`Transaction`](../type-aliases/Transaction)\<`T` *extends* `PrepareOnly`\<`true`> ? `true` : `false`>>

Defined in: [packages/wallets/src/wallets/wallet.ts:335](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L335)

Send a token to a wallet or user locator

#### Type Parameters

| Type Parameter                                             | Default type |
| ---------------------------------------------------------- | ------------ |
| `T` *extends* `SendTokenTransactionOptions` \| `undefined` | `undefined`  |

#### Parameters

| Parameter  | Type                      | Description                             |
| ---------- | ------------------------- | --------------------------------------- |
| `to`       | `string` \| `UserLocator` | The recipient (address or user locator) |
| `token`    | `string`                  | The token (address or currency symbol)  |
| `amount`   | `string`                  | The amount to send (decimal units)      |
| `options`? | `T`                       | The options for the transaction         |

#### Returns

`Promise`\<[`Transaction`](../type-aliases/Transaction)\<`T` *extends* `PrepareOnly`\<`true`> ? `true` : `false`>>

The transaction

#### Inherited from

[`Wallet`](./Wallet).[`send`](./Wallet#send)

***

### sendTransaction()

> **sendTransaction**\<`T`>(`params`): `Promise`\<[`Transaction`](../type-aliases/Transaction)\<`T` *extends* `PrepareOnly`\<`true`> ? `true` : `false`>>

Defined in: [packages/wallets/src/wallets/solana.ts:52](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/solana.ts#L52)

Send a raw Solana transaction.

#### Type Parameters

| Type Parameter                                         | Default type |
| ------------------------------------------------------ | ------------ |
| `T` *extends* `TransactionInputOptions` \| `undefined` | `undefined`  |

#### Parameters

| Parameter | Type                                                               | Description                                                               |
| --------- | ------------------------------------------------------------------ | ------------------------------------------------------------------------- |
| `params`  | [`SolanaTransactionInput`](../type-aliases/SolanaTransactionInput) | The transaction parameters (serialized transaction or Transaction object) |

#### Returns

`Promise`\<[`Transaction`](../type-aliases/Transaction)\<`T` *extends* `PrepareOnly`\<`true`> ? `true` : `false`>>

The transaction result

***

### stagingFund()

> **stagingFund**(`amount`, `chain`?): `Promise`\<`FundWalletResponse`>

Defined in: [packages/wallets/src/wallets/wallet.ts:166](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L166)

Funds the wallet with Crossmint's stablecoin (USDXM).

**Note:** This method is only available in staging environments and exclusively supports USDXM tokens.
It cannot be used in production environments.

#### Parameters

| Parameter | Type                             | Description                                                                 |
| --------- | -------------------------------- | --------------------------------------------------------------------------- |
| `amount`  | `number`                         | The amount of USDXM to fund the wallet with                                 |
| `chain`?  | [`Chain`](../type-aliases/Chain) | Optional chain to fund on. If not provided, uses the wallet's default chain |

#### Returns

`Promise`\<`FundWalletResponse`>

The funding response

#### Throws

If the funding operation fails or if called in a production environment

#### Inherited from

[`Wallet`](./Wallet).[`stagingFund`](./Wallet#stagingfund)

***

### from()

> `static` **from**(`wallet`): `SolanaWallet`

Defined in: [packages/wallets/src/wallets/solana.ts:32](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/solana.ts#L32)

#### Parameters

| Parameter | Type                                                    |
| --------- | ------------------------------------------------------- |
| `wallet`  | [`Wallet`](./Wallet)\<[`Chain`](../type-aliases/Chain)> |

#### Returns

`SolanaWallet`


# StellarWallet
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/classes/StellarWallet



Defined in: [packages/wallets/src/wallets/stellar.ts:15](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/stellar.ts#L15)

## Extends

* [`Wallet`](./Wallet)\<[`StellarChain`](../type-aliases/StellarChain)>

## Constructors

### new StellarWallet()

> **new StellarWallet**(`wallet`): `StellarWallet`

Defined in: [packages/wallets/src/wallets/stellar.ts:16](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/stellar.ts#L16)

#### Parameters

| Parameter | Type                               |
| --------- | ---------------------------------- |
| `wallet`  | [`Wallet`](./Wallet)\<`"stellar"`> |

#### Returns

`StellarWallet`

#### Overrides

[`Wallet`](./Wallet).[`constructor`](./Wallet#constructor)

## Properties

| Property        | Type                             | Inherited from                                     | Defined in                                                                                                                                   |
| --------------- | -------------------------------- | -------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| <a /> `address` | `string`                         | [`Wallet`](./Wallet).[`address`](./Wallet#address) | [packages/wallets/src/wallets/wallet.ts:62](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L62) |
| <a /> `alias?`  | `string`                         | [`Wallet`](./Wallet).[`alias`](./Wallet#alias)     | [packages/wallets/src/wallets/wallet.ts:64](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L64) |
| <a /> `chain`   | `"stellar"`                      | [`Wallet`](./Wallet).[`chain`](./Wallet#chain)     | [packages/wallets/src/wallets/wallet.ts:61](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L61) |
| <a /> `owner?`  | `string`                         | [`Wallet`](./Wallet).[`owner`](./Wallet#owner)     | [packages/wallets/src/wallets/wallet.ts:63](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L63) |
| <a /> `signer`  | [`Signer`](../interfaces/Signer) | [`Wallet`](./Wallet).[`signer`](./Wallet#signer)   | [packages/wallets/src/wallets/wallet.ts:65](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L65) |

## Methods

### addDelegatedSigner()

> **addDelegatedSigner**\<`T`>(`params`): `Promise`\<`T` *extends* `PrepareOnly`\<`true`> ? `object` : `void`>

Defined in: [packages/wallets/src/wallets/wallet.ts:465](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L465)

Add a delegated signer to the wallet

#### Type Parameters

| Type Parameter                                           | Default type |
| -------------------------------------------------------- | ------------ |
| `T` *extends* `AddDelegatedSignerOptions` \| `undefined` | `undefined`  |

#### Parameters

| Parameter         | Type                                                                                                                                                     |
| ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `params`          | \{ `options`: `T`; `signer`: `string` \| \{ `id`: `string`; `name`: `string`; `publicKey`: \{ `x`: `string`; `y`: `string`; }; `type`: `"passkey"`; }; } |
| `params.options`? | `T`                                                                                                                                                      |
| `params.signer`   | `string` \| \{ `id`: `string`; `name`: `string`; `publicKey`: \{ `x`: `string`; `y`: `string`; }; `type`: `"passkey"`; }                                 |

#### Returns

`Promise`\<`T` *extends* `PrepareOnly`\<`true`> ? `object` : `void`>

#### Inherited from

[`Wallet`](./Wallet).[`addDelegatedSigner`](./Wallet#adddelegatedsigner)

***

### approve()

> **approve**\<`T`>(`params`): `Promise`\<`ApproveResult`\<`T`>>

Defined in: [packages/wallets/src/wallets/wallet.ts:423](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L423)

Approve a transaction or signature

#### Type Parameters

| Type Parameter                |
| ----------------------------- |
| `T` *extends* `ApproveParams` |

#### Parameters

| Parameter | Type | Description    |
| --------- | ---- | -------------- |
| `params`  | `T`  | The parameters |

#### Returns

`Promise`\<`ApproveResult`\<`T`>>

The transaction or signature

#### Inherited from

[`Wallet`](./Wallet).[`approve`](./Wallet#approve)

***

### ~~approveTransaction()~~

> **approveTransaction**(`params`): `Promise`\<`Error`>

Defined in: [packages/wallets/src/wallets/wallet.ts:399](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L399)

#### Parameters

| Parameter | Type            | Description    |
| --------- | --------------- | -------------- |
| `params`  | `ApproveParams` | The parameters |

#### Returns

`Promise`\<`Error`>

The transaction

#### Deprecated

Use `approve` instead.
Approve a transaction

#### Inherited from

[`Wallet`](./Wallet).[`approveTransaction`](./Wallet#approvetransaction)

***

### balances()

> **balances**(`tokens`?): `Promise`\<[`Balances`](../type-aliases/Balances)\<`"stellar"`>>

Defined in: [packages/wallets/src/wallets/wallet.ts:118](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L118)

Get the wallet balances - always includes USDC and native token (ETH/SOL)

#### Parameters

| Parameter | Type        | Description                                                                        |
| --------- | ----------- | ---------------------------------------------------------------------------------- |
| `tokens`? | `string`\[] | Additional tokens to request (optional: native token and usdc are always included) |

#### Returns

`Promise`\<[`Balances`](../type-aliases/Balances)\<`"stellar"`>>

The balances returns nativeToken, usdc, tokens

#### Throws

If the balances cannot be retrieved

#### Inherited from

[`Wallet`](./Wallet).[`balances`](./Wallet#balances)

***

### delegatedSigners()

> **delegatedSigners**(): `Promise`\<[`DelegatedSigner`](../type-aliases/DelegatedSigner)\[]>

Defined in: [packages/wallets/src/wallets/wallet.ts:554](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L554)

List the delegated signers for this wallet.

#### Returns

`Promise`\<[`DelegatedSigner`](../type-aliases/DelegatedSigner)\[]>

The delegated signers

#### Inherited from

[`Wallet`](./Wallet).[`delegatedSigners`](./Wallet#delegatedsigners)

***

### experimental\_activity()

> **experimental\_activity**(): `Promise`\<`WalletsV1Alpha2ActivityResponseDto`>

Defined in: [packages/wallets/src/wallets/wallet.ts:312](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L312)

**`Experimental`**

Get the wallet activity

#### Returns

`Promise`\<`WalletsV1Alpha2ActivityResponseDto`>

The activity
This API is experimental and may change in the future

#### Throws

If the activity cannot be retrieved

#### Inherited from

[`Wallet`](./Wallet).[`experimental_activity`](./Wallet#experimental_activity)

***

### experimental\_apiClient()

> **experimental\_apiClient**(): [`WalletsApiClient`](./WalletsApiClient)

Defined in: [packages/wallets/src/wallets/wallet.ts:101](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L101)

**`Experimental`**

Get the API client

#### Returns

[`WalletsApiClient`](./WalletsApiClient)

The API client
This API is experimental and may change in the future

#### Inherited from

[`Wallet`](./Wallet).[`experimental_apiClient`](./Wallet#experimental_apiclient)

***

### experimental\_nfts()

> **experimental\_nfts**(`params`): `Promise`\<`WalletNftsResponseDto`>

Defined in: [packages/wallets/src/wallets/wallet.ts:272](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L272)

**`Experimental`**

Get the wallet NFTs

#### Parameters

| Parameter        | Type                                        | Description                 |
| ---------------- | ------------------------------------------- | --------------------------- |
| `params`         | \{ `page`: `number`; `perPage`: `number`; } | The parameters              |
| `params.page`    | `number`                                    | The page number             |
| `params.perPage` | `number`                                    | The number of NFTs per page |

#### Returns

`Promise`\<`WalletNftsResponseDto`>

The NFTs
This API is experimental and may change in the future

#### Inherited from

[`Wallet`](./Wallet).[`experimental_nfts`](./Wallet#experimental_nfts)

***

### experimental\_transaction()

> **experimental\_transaction**(`transactionId`): `Promise`\<`WalletsTransactionV2025ResponseDto`>

Defined in: [packages/wallets/src/wallets/wallet.ts:298](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L298)

Get a transaction by id

#### Parameters

| Parameter       | Type     |
| --------------- | -------- |
| `transactionId` | `string` |

#### Returns

`Promise`\<`WalletsTransactionV2025ResponseDto`>

The transaction

#### Throws

If the transaction cannot be retrieved

#### Inherited from

[`Wallet`](./Wallet).[`experimental_transaction`](./Wallet#experimental_transaction)

***

### experimental\_transactions()

> **experimental\_transactions**(): `Promise`\<`GetTransactionsResponse`>

Defined in: [packages/wallets/src/wallets/wallet.ts:285](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L285)

Get the wallet transactions

#### Returns

`Promise`\<`GetTransactionsResponse`>

The transactions

#### Throws

If the transactions cannot be retrieved

#### Inherited from

[`Wallet`](./Wallet).[`experimental_transactions`](./Wallet#experimental_transactions)

***

### send()

> **send**\<`T`>(`to`, `token`, `amount`, `options`?): `Promise`\<[`Transaction`](../type-aliases/Transaction)\<`T` *extends* `PrepareOnly`\<`true`> ? `true` : `false`>>

Defined in: [packages/wallets/src/wallets/wallet.ts:335](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L335)

Send a token to a wallet or user locator

#### Type Parameters

| Type Parameter                                             | Default type |
| ---------------------------------------------------------- | ------------ |
| `T` *extends* `SendTokenTransactionOptions` \| `undefined` | `undefined`  |

#### Parameters

| Parameter  | Type                      | Description                             |
| ---------- | ------------------------- | --------------------------------------- |
| `to`       | `string` \| `UserLocator` | The recipient (address or user locator) |
| `token`    | `string`                  | The token (address or currency symbol)  |
| `amount`   | `string`                  | The amount to send (decimal units)      |
| `options`? | `T`                       | The options for the transaction         |

#### Returns

`Promise`\<[`Transaction`](../type-aliases/Transaction)\<`T` *extends* `PrepareOnly`\<`true`> ? `true` : `false`>>

The transaction

#### Inherited from

[`Wallet`](./Wallet).[`send`](./Wallet#send)

***

### sendTransaction()

> **sendTransaction**\<`T`>(`params`): `Promise`\<[`Transaction`](../type-aliases/Transaction)\<`T` *extends* `PrepareOnly`\<`true`> ? `true` : `false`>>

Defined in: [packages/wallets/src/wallets/stellar.ts:50](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/stellar.ts#L50)

Send a raw Stellar transaction (serialized transaction or contract call).

#### Type Parameters

| Type Parameter                                         | Default type |
| ------------------------------------------------------ | ------------ |
| `T` *extends* `TransactionInputOptions` \| `undefined` | `undefined`  |

#### Parameters

| Parameter | Type                                 | Description                |
| --------- | ------------------------------------ | -------------------------- |
| `params`  | `StellarTransactionInput` & `object` | The transaction parameters |

#### Returns

`Promise`\<[`Transaction`](../type-aliases/Transaction)\<`T` *extends* `PrepareOnly`\<`true`> ? `true` : `false`>>

The transaction result

***

### stagingFund()

> **stagingFund**(`amount`, `chain`?): `Promise`\<`FundWalletResponse`>

Defined in: [packages/wallets/src/wallets/wallet.ts:166](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L166)

Funds the wallet with Crossmint's stablecoin (USDXM).

**Note:** This method is only available in staging environments and exclusively supports USDXM tokens.
It cannot be used in production environments.

#### Parameters

| Parameter | Type                             | Description                                                                 |
| --------- | -------------------------------- | --------------------------------------------------------------------------- |
| `amount`  | `number`                         | The amount of USDXM to fund the wallet with                                 |
| `chain`?  | [`Chain`](../type-aliases/Chain) | Optional chain to fund on. If not provided, uses the wallet's default chain |

#### Returns

`Promise`\<`FundWalletResponse`>

The funding response

#### Throws

If the funding operation fails or if called in a production environment

#### Inherited from

[`Wallet`](./Wallet).[`stagingFund`](./Wallet#stagingfund)

***

### from()

> `static` **from**(`wallet`): `StellarWallet`

Defined in: [packages/wallets/src/wallets/stellar.ts:30](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/stellar.ts#L30)

#### Parameters

| Parameter | Type                                                    |
| --------- | ------------------------------------------------------- |
| `wallet`  | [`Wallet`](./Wallet)\<[`Chain`](../type-aliases/Chain)> |

#### Returns

`StellarWallet`


# Wallet
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/classes/Wallet



Defined in: [packages/wallets/src/wallets/wallet.ts:60](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L60)

## Extended by

* [`SolanaWallet`](./SolanaWallet)
* [`EVMWallet`](./EVMWallet)
* [`StellarWallet`](./StellarWallet)

## Type Parameters

| Type Parameter                                 |
| ---------------------------------------------- |
| `C` *extends* [`Chain`](../type-aliases/Chain) |

## Constructors

### new Wallet()

> **new Wallet**\<`C`>(`args`, `apiClient`): `Wallet`\<`C`>

Defined in: [packages/wallets/src/wallets/wallet.ts:69](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L69)

#### Parameters

| Parameter   | Type                                     |
| ----------- | ---------------------------------------- |
| `args`      | `WalletContructorType`\<`C`>             |
| `apiClient` | [`WalletsApiClient`](./WalletsApiClient) |

#### Returns

`Wallet`\<`C`>

## Properties

| Property        | Type                             | Defined in                                                                                                                                   |
| --------------- | -------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| <a /> `address` | `string`                         | [packages/wallets/src/wallets/wallet.ts:62](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L62) |
| <a /> `alias?`  | `string`                         | [packages/wallets/src/wallets/wallet.ts:64](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L64) |
| <a /> `chain`   | `C`                              | [packages/wallets/src/wallets/wallet.ts:61](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L61) |
| <a /> `owner?`  | `string`                         | [packages/wallets/src/wallets/wallet.ts:63](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L63) |
| <a /> `signer`  | [`Signer`](../interfaces/Signer) | [packages/wallets/src/wallets/wallet.ts:65](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L65) |

## Methods

### addDelegatedSigner()

> **addDelegatedSigner**\<`T`>(`params`): `Promise`\<`T` *extends* `PrepareOnly`\<`true`> ? `AddDelegatedSignerReturnType`\<`C`> : `void`>

Defined in: [packages/wallets/src/wallets/wallet.ts:465](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L465)

Add a delegated signer to the wallet

#### Type Parameters

| Type Parameter                                           | Default type |
| -------------------------------------------------------- | ------------ |
| `T` *extends* `AddDelegatedSignerOptions` \| `undefined` | `undefined`  |

#### Parameters

| Parameter         | Type                                                                                                                                                     |
| ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `params`          | \{ `options`: `T`; `signer`: `string` \| \{ `id`: `string`; `name`: `string`; `publicKey`: \{ `x`: `string`; `y`: `string`; }; `type`: `"passkey"`; }; } |
| `params.options`? | `T`                                                                                                                                                      |
| `params.signer`   | `string` \| \{ `id`: `string`; `name`: `string`; `publicKey`: \{ `x`: `string`; `y`: `string`; }; `type`: `"passkey"`; }                                 |

#### Returns

`Promise`\<`T` *extends* `PrepareOnly`\<`true`> ? `AddDelegatedSignerReturnType`\<`C`> : `void`>

***

### approve()

> **approve**\<`T`>(`params`): `Promise`\<`ApproveResult`\<`T`>>

Defined in: [packages/wallets/src/wallets/wallet.ts:423](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L423)

Approve a transaction or signature

#### Type Parameters

| Type Parameter                |
| ----------------------------- |
| `T` *extends* `ApproveParams` |

#### Parameters

| Parameter | Type | Description    |
| --------- | ---- | -------------- |
| `params`  | `T`  | The parameters |

#### Returns

`Promise`\<`ApproveResult`\<`T`>>

The transaction or signature

***

### ~~approveTransaction()~~

> **approveTransaction**(`params`): `Promise`\<`Error`>

Defined in: [packages/wallets/src/wallets/wallet.ts:399](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L399)

#### Parameters

| Parameter | Type            | Description    |
| --------- | --------------- | -------------- |
| `params`  | `ApproveParams` | The parameters |

#### Returns

`Promise`\<`Error`>

The transaction

#### Deprecated

Use `approve` instead.
Approve a transaction

***

### balances()

> **balances**(`tokens`?): `Promise`\<[`Balances`](../type-aliases/Balances)\<`C`>>

Defined in: [packages/wallets/src/wallets/wallet.ts:118](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L118)

Get the wallet balances - always includes USDC and native token (ETH/SOL)

#### Parameters

| Parameter | Type        | Description                                                                        |
| --------- | ----------- | ---------------------------------------------------------------------------------- |
| `tokens`? | `string`\[] | Additional tokens to request (optional: native token and usdc are always included) |

#### Returns

`Promise`\<[`Balances`](../type-aliases/Balances)\<`C`>>

The balances returns nativeToken, usdc, tokens

#### Throws

If the balances cannot be retrieved

***

### delegatedSigners()

> **delegatedSigners**(): `Promise`\<[`DelegatedSigner`](../type-aliases/DelegatedSigner)\[]>

Defined in: [packages/wallets/src/wallets/wallet.ts:554](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L554)

List the delegated signers for this wallet.

#### Returns

`Promise`\<[`DelegatedSigner`](../type-aliases/DelegatedSigner)\[]>

The delegated signers

***

### experimental\_activity()

> **experimental\_activity**(): `Promise`\<`WalletsV1Alpha2ActivityResponseDto`>

Defined in: [packages/wallets/src/wallets/wallet.ts:312](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L312)

**`Experimental`**

Get the wallet activity

#### Returns

`Promise`\<`WalletsV1Alpha2ActivityResponseDto`>

The activity
This API is experimental and may change in the future

#### Throws

If the activity cannot be retrieved

***

### experimental\_apiClient()

> **experimental\_apiClient**(): [`WalletsApiClient`](./WalletsApiClient)

Defined in: [packages/wallets/src/wallets/wallet.ts:101](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L101)

**`Experimental`**

Get the API client

#### Returns

[`WalletsApiClient`](./WalletsApiClient)

The API client
This API is experimental and may change in the future

***

### experimental\_nfts()

> **experimental\_nfts**(`params`): `Promise`\<`WalletNftsResponseDto`>

Defined in: [packages/wallets/src/wallets/wallet.ts:272](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L272)

**`Experimental`**

Get the wallet NFTs

#### Parameters

| Parameter        | Type                                        | Description                 |
| ---------------- | ------------------------------------------- | --------------------------- |
| `params`         | \{ `page`: `number`; `perPage`: `number`; } | The parameters              |
| `params.page`    | `number`                                    | The page number             |
| `params.perPage` | `number`                                    | The number of NFTs per page |

#### Returns

`Promise`\<`WalletNftsResponseDto`>

The NFTs
This API is experimental and may change in the future

***

### experimental\_transaction()

> **experimental\_transaction**(`transactionId`): `Promise`\<`WalletsTransactionV2025ResponseDto`>

Defined in: [packages/wallets/src/wallets/wallet.ts:298](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L298)

Get a transaction by id

#### Parameters

| Parameter       | Type     |
| --------------- | -------- |
| `transactionId` | `string` |

#### Returns

`Promise`\<`WalletsTransactionV2025ResponseDto`>

The transaction

#### Throws

If the transaction cannot be retrieved

***

### experimental\_transactions()

> **experimental\_transactions**(): `Promise`\<`GetTransactionsResponse`>

Defined in: [packages/wallets/src/wallets/wallet.ts:285](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L285)

Get the wallet transactions

#### Returns

`Promise`\<`GetTransactionsResponse`>

The transactions

#### Throws

If the transactions cannot be retrieved

***

### send()

> **send**\<`T`>(`to`, `token`, `amount`, `options`?): `Promise`\<[`Transaction`](../type-aliases/Transaction)\<`T` *extends* `PrepareOnly`\<`true`> ? `true` : `false`>>

Defined in: [packages/wallets/src/wallets/wallet.ts:335](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L335)

Send a token to a wallet or user locator

#### Type Parameters

| Type Parameter                                             | Default type |
| ---------------------------------------------------------- | ------------ |
| `T` *extends* `SendTokenTransactionOptions` \| `undefined` | `undefined`  |

#### Parameters

| Parameter  | Type                      | Description                             |
| ---------- | ------------------------- | --------------------------------------- |
| `to`       | `string` \| `UserLocator` | The recipient (address or user locator) |
| `token`    | `string`                  | The token (address or currency symbol)  |
| `amount`   | `string`                  | The amount to send (decimal units)      |
| `options`? | `T`                       | The options for the transaction         |

#### Returns

`Promise`\<[`Transaction`](../type-aliases/Transaction)\<`T` *extends* `PrepareOnly`\<`true`> ? `true` : `false`>>

The transaction

***

### stagingFund()

> **stagingFund**(`amount`, `chain`?): `Promise`\<`FundWalletResponse`>

Defined in: [packages/wallets/src/wallets/wallet.ts:166](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/wallet.ts#L166)

Funds the wallet with Crossmint's stablecoin (USDXM).

**Note:** This method is only available in staging environments and exclusively supports USDXM tokens.
It cannot be used in production environments.

#### Parameters

| Parameter | Type                             | Description                                                                 |
| --------- | -------------------------------- | --------------------------------------------------------------------------- |
| `amount`  | `number`                         | The amount of USDXM to fund the wallet with                                 |
| `chain`?  | [`Chain`](../type-aliases/Chain) | Optional chain to fund on. If not provided, uses the wallet's default chain |

#### Returns

`Promise`\<`FundWalletResponse`>

The funding response

#### Throws

If the funding operation fails or if called in a production environment


# WalletsApiClient
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/classes/WalletsApiClient



Defined in: [packages/wallets/src/api/client.ts:41](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/api/client.ts#L41)

## Extends

* `CrossmintApiClient`

## Constructors

### new WalletsApiClient()

> **new WalletsApiClient**(`crossmint`): `ApiClient`

Defined in: [packages/wallets/src/api/client.ts:45](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/api/client.ts#L45)

#### Parameters

| Parameter   | Type        |
| ----------- | ----------- |
| `crossmint` | `Crossmint` |

#### Returns

`ApiClient`

#### Overrides

`CrossmintApiClient.constructor`

## Properties

| Property          | Type        | Inherited from                 | Defined in                                                     |
| ----------------- | ----------- | ------------------------------ | -------------------------------------------------------------- |
| <a /> `crossmint` | `Crossmint` | `CrossmintApiClient.crossmint` | packages/common/base/dist/apiClient/CrossmintApiClient.d.ts:18 |

## Accessors

### baseUrl

#### Get Signature

> **get** **baseUrl**(): `string`

Defined in: packages/common/base/dist/apiClient/CrossmintApiClient.d.ts:24

##### Returns

`string`

#### Inherited from

`CrossmintApiClient.baseUrl`

***

### commonHeaders

#### Get Signature

> **get** **commonHeaders**(): `object`

Defined in: packages/common/base/dist/apiClient/CrossmintApiClient.d.ts:25

##### Returns

`object`

###### Authorization?

> `optional` **Authorization**: `string`

###### x-api-key

> **x-api-key**: `string`

###### x-app-identifier?

> `optional` **x-app-identifier**: `string`

###### x-client-name

> **x-client-name**: `string`

###### x-client-version

> **x-client-version**: `string`

###### x-extension-id?

> `optional` **x-extension-id**: `string`

#### Inherited from

`CrossmintApiClient.commonHeaders`

***

### environment

#### Get Signature

> **get** **environment**(): `APIKeyEnvironmentPrefix`

Defined in: [packages/wallets/src/api/client.ts:264](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/api/client.ts#L264)

##### Returns

`APIKeyEnvironmentPrefix`

#### Overrides

`CrossmintApiClient.environment`

***

### isServerSide

#### Get Signature

> **get** **isServerSide**(): `boolean`

Defined in: [packages/wallets/src/api/client.ts:260](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/api/client.ts#L260)

##### Returns

`boolean`

## Methods

### approveSignature()

> **approveSignature**(`walletLocator`, `signatureId`, `params`): `Promise`\<`ApproveSignatureResponse`>

Defined in: [packages/wallets/src/api/client.ts:137](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/api/client.ts#L137)

#### Parameters

| Parameter       | Type                     |
| --------------- | ------------------------ |
| `walletLocator` | `string`                 |
| `signatureId`   | `string`                 |
| `params`        | `SubmitApprovalV2025Dto` |

#### Returns

`Promise`\<`ApproveSignatureResponse`>

***

### approveTransaction()

> **approveTransaction**(`walletLocator`, `transactionId`, `params`): `Promise`\<`ApproveTransactionResponse`>

Defined in: [packages/wallets/src/api/client.ts:107](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/api/client.ts#L107)

#### Parameters

| Parameter       | Type                     |
| --------------- | ------------------------ |
| `walletLocator` | `string`                 |
| `transactionId` | `string`                 |
| `params`        | `SubmitApprovalV2025Dto` |

#### Returns

`Promise`\<`ApproveTransactionResponse`>

***

### buildUrl()

> **buildUrl**(`path`): `string`

Defined in: packages/common/base/dist/apiClient/ApiClient.d.ts:5

#### Parameters

| Parameter | Type     |
| --------- | -------- |
| `path`    | `string` |

#### Returns

`string`

#### Inherited from

`CrossmintApiClient.buildUrl`

***

### createSignature()

> **createSignature**(`walletLocator`, `params`): `Promise`\<`CreateSignatureResponse`>

Defined in: [packages/wallets/src/api/client.ts:126](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/api/client.ts#L126)

#### Parameters

| Parameter       | Type                      |
| --------------- | ------------------------- |
| `walletLocator` | `string`                  |
| `params`        | `CreateSignatureV2025Dto` |

#### Returns

`Promise`\<`CreateSignatureResponse`>

***

### createTransaction()

> **createTransaction**(`walletLocator`, `params`): `Promise`\<`CreateTransactionResponse`>

Defined in: [packages/wallets/src/api/client.ts:96](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/api/client.ts#L96)

#### Parameters

| Parameter       | Type                        |
| --------------- | --------------------------- |
| `walletLocator` | `string`                    |
| `params`        | `CreateTransactionV2025Dto` |

#### Returns

`Promise`\<`CreateTransactionResponse`>

***

### createWallet()

> **createWallet**(`params`): `Promise`\<`CreateWalletResponse`>

Defined in: [packages/wallets/src/api/client.ts:53](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/api/client.ts#L53)

#### Parameters

| Parameter | Type                   |
| --------- | ---------------------- |
| `params`  | `CreateWalletV2025Dto` |

#### Returns

`Promise`\<`CreateWalletResponse`>

***

### delete()

> **delete**(`path`, `params`): `Promise`\<`Response`>

Defined in: packages/common/base/dist/apiClient/ApiClient.d.ts:9

#### Parameters

| Parameter | Type                               |
| --------- | ---------------------------------- |
| `path`    | `string`                           |
| `params`  | `Omit`\<`RequestInit`, `"method"`> |

#### Returns

`Promise`\<`Response`>

#### Inherited from

`CrossmintApiClient.delete`

***

### experimental\_activity()

> **experimental\_activity**(`walletLocator`, `params`): `Promise`\<`GetActivityResponse`>

Defined in: [packages/wallets/src/api/client.ts:179](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/api/client.ts#L179)

#### Parameters

| Parameter       | Type                                            |
| --------------- | ----------------------------------------------- |
| `walletLocator` | `string`                                        |
| `params`        | \{ `chain`: [`Chain`](../type-aliases/Chain); } |
| `params.chain`  | [`Chain`](../type-aliases/Chain)                |

#### Returns

`Promise`\<`GetActivityResponse`>

***

### experimental\_getNfts()

> **experimental\_getNfts**(`params`): `Promise`\<`WalletNftsResponseDto`>

Defined in: [packages/wallets/src/api/client.ts:163](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/api/client.ts#L163)

#### Parameters

| Parameter        | Type                                                                                |
| ---------------- | ----------------------------------------------------------------------------------- |
| `params`         | \{ `address`: `string`; `chain`: `string`; `page`: `number`; `perPage`: `number`; } |
| `params.address` | `string`                                                                            |
| `params.chain`   | `string`                                                                            |
| `params.page`    | `number`                                                                            |
| `params.perPage` | `number`                                                                            |

#### Returns

`Promise`\<`WalletNftsResponseDto`>

***

### fundWallet()

> **fundWallet**(`walletLocator`, `params`): `Promise`\<`FundWalletResponse`>

Defined in: [packages/wallets/src/api/client.ts:208](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/api/client.ts#L208)

#### Parameters

| Parameter       | Type                  |
| --------------- | --------------------- |
| `walletLocator` | `string`              |
| `params`        | `FundWalletAmountDto` |

#### Returns

`Promise`\<`FundWalletResponse`>

***

### get()

> **get**(`path`, `params`): `Promise`\<`Response`>

Defined in: packages/common/base/dist/apiClient/ApiClient.d.ts:6

#### Parameters

| Parameter | Type                               |
| --------- | ---------------------------------- |
| `path`    | `string`                           |
| `params`  | `Omit`\<`RequestInit`, `"method"`> |

#### Returns

`Promise`\<`Response`>

#### Inherited from

`CrossmintApiClient.get`

***

### getBalance()

> **getBalance**(`walletLocator`, `params`): `Promise`\<`GetBalanceResponse`>

Defined in: [packages/wallets/src/api/client.ts:192](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/api/client.ts#L192)

#### Parameters

| Parameter       | Type                                                                       |
| --------------- | -------------------------------------------------------------------------- |
| `walletLocator` | `string`                                                                   |
| `params`        | \{ `chains`: [`Chain`](../type-aliases/Chain)\[]; `tokens`: `string`\[]; } |
| `params.chains` | [`Chain`](../type-aliases/Chain)\[]                                        |
| `params.tokens` | `string`\[]                                                                |

#### Returns

`Promise`\<`GetBalanceResponse`>

***

### getSignature()

> **getSignature**(`walletLocator`, `signatureId`): `Promise`\<`GetSignatureResponse`>

Defined in: [packages/wallets/src/api/client.ts:149](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/api/client.ts#L149)

#### Parameters

| Parameter       | Type     |
| --------------- | -------- |
| `walletLocator` | `string` |
| `signatureId`   | `string` |

#### Returns

`Promise`\<`GetSignatureResponse`>

***

### getSigner()

> **getSigner**(`walletLocator`, `signer`): `Promise`\<`GetSignerResponse`>

Defined in: [packages/wallets/src/api/client.ts:227](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/api/client.ts#L227)

#### Parameters

| Parameter       | Type     |
| --------------- | -------- |
| `walletLocator` | `string` |
| `signer`        | `string` |

#### Returns

`Promise`\<`GetSignerResponse`>

***

### getTransaction()

> **getTransaction**(`walletLocator`, `transactionId`): `Promise`\<`GetTransactionResponse`>

Defined in: [packages/wallets/src/api/client.ts:119](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/api/client.ts#L119)

#### Parameters

| Parameter       | Type     |
| --------------- | -------- |
| `walletLocator` | `string` |
| `transactionId` | `string` |

#### Returns

`Promise`\<`GetTransactionResponse`>

***

### getTransactions()

> **getTransactions**(`walletLocator`): `Promise`\<`GetTransactionsResponse`>

Defined in: [packages/wallets/src/api/client.ts:156](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/api/client.ts#L156)

#### Parameters

| Parameter       | Type     |
| --------------- | -------- |
| `walletLocator` | `string` |

#### Returns

`Promise`\<`GetTransactionsResponse`>

***

### getWallet()

> **getWallet**(`locator`): `Promise`\<`GetWalletResponse`>

Defined in: [packages/wallets/src/api/client.ts:79](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/api/client.ts#L79)

#### Parameters

| Parameter | Type     |
| --------- | -------- |
| `locator` | `string` |

#### Returns

`Promise`\<`GetWalletResponse`>

***

### patch()

> **patch**(`path`, `params`): `Promise`\<`Response`>

Defined in: packages/common/base/dist/apiClient/ApiClient.d.ts:10

#### Parameters

| Parameter | Type                               |
| --------- | ---------------------------------- |
| `path`    | `string`                           |
| `params`  | `Omit`\<`RequestInit`, `"method"`> |

#### Returns

`Promise`\<`Response`>

#### Inherited from

`CrossmintApiClient.patch`

***

### post()

> **post**(`path`, `params`): `Promise`\<`Response`>

Defined in: packages/common/base/dist/apiClient/ApiClient.d.ts:7

#### Parameters

| Parameter | Type                               |
| --------- | ---------------------------------- |
| `path`    | `string`                           |
| `params`  | `Omit`\<`RequestInit`, `"method"`> |

#### Returns

`Promise`\<`Response`>

#### Inherited from

`CrossmintApiClient.post`

***

### put()

> **put**(`path`, `params`): `Promise`\<`Response`>

Defined in: packages/common/base/dist/apiClient/ApiClient.d.ts:8

#### Parameters

| Parameter | Type                               |
| --------- | ---------------------------------- |
| `path`    | `string`                           |
| `params`  | `Omit`\<`RequestInit`, `"method"`> |

#### Returns

`Promise`\<`Response`>

#### Inherited from

`CrossmintApiClient.put`

***

### registerSigner()

> **registerSigner**(`walletLocator`, `params`): `Promise`\<`RegisterSignerResponse`>

Defined in: [packages/wallets/src/api/client.ts:219](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/api/client.ts#L219)

#### Parameters

| Parameter       | Type                   |
| --------------- | ---------------------- |
| `walletLocator` | `string`               |
| `params`        | `RegisterSignerParams` |

#### Returns

`Promise`\<`RegisterSignerResponse`>

***

### send()

> **send**(`walletLocator`, `tokenLocator`, `params`): `Promise`\<`WalletsV1Alpha2TransactionResponseWithSendParamsDto`>

Defined in: [packages/wallets/src/api/client.ts:234](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/api/client.ts#L234)

#### Parameters

| Parameter       | Type           |
| --------------- | -------------- |
| `walletLocator` | `string`       |
| `tokenLocator`  | `string`       |
| `params`        | `SendTokenDto` |

#### Returns

`Promise`\<`WalletsV1Alpha2TransactionResponseWithSendParamsDto`>

***

### normalizePath()

> `static` **normalizePath**(`path`): `string`

Defined in: packages/common/base/dist/apiClient/ApiClient.d.ts:11

#### Parameters

| Parameter | Type     |
| --------- | -------- |
| `path`    | `string` |

#### Returns

`string`

#### Inherited from

`CrossmintApiClient.normalizePath`


# createCrossmint
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/functions/createCrossmint



> **createCrossmint**(`config`, `apiKeyExpectations`?): `Crossmint`

Defined in: packages/common/base/dist/types/Crossmint.d.ts:31

## Parameters

| Parameter             | Type                               |
| --------------------- | ---------------------------------- |
| `config`              | `CrossmintConfig`                  |
| `apiKeyExpectations`? | `ValidateAPIKeyPrefixExpectations` |

## Returns

`Crossmint`


# isExportableSigner
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/functions/isExportableSigner



> **isExportableSigner**(`signer`): `signer is ExportableSigner`

Defined in: [packages/wallets/src/signers/types.ts:154](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/signers/types.ts#L154)

## Parameters

| Parameter | Type                             |
| --------- | -------------------------------- |
| `signer`  | [`Signer`](../interfaces/Signer) |

## Returns

`signer is ExportableSigner`


# ExportableSigner
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/interfaces/ExportableSigner



Defined in: [packages/wallets/src/signers/types.ts:150](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/signers/types.ts#L150)

## Extends

* [`Signer`](./Signer)

## Properties

### \_exportPrivateKey()

> **\_exportPrivateKey**: (`exportTEEConnection`) => `Promise`\<`void`>

Defined in: [packages/wallets/src/signers/types.ts:151](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/signers/types.ts#L151)

#### Parameters

| Parameter             | Type                                                                     |
| --------------------- | ------------------------------------------------------------------------ |
| `exportTEEConnection` | [`ExportSignerTEEConnection`](../type-aliases/ExportSignerTEEConnection) |

#### Returns

`Promise`\<`void`>

***

### type

> **type**: keyof `SignResultMap`

Defined in: [packages/wallets/src/signers/types.ts:143](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/signers/types.ts#L143)

#### Inherited from

[`Signer`](./Signer).[`type`](./Signer#type)

## Methods

### address()?

> `optional` **address**(): `string`

Defined in: [packages/wallets/src/signers/types.ts:145](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/signers/types.ts#L145)

#### Returns

`string`

#### Inherited from

[`Signer`](./Signer).[`address`](./Signer#address)

***

### locator()

> **locator**(): `string`

Defined in: [packages/wallets/src/signers/types.ts:144](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/signers/types.ts#L144)

#### Returns

`string`

#### Inherited from

[`Signer`](./Signer).[`locator`](./Signer#locator)

***

### signMessage()

> **signMessage**(`message`): `Promise`\<`BaseSignResult` | `PasskeySignResult`>

Defined in: [packages/wallets/src/signers/types.ts:146](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/signers/types.ts#L146)

#### Parameters

| Parameter | Type     |
| --------- | -------- |
| `message` | `string` |

#### Returns

`Promise`\<`BaseSignResult` | `PasskeySignResult`>

#### Inherited from

[`Signer`](./Signer).[`signMessage`](./Signer#signmessage)

***

### signTransaction()

> **signTransaction**(`transaction`): `Promise`\<`BaseSignResult` | `PasskeySignResult`>

Defined in: [packages/wallets/src/signers/types.ts:147](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/signers/types.ts#L147)

#### Parameters

| Parameter     | Type     |
| ------------- | -------- |
| `transaction` | `string` |

#### Returns

`Promise`\<`BaseSignResult` | `PasskeySignResult`>

#### Inherited from

[`Signer`](./Signer).[`signTransaction`](./Signer#signtransaction)


# Signer
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/interfaces/Signer



Defined in: [packages/wallets/src/signers/types.ts:142](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/signers/types.ts#L142)

## Extended by

* [`ExportableSigner`](./ExportableSigner)

## Type Parameters

| Type Parameter                      | Default type          |
| ----------------------------------- | --------------------- |
| `T` *extends* keyof `SignResultMap` | keyof `SignResultMap` |

## Properties

### type

> **type**: `T`

Defined in: [packages/wallets/src/signers/types.ts:143](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/signers/types.ts#L143)

## Methods

### address()?

> `optional` **address**(): `string`

Defined in: [packages/wallets/src/signers/types.ts:145](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/signers/types.ts#L145)

#### Returns

`string`

***

### locator()

> **locator**(): `string`

Defined in: [packages/wallets/src/signers/types.ts:144](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/signers/types.ts#L144)

#### Returns

`string`

***

### signMessage()

> **signMessage**(`message`): `Promise`\<`SignResultMap`\[`T`]>

Defined in: [packages/wallets/src/signers/types.ts:146](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/signers/types.ts#L146)

#### Parameters

| Parameter | Type     |
| --------- | -------- |
| `message` | `string` |

#### Returns

`Promise`\<`SignResultMap`\[`T`]>

***

### signTransaction()

> **signTransaction**(`transaction`): `Promise`\<`SignResultMap`\[`T`]>

Defined in: [packages/wallets/src/signers/types.ts:147](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/signers/types.ts#L147)

#### Parameters

| Parameter     | Type     |
| ------------- | -------- |
| `transaction` | `string` |

#### Returns

`Promise`\<`SignResultMap`\[`T`]>


# Getting Started
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/overview



A Typescript SDK to interact with Crossmint Wallets. This SDK enables developers to easily create and manage wallets on Solana and EVM chains.

<CardGroup>
  <Snippet />
</CardGroup>

<Steps>
  <Step title="Install the SDK">
    Run the following command to install the SDK:

    <Snippet />
  </Step>

  <Step title="Create a wallet">
    ```tsx index.ts theme={null}
    import { CrossmintWallets, createCrossmint } from "@crossmint/wallets-sdk";

    const crossmint = createCrossmint({
        apiKey: "<your-client-OR-server-api-key>",
        jwt: "<your-jwt>", // required for client-side calls, optional for server-side calls
    });
    const crossmintWallets = CrossmintWallets.from(crossmint);
    const wallet = await crossmintWallets.getOrCreateWallet({
        chain: "<your-chain>",
        signer: {
            type: "email",
            email: "<your-email>",
        },
    });

    console.log(wallet.address);
    ```
  </Step>
</Steps>

## Wallet Examples

### Get wallet balances

```ts theme={null}
const balances = await wallet.balances();

console.log(balances.nativeToken.amount);
console.log(balances.usdc.amount);
```

### Transfer

```ts theme={null}
const transaction = await wallet.send(recipient, "usdc", "100");

console.log(transaction.explorerLink);
```

### Get wallet activity

```ts theme={null}
const activity = await wallet.experimental_activity();

console.log(activity.events);
```

### Operational signers

```ts theme={null}
// Add an operational signer
await wallet.addDelegatedSigner({ signer: "<signer-address>" });

const signers = await wallet.delegatedSigners();

console.log(signers);
```

### Create custom transactions

```ts theme={null}
import { SolanaWallet, EVMWallet } from "@crossmint/wallets-sdk";

// Solana
const solanaWallet = SolanaWallet.from(wallet);
const solTx = await solanaWallet.sendTransaction({ transaction: "<serialized-or-non-serialized-transaction>" });

console.log(solTx.explorerLink);

// EVM
const evmWallet = EVMWallet.from(wallet);
const evmTx = await evmWallet.sendTransaction({ transaction: "<serialized-or-non-serialized-transaction>" });

console.log(evmTx.explorerLink);
```

### Signers and custody

<CardGroup>
  <Card title="Wallet Signers" icon="rocket" href="/wallets/concepts/wallet-signers">
    Learn about signer types and how to choose the right ones.
  </Card>
</CardGroup>


# Reference
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/reference



## Classes

* [CrossmintWallets](./classes/CrossmintWallets)
* [EVMWallet](./classes/EVMWallet)
* [SolanaWallet](./classes/SolanaWallet)
* [StellarWallet](./classes/StellarWallet)
* [Wallet](./classes/Wallet)
* [WalletsApiClient](./classes/WalletsApiClient)

## Interfaces

* [ExportableSigner](./interfaces/ExportableSigner)
* [Signer](./interfaces/Signer)

## Type Aliases

* [Activity](./type-aliases/Activity)
* [Balances](./type-aliases/Balances)
* [Chain](./type-aliases/Chain)
* [DelegatedSigner](./type-aliases/DelegatedSigner)
* [EmailSignerConfig](./type-aliases/EmailSignerConfig)
* [EVMChain](./type-aliases/EVMChain)
* [EvmExternalWalletSignerConfig](./type-aliases/EvmExternalWalletSignerConfig)
* [EVMTransactionInput](./type-aliases/EVMTransactionInput)
* [ExportSignerTEEConnection](./type-aliases/ExportSignerTEEConnection)
* [ExternalWalletSignerConfigForChain](./type-aliases/ExternalWalletSignerConfigForChain)
* [PhoneSignerConfig](./type-aliases/PhoneSignerConfig)
* [Signature](./type-aliases/Signature)
* [SignerConfigForChain](./type-aliases/SignerConfigForChain)
* [SolanaChain](./type-aliases/SolanaChain)
* [SolanaExternalWalletSignerConfig](./type-aliases/SolanaExternalWalletSignerConfig)
* [SolanaTransactionInput](./type-aliases/SolanaTransactionInput)
* [StellarChain](./type-aliases/StellarChain)
* [StellarExternalWalletSignerConfig](./type-aliases/StellarExternalWalletSignerConfig)
* [Transaction](./type-aliases/Transaction)
* [WalletArgsFor](./type-aliases/WalletArgsFor)
* [WalletPlugin](./type-aliases/WalletPlugin)

## Functions

* [createCrossmint](./functions/createCrossmint)
* [isExportableSigner](./functions/isExportableSigner)


# Activity
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/type-aliases/Activity



> **Activity** = `WalletsV1Alpha2ActivityResponseDto`

Defined in: [packages/wallets/src/api/types.ts:69](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/api/types.ts#L69)


# Balances
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/type-aliases/Balances



> **Balances**\<`C`> = `object`

Defined in: [packages/wallets/src/wallets/types.ts:153](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/types.ts#L153)

## Type Parameters

| Type Parameter                   | Default type       |
| -------------------------------- | ------------------ |
| `C` *extends* [`Chain`](./Chain) | [`Chain`](./Chain) |

## Properties

### nativeToken

> **nativeToken**: `TokenBalance`\<`C`>

Defined in: [packages/wallets/src/wallets/types.ts:154](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/types.ts#L154)

***

### tokens

> **tokens**: `TokenBalance`\<`C`>\[]

Defined in: [packages/wallets/src/wallets/types.ts:156](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/types.ts#L156)

***

### usdc

> **usdc**: `TokenBalance`\<`C`>

Defined in: [packages/wallets/src/wallets/types.ts:155](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/types.ts#L155)


# Chain
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/type-aliases/Chain



> **Chain** = [`SolanaChain`](./SolanaChain) | [`EVMChain`](./EVMChain) | [`StellarChain`](./StellarChain)

Defined in: [packages/wallets/src/chains/chains.ts:151](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/chains/chains.ts#L151)


# DelegatedSigner
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/type-aliases/DelegatedSigner



> **DelegatedSigner** = `object`

Defined in: [packages/wallets/src/wallets/types.ts:104](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/types.ts#L104)

## Properties

### signer

> **signer**: `string`

Defined in: [packages/wallets/src/wallets/types.ts:105](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/types.ts#L105)


# EVMChain
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/type-aliases/EVMChain



> **EVMChain** = `EVMSmartWalletChain`

Defined in: [packages/wallets/src/chains/chains.ts:149](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/chains/chains.ts#L149)


# EVMTransactionInput
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/type-aliases/EVMTransactionInput



> **EVMTransactionInput** = `EVMTransactionInputBase` & \{ `abi`: `Abi`; `args`: `unknown`\[]; `data`: `` `0x${string}` ``; `functionName`: `string`; `to`: `string`; `value`: `bigint`; } | \{ `transaction`: `string`; }

Defined in: [packages/wallets/src/wallets/types.ts:56](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/types.ts#L56)


# EmailSignerConfig
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/type-aliases/EmailSignerConfig



> **EmailSignerConfig** = `object`

Defined in: [packages/wallets/src/signers/types.ts:34](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/signers/types.ts#L34)

## Properties

### email?

> `optional` **email**: `string`

Defined in: [packages/wallets/src/signers/types.ts:36](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/signers/types.ts#L36)

***

### onAuthRequired()?

> `optional` **onAuthRequired**: (`needsAuth`, `sendEmailWithOtp`, `verifyOtp`, `reject`) => `Promise`\<`void`>

Defined in: [packages/wallets/src/signers/types.ts:37](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/signers/types.ts#L37)

#### Parameters

| Parameter          | Type                          |
| ------------------ | ----------------------------- |
| `needsAuth`        | `boolean`                     |
| `sendEmailWithOtp` | () => `Promise`\<`void`>      |
| `verifyOtp`        | (`otp`) => `Promise`\<`void`> |
| `reject`           | () => `void`                  |

#### Returns

`Promise`\<`void`>

***

### type

> **type**: `"email"`

Defined in: [packages/wallets/src/signers/types.ts:35](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/signers/types.ts#L35)


# EvmExternalWalletSignerConfig
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/type-aliases/EvmExternalWalletSignerConfig



> **EvmExternalWalletSignerConfig** = `BaseExternalWalletSignerConfig` & `object`

Defined in: packages/common/base/dist/types/signers.d.ts:16

## Type Declaration

### provider?

> `optional` **provider**: `GenericEIP1193Provider` | `EIP1193Provider`

### viemAccount?

> `optional` **viemAccount**: `Account`


# ExportSignerTEEConnection
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/type-aliases/ExportSignerTEEConnection



> **ExportSignerTEEConnection** = `HandshakeParent`\<*typeof* `exportSignerOutboundEvents`, *typeof* `exportSignerInboundEvents`>

Defined in: [packages/wallets/src/signers/types.ts:158](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/signers/types.ts#L158)


# ExternalWalletSignerConfigForChain
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/type-aliases/ExternalWalletSignerConfigForChain



> **ExternalWalletSignerConfigForChain**\<`C`> = `C` *extends* [`SolanaChain`](./SolanaChain) ? [`SolanaExternalWalletSignerConfig`](./SolanaExternalWalletSignerConfig) : `C` *extends* [`StellarChain`](./StellarChain) ? [`StellarExternalWalletSignerConfig`](./StellarExternalWalletSignerConfig) : [`EvmExternalWalletSignerConfig`](./EvmExternalWalletSignerConfig)

Defined in: [packages/wallets/src/signers/types.ts:58](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/signers/types.ts#L58)

## Type Parameters

| Type Parameter                   |
| -------------------------------- |
| `C` *extends* [`Chain`](./Chain) |


# PhoneSignerConfig
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/type-aliases/PhoneSignerConfig



> **PhoneSignerConfig** = `object`

Defined in: [packages/wallets/src/signers/types.ts:45](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/signers/types.ts#L45)

## Properties

### onAuthRequired()?

> `optional` **onAuthRequired**: (`needsAuth`, `sendEmailWithOtp`, `verifyOtp`, `reject`) => `Promise`\<`void`>

Defined in: [packages/wallets/src/signers/types.ts:48](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/signers/types.ts#L48)

#### Parameters

| Parameter          | Type                          |
| ------------------ | ----------------------------- |
| `needsAuth`        | `boolean`                     |
| `sendEmailWithOtp` | () => `Promise`\<`void`>      |
| `verifyOtp`        | (`otp`) => `Promise`\<`void`> |
| `reject`           | () => `void`                  |

#### Returns

`Promise`\<`void`>

***

### phone?

> `optional` **phone**: `string`

Defined in: [packages/wallets/src/signers/types.ts:47](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/signers/types.ts#L47)

***

### type

> **type**: `"phone"`

Defined in: [packages/wallets/src/signers/types.ts:46](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/signers/types.ts#L46)


# Signature
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/type-aliases/Signature



> **Signature**\<`TPrepareOnly`> = `TPrepareOnly` *extends* `true` ? `object` : `object`

Defined in: [packages/wallets/src/wallets/types.ts:178](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/types.ts#L178)

## Type Parameters

| Type Parameter                     | Default type |
| ---------------------------------- | ------------ |
| `TPrepareOnly` *extends* `boolean` | `false`      |


# SignerConfigForChain
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/type-aliases/SignerConfigForChain



> **SignerConfigForChain**\<`C`> = `C` *extends* [`SolanaChain`](./SolanaChain) ? [`EmailSignerConfig`](./EmailSignerConfig) | [`PhoneSignerConfig`](./PhoneSignerConfig) | `BaseSignerConfig`\<`C`> : `C` *extends* [`StellarChain`](./StellarChain) ? [`EmailSignerConfig`](./EmailSignerConfig) | [`PhoneSignerConfig`](./PhoneSignerConfig) | `BaseSignerConfig`\<`C`> : [`EmailSignerConfig`](./EmailSignerConfig) | [`PhoneSignerConfig`](./PhoneSignerConfig) | `PasskeySignerConfig` | `BaseSignerConfig`\<`C`>

Defined in: [packages/wallets/src/signers/types.ts:125](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/signers/types.ts#L125)

## Type Parameters

| Type Parameter                   |
| -------------------------------- |
| `C` *extends* [`Chain`](./Chain) |


# SolanaChain
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/type-aliases/SolanaChain



> **SolanaChain** = `"solana"`

Defined in: [packages/wallets/src/chains/chains.ts:147](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/chains/chains.ts#L147)


# SolanaExternalWalletSignerConfig
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/type-aliases/SolanaExternalWalletSignerConfig



> **SolanaExternalWalletSignerConfig** = `BaseExternalWalletSignerConfig` & `object`

Defined in: packages/common/base/dist/types/signers.d.ts:20

## Type Declaration

### onSignTransaction()?

> `optional` **onSignTransaction**: (`transaction`) => `Promise`\<`VersionedTransaction`>

#### Parameters

| Parameter     | Type                   |
| ------------- | ---------------------- |
| `transaction` | `VersionedTransaction` |

#### Returns

`Promise`\<`VersionedTransaction`>


# SolanaTransactionInput
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/type-aliases/SolanaTransactionInput



> **SolanaTransactionInput** = \{ `transaction`: `VersionedTransaction`; } | \{ `serializedTransaction`: `string`; } & `object`

Defined in: [packages/wallets/src/wallets/types.ts:84](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/types.ts#L84)

## Type Declaration

### additionalSigners?

> `optional` **additionalSigners**: `Keypair`\[]

### options?

> `optional` **options**: `TransactionInputOptions`


# StellarChain
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/type-aliases/StellarChain



> **StellarChain** = `"stellar"`

Defined in: [packages/wallets/src/chains/chains.ts:148](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/chains/chains.ts#L148)


# StellarExternalWalletSignerConfig
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/type-aliases/StellarExternalWalletSignerConfig



> **StellarExternalWalletSignerConfig** = `BaseExternalWalletSignerConfig` & `object`

Defined in: packages/common/base/dist/types/signers.d.ts:23

## Type Declaration

### onSignStellarTransaction()?

> `optional` **onSignStellarTransaction**: (`transaction`) => `Promise`\<`string`>

#### Parameters

| Parameter     | Type     |
| ------------- | -------- |
| `transaction` | `string` |

#### Returns

`Promise`\<`string`>


# Transaction
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/type-aliases/Transaction



> **Transaction**\<`TPrepareOnly`> = `TPrepareOnly` *extends* `true` ? `object` : `object`

Defined in: [packages/wallets/src/wallets/types.ts:166](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/types.ts#L166)

## Type Parameters

| Type Parameter                     | Default type |
| ---------------------------------- | ------------ |
| `TPrepareOnly` *extends* `boolean` | `false`      |


# WalletArgsFor
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/type-aliases/WalletArgsFor



> **WalletArgsFor**\<`C`> = `object`

Defined in: [packages/wallets/src/wallets/types.ts:127](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/types.ts#L127)

## Type Parameters

| Type Parameter                   |
| -------------------------------- |
| `C` *extends* [`Chain`](./Chain) |

## Properties

### alias?

> `optional` **alias**: `string`

Defined in: [packages/wallets/src/wallets/types.ts:134](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/types.ts#L134)

***

### chain

> **chain**: `C`

Defined in: [packages/wallets/src/wallets/types.ts:128](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/types.ts#L128)

***

### delegatedSigners?

> `optional` **delegatedSigners**: [`DelegatedSigner`](./DelegatedSigner)\[]

Defined in: [packages/wallets/src/wallets/types.ts:133](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/types.ts#L133)

***

### options?

> `optional` **options**: `WalletOptions`

Defined in: [packages/wallets/src/wallets/types.ts:132](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/types.ts#L132)

***

### owner?

> `optional` **owner**: `string`

Defined in: [packages/wallets/src/wallets/types.ts:130](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/types.ts#L130)

***

### plugins?

> `optional` **plugins**: [`WalletPlugin`](./WalletPlugin)\<`C`>\[]

Defined in: [packages/wallets/src/wallets/types.ts:131](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/types.ts#L131)

***

### signer

> **signer**: [`SignerConfigForChain`](./SignerConfigForChain)\<`C`>

Defined in: [packages/wallets/src/wallets/types.ts:129](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/types.ts#L129)


# WalletPlugin
Source: https://docs.crossmint.com/sdk-reference/wallets/typescript/type-aliases/WalletPlugin



> **WalletPlugin**\<`C`> = `C` *extends* [`StellarChain`](./StellarChain) ? `StellarWalletPlugin` : `never`

Defined in: [packages/wallets/src/wallets/types.ts:120](https://github.com/Crossmint/crossmint-sdk/blob/main/packages/wallets/src/wallets/types.ts#L120)

## Type Parameters

| Type Parameter                   |
| -------------------------------- |
| `C` *extends* [`Chain`](./Chain) |


# Inventory
Source: https://docs.crossmint.com/solutions/ai-agents/agentic-commerce/inventory

Purchase 1B+ products from Amazon, Shopify, flights all via a single API

<Snippet />

<Frame type="simple">
  <img alt="Agentic Commerce with Crossmint" />
</Frame>

Agents can purchase 1B+ products from Amazon, Shopify, airlines and more all via Crossmint's Checkout API. Crossmint is the Merchant of Record (MoR) for these transactions, handling payments, shipping costs, taxes, and customer support.

<Note>
  Orders below are performed using USDC assuming an already-funded agent wallet. Check the [payments
  page](/solutions/ai-agents/agentic-commerce/payment-methods) to explore other supported payment methods.
</Note>

<Tabs>
  <Tab title="Amazon">
    ## Integration Steps

    <Steps>
      <Step title="Setup">
        <Steps>
          <Step icon="circle-dot" title="Crossmint Project">
            Create a project in the [Crossmint Console](https://staging.crossmint.com/signin?callbackUrl=/console) (staging environment)
          </Step>

          <Step icon="circle-dot" title="Server-side API Key">
            Obtain a server-side API key from the Overview page and save it for later use
          </Step>
        </Steps>
      </Step>

      <Step title="Search for Products">
        Use an LLM or third-party API provider to search available Amazon products and obtain the product's Amazon URL or ASIN. Extract the ASIN from the Amazon URL, i.e. [https://wwww.amazon.com/Sparkling-Naturally-Essenced-Calories-Sweeteners/dp/B00O79SKV6](https://wwww.amazon.com/Sparkling-Naturally-Essenced-Calories-Sweeteners/dp/B00O79SKV6) has ASIN `B00O79SKV6`.
      </Step>

      <Step title="Create Crossmint Order">
        Use the [Headless Checkout API](/api-reference/headless/create-order) to create a payment order, specifying the recipient details and payment method.

        ```javascript theme={null}
        const baseUrl = 'staging'; // or 'www' for prod environment
        const crossmintOrder = await fetch(`https://${baseUrl}.crossmint.com/api/2022-06-09/orders`, {
          method: 'POST',
          headers: {
            'X-API-KEY': `${API_KEY}`,
            'Content-Type': 'application/json'
          },
          body: JSON.stringify({
            recipient: {
              email: "john@example.com",
              physicalAddress: {
                name: "John Doe",
                line1: "ABC Street",
                city: "New York",
                state: "NY",
                postalCode: "10007",
                country: "US"
              }
            },
            locale: "en-US",
            payment: {
              receiptEmail: "john@example.com",
              method: "base-sepolia",
              currency: "usdc",
              // Agent's wallet that pays for the transaction
              payerAddress: "0x..."
            },
            lineItems: [{ productLocator: "amazon:B00O79SKV6" }]
          })
        });

        const { order: paymentOrder } = await crossmintOrder.json();
        ```

        This returns a valid order with payment preparation details including the serialized transaction.

        <Note> You can add multiple productLocators from Amazon as part of the same order. </Note>
      </Step>

      <Step title="Sign and Submit Payment">
        Sign the transaction with Crossmint's [Create Transaction API](/api-reference/wallets/create-transaction) using the agent's wallet to complete the purchase.

        ```javascript theme={null}
        const baseUrl = 'staging'; // or 'www' for prod environment
        const transaction = await fetch(`https://${baseUrl}.crossmint.com/api/2022-06-09/wallets/${userWallet}/transactions`, {
          method: 'POST',
          headers: {
            'X-API-KEY': `${API_KEY}`,
            'Content-Type': 'application/json'
          },
          body: JSON.stringify({
            params: {
              calls: [{
                transaction: paymentOrder.payment.preparation.serializedTransaction
              }],
              chain: "base-sepolia"
            }
          })
        });
        ```

        <Accordion title="Alternative: Using External Wallets">
          ```javascript theme={null}
          import { ethers } from "ethers";

          async function processPayment(order, privateKey, rpcUrl) {
              const isInsufficientFunds = order.payment.status === "crypto-payer-insufficient-funds";
              if (isInsufficientFunds) {
                  throw new Error("Insufficient funds");
              }

              const serializedTransaction =
                  order.payment.preparation != null && "serializedTransaction" in order.payment.preparation
                      ? order.payment.preparation.serializedTransaction
                      : undefined;
              if (!serializedTransaction) {
                  throw new Error(
                      `No serialized transaction found for order, this item may not be available for purchase:\n\n ${JSON.stringify(
                          order,
                          null,
                          2,
                      )}`,
                  );
              }

              const provider = new ethers.providers.JsonRpcProvider(rpcUrl);
              const wallet = new ethers.Wallet(privateKey, provider);

              try {
                  const parsedTx = ethers.utils.parseTransaction(serializedTransaction);

                  // Rebuild the transaction object without gasLimit
                  const txRequest = {
                      to: parsedTx.to,
                      value: parsedTx.value,
                      data: parsedTx.data,
                      nonce: parsedTx.nonce,
                      chainId: parsedTx.chainId,
                      type: parsedTx.type ?? 2,
                      maxFeePerGas: parsedTx.maxFeePerGas,
                      maxPriorityFeePerGas: parsedTx.maxPriorityFeePerGas,
                      accessList: parsedTx.accessList || [],
                  };

                  // Estimate gas
                  const estimatedGasLimit = await provider.estimateGas({
                      ...txRequest,
                      from: wallet.address, // ensure correct estimation context
                  });

                  // Attach estimated gas
                  const finalTx = {
                      ...txRequest,
                      gasLimit: estimatedGasLimit,
                  };

                  const tx = await wallet.sendTransaction(finalTx);
                  console.log("Transaction sent! Hash:", tx.hash);

                  const receipt = await tx.wait();
                  console.log("Transaction confirmed in block:", receipt.blockNumber);

                  return receipt;

              } catch (error) {
                  console.error("Error sending transaction:", error);
                  throw error;
              }
          }

          // Usage example
          const baseUrl = 'staging'; // or 'www' for prod environment
          const rpcUrl = "https://base-sepolia.g.alchemy.com/v2/YOUR_API_KEY"; // or 'mainnet' for prod
          const walletPrivateKey = "YOUR_PRIVATE_KEY";

          // Call the function with your order, private key, and RPC URL
          processPayment(paymentOrder, walletPrivateKey, rpcUrl);
          ```
        </Accordion>
      </Step>

      <Step title="Monitor Order Status">
        Poll the order status with Crossmint's [Get Order API](/api-reference/headless/get-order) to track delivery and present updates to your agent or end user.

        ```javascript theme={null}
        const baseUrl = 'staging'; // or 'www' for prod environment
        const checkStatus = async (orderId) => {
          const response = await fetch(`https://${baseUrl}.crossmint.com/api/2022-06-09/orders/${orderId}`, {
            headers: {
              'X-API-KEY': `${API_KEY}`
            }
          });

          const { order } = await response.json();

          switch(order.phase) {
            case 'completed':
              console.log('Amazon order confirmed!');
              break;
            case 'pending':
              console.log('Processing order...');
              break;
            case 'failed':
              console.log('Order failed:', order.delivery.status);
              break;
          }

          return order;
        };

        const pollStatus = setInterval(async () => {
          const order = await checkStatus(paymentOrder.orderId);
          if (order.phase === 'completed' || order.phase === 'failed') {
            clearInterval(pollStatus);
          }
        }, 30000);
        ```
      </Step>

      <Step title="Receive Order Confirmation">
        Crossmint automatically sends a purchase receipt to the buyer's email with the order confirmation number, product details, and cost breakdown.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Shopify">
    ## Integration Steps

    <Steps>
      <Step title="Setup">
        <Steps>
          <Step icon="circle-dot" title="Crossmint Project">
            Create a project in the [Crossmint Console](https://staging.crossmint.com/signin?callbackUrl=/console) (staging environment)
          </Step>

          <Step icon="circle-dot" title="Server-side API Key">
            Obtain a server-side API key from the Overview page and save it for later use
          </Step>
        </Steps>
      </Step>

      <Step title="Search for Products">
        Use an LLM or third-party API provider to fetch Shopify stores or products within such stores.
      </Step>

      <Step title="Identify Product Variants">
        Once a product is identified, call Crossmint's WS Search API to check the product variants available for sale.

        ```javascript theme={null}
        const baseUrl = 'staging'; // or 'www' for prod environment
        const response = await fetch(`https://${baseUrl}.crossmint.com/api/unstable/ws/search`, {
          method: 'POST',
          headers: {
            'X-API-KEY': `${API_KEY}`,
            'Content-Type': 'application/json'
          },
          body: JSON.stringify({
            uid: {
              productUrl: "https://elwoodclothing.com/collections/sweatshirts/products/oversized-core-crewneck-vintage-grey"
            }
          })
        });

        const { listings } = await response.json();
        ```

        The response contains a `variants` array from which the variantId can be extracted.
      </Step>

      <Step title="Create Crossmint Order">
        Use the [Headless Checkout API](/api-reference/headless/create-order) to create a payment order, specifying the recipient details, productLocator, and payment method.

        ```javascript theme={null}
        const baseUrl = 'staging'; // or 'www' for prod environment
        const crossmintOrder = await fetch(`https://${baseUrl}.crossmint.com/api/2022-06-09/orders`, {
          method: 'POST',
          headers: {
            'X-API-KEY': `${API_KEY}`,
            'Content-Type': 'application/json'
          },
          body: JSON.stringify({
            recipient: {
              email: "john@example.com",
              physicalAddress: {
                name: "John Doe",
                line1: "ABC Street",
                city: "New York",
                state: "NY",
                postalCode: "10007",
                country: "US"
              }
            },
            locale: "en-US",
            payment: {
              receiptEmail: "john@example.com",
              method: "base-sepolia",
              currency: "usdc",
              payerAddress: "0x..."
            },
            lineItems: [{ productLocator: "shopify:https://elwoodclothing.com/collections/sweatshirts/products/oversized-core-crewneck-vintage-grey:<variantId>" }]
          })
        });

        const { order: paymentOrder } = await crossmintOrder.json();
        ```

        This returns a valid order with payment preparation details including the serialized transaction.

        <Note> You can add multiple productLocators from the same or separate Shopify stores as part of the same order. </Note>
      </Step>

      <Step title="Sign and Submit Payment">
        Sign the transaction with Crossmint's [Create Transaction API](/api-reference/wallets/create-transaction) using your agent's wallet to complete the purchase.

        **Using Crossmint Wallets**

        ```javascript theme={null}
        const baseUrl = 'staging'; // or 'www' for prod environment
        const transaction = await fetch(`https://${baseUrl}.crossmint.com/api/2022-06-09/wallets/${userWallet}/transactions`, {
          method: 'POST',
          headers: {
            'X-API-KEY': `${API_KEY}`,
            'Content-Type': 'application/json'
          },
          body: JSON.stringify({
            params: {
              calls: [{
                transaction: paymentOrder.payment.preparation.serializedTransaction
              }],
              chain: "base-sepolia"
            }
          })
        });
        ```
      </Step>

      <Step title="Monitor Order Status">
        Poll the order status with Crossmint's [Get Order API](/api-reference/headless/get-order) to track delivery and present updates to your agent or end user.

        ```javascript theme={null}
        const baseUrl = 'staging'; // or 'www' for prod environment
        const checkStatus = async (orderId) => {
          const response = await fetch(`https://${baseUrl}.crossmint.com/api/2022-06-09/orders/${orderId}`, {
            headers: {
              'X-API-KEY': `${API_KEY}`
            }
          });

          const { order } = await response.json();

          switch(order.phase) {
            case 'completed':
              console.log('Shopify order confirmed!');
              break;
            case 'pending':
              console.log('Processing order...');
              break;
            case 'failed':
              console.log('Order failed:', order.delivery.status);
              break;
          }

          return order;
        };

        const pollStatus = setInterval(async () => {
          const order = await checkStatus(paymentOrder.orderId);
          if (order.phase === 'completed' || order.phase === 'failed') {
            clearInterval(pollStatus);
          }
        }, 30000);
        ```
      </Step>

      <Step title="Receive Order Confirmation">
        Crossmint automatically sends a purchase receipt to the buyer's email with the order confirmation number, product details, and cost breakdown.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Flights">
    ## Integration Steps

    <Warning>
      Note: buying flights in production requires approval from the Crossmint team prior to launching. Reach out [on Telegram](https://t.me/crossmintdevs) to discuss.
    </Warning>

    <Steps>
      <Step title="Setup">
        <Steps>
          <Step icon="circle-dot" title="Crossmint Project">
            Create a project in the [Crossmint Console](https://staging.crossmint.com/signin?callbackUrl=/console) (staging environment)
          </Step>

          <Step icon="circle-dot" title="Server-side API Key">
            Obtain a server-side API key from the Overview page and save it for later use
          </Step>
        </Steps>
      </Step>

      <Step title="Search for Flights">
        [Use an LLM](https://chatgpt.com/share/686da586-d898-8010-b57a-65547ffde8b0) or third-party API provider to fetch available flights based on your agent's requirements (origin, destination, dates, passenger count).
      </Step>

      <Step title="Check Flight Availability">
        Flight listings are available on Worldstore. Call Crossmint's Worldstore Search API to check a flight's availability and get pricing details.

        ```javascript theme={null}
        const baseUrl = 'staging'; // or 'www' for prod environment
        const response = await fetch(`https://${baseUrl}.crossmint.com/api/unstable/ws/search`, {
          method: 'POST',
          headers: {
            'X-API-KEY': `${API_KEY}`,
            'Content-Type': 'application/json'
          },
          body: JSON.stringify({
            uid: {
              originIATA: "JFK",
              destinationIATA: "ATH",
              cabinClass: "economy",
              passenger_number: 1,
              departureFlightDetails: {
                departureDate: "2025-07-19",
                flightIds: ["AY4161"]
              }
            }
          })
        });

        const { listings } = await response.json();
        ```

        The response contains available flights with pricing and required passenger information schema.
      </Step>

      <Step title="Create Worldstore Order">
        Create a Worldstore order with passenger details to get a signed commitment from the flight seller.

        ```javascript theme={null}
        const baseUrl = 'staging'; // or 'www' for prod environment
        const wsOrder = await fetch(`https://${baseUrl}.crossmint.com/api/unstable/ws/orders`, {
          method: 'POST',
          headers: {
            'X-API-KEY': `${API_KEY}`,
            'Content-Type': 'application/json'
          },
          body: JSON.stringify({
            sellerId: "1",
            items: [{
              listingId: "ws_flights-off_0000AvtB1fGEU1sZUjSIJm",
              listingParameters: {
                passengers: [{
                  title: "mr",
                  given_name: "John",
                  family_name: "Doe",
                  born_on: "1980-01-01",
                  gender: "m",
                  email: "john@example.com",
                  phone_number: "+14155552671",
                  identity_documents: [{
                    type: "passport",
                    unique_identifier: "123456789",
                    issuing_country_code: "US",
                    expires_on: "2030-04-24"
                  }]
                }]
              }
            }],
            orderParameters: {}
          })
        });

        const { order } = await wsOrder.json();
        ```

        This returns the order hash and signature confirming the seller's commitment.
      </Step>

      <Step title="Create Crossmint Order">
        Use the [Headless Checkout API](/api-reference/headless/create-order) to create a payment order, specifying the recipient details and payment method.

        ```javascript theme={null}
        const baseUrl = 'staging'; // or 'www' for test environment
        const crossmintOrder = await fetch(`https://${baseUrl}.crossmint.com/api/2022-06-09/orders`, {
          method: 'POST',
          headers: {
            'X-API-KEY': `${API_KEY}`,
            'Content-Type': 'application/json'
          },
          body: JSON.stringify({
            recipient: {
              email: "john@example.com"
            },
            locale: "en-US",
            payment: {
              receiptEmail: "john@example.com",
              method: "base-sepolia",
              currency: "usdc",
              payerAddress: "0x..."
            },
            // Pass the previous step's entire response object here
            externalOrder: order
          })
        });

        const { order: paymentOrder } = await crossmintOrder.json();
        ```

        This returns a valid order with payment preparation details including the serialized transaction.
      </Step>

      <Step title="Sign and Submit Payment">
        Sign the transaction with Crossmint's [Create Transaction API](/api-reference/wallets/create-transaction) using your agent's wallet to complete the purchase.

        **Using Crossmint Wallets**

        ```javascript theme={null}
        const baseUrl = 'staging'; // or 'www' for test environment
        const transaction = await fetch(`https://${baseUrl}.crossmint.com/api/2022-06-09/wallets/${userWallet}/transactions`, {
          method: 'POST',
          headers: {
            'X-API-KEY': `${API_KEY}`,
            'Content-Type': 'application/json'
          },
          body: JSON.stringify({
            params: {
              calls: [{
                transaction: paymentOrder.payment.preparation.serializedTransaction
              }],
              chain: "base-sepolia"
            }
          })
        });
        ```

        <Accordion title="Alternative: Using External Wallets">
          ```javascript theme={null}
          import { ethers } from "ethers";

          async function processPayment(order, privateKey, rpcUrl) {
              const isInsufficientFunds = order.payment.status === "crypto-payer-insufficient-funds";
              if (isInsufficientFunds) {
                  throw new Error("Insufficient funds");
              }

              const serializedTransaction =
                  order.payment.preparation != null && "serializedTransaction" in order.payment.preparation
                      ? order.payment.preparation.serializedTransaction
                      : undefined;
              if (!serializedTransaction) {
                  throw new Error(
                      `No serialized transaction found for order, this item may not be available for purchase:\n\n ${JSON.stringify(
                          order,
                          null,
                          2,
                      )}`,
                  );
              }

              const provider = new ethers.providers.JsonRpcProvider(rpcUrl);
              const wallet = new ethers.Wallet(privateKey, provider);

              try {
                  const parsedTx = ethers.utils.parseTransaction(serializedTransaction);

                  // Rebuild the transaction object without gasLimit
                  const txRequest = {
                      to: parsedTx.to,
                      value: parsedTx.value,
                      data: parsedTx.data,
                      nonce: parsedTx.nonce,
                      chainId: parsedTx.chainId,
                      type: parsedTx.type ?? 2,
                      maxFeePerGas: parsedTx.maxFeePerGas,
                      maxPriorityFeePerGas: parsedTx.maxPriorityFeePerGas,
                      accessList: parsedTx.accessList || [],
                  };

                  // Estimate gas
                  const estimatedGasLimit = await provider.estimateGas({
                      ...txRequest,
                      from: wallet.address, // ensure correct estimation context
                  });

                  // Attach estimated gas
                  const finalTx = {
                      ...txRequest,
                      gasLimit: estimatedGasLimit,
                  };

                  const tx = await wallet.sendTransaction(finalTx);
                  console.log("Transaction sent! Hash:", tx.hash);

                  const receipt = await tx.wait();
                  console.log("Transaction confirmed in block:", receipt.blockNumber);

                  return receipt;

              } catch (error) {
                  console.error("Error sending transaction:", error);
                  throw error;
              }
          }

          // Usage example
          const baseUrl = 'staging'; // or 'www' for prod environment
          const rpcUrl = "https://base-sepolia.g.alchemy.com/v2/YOUR_API_KEY"; // or 'mainnet' for prod
          const walletPrivateKey = "YOUR_PRIVATE_KEY";

          // Call the function with your order, private key, and RPC URL
          processPayment(paymentOrder, walletPrivateKey, rpcUrl);
          ```
        </Accordion>
      </Step>

      <Step title="Monitor Order Status">
        Poll the order status with Crossmint's [Get Order API](/api-reference/headless/get-order) to track delivery and present updates to your agent or end user.

        ```javascript theme={null}
        const baseUrl = 'staging'; // or 'www' for prod environment
        const checkStatus = async (orderId) => {
          const response = await fetch(`https://${baseUrl}.crossmint.com/api/2022-06-09/orders/${orderId}`, {
            headers: {
              'X-API-KEY': `${API_KEY}`
            }
          });

          const { order } = await response.json();

          switch(order.phase) {
            case 'completed':
              console.log('Flight booking confirmed!');
              break;
            case 'pending':
              console.log('Processing booking...');
              break;
            case 'failed':
              console.log('Booking failed:', order.delivery.status);
              break;
          }

          return order;
        };

        const pollStatus = setInterval(async () => {
          const order = await checkStatus(paymentOrder.orderId);
          if (order.phase === 'completed' || order.phase === 'failed') {
            clearInterval(pollStatus);
          }
        }, 30000);
        ```
      </Step>

      <Step title="Receive Booking Confirmation">
        Crossmint automatically sends a purchase receipt to the buyer's email with the bookking's confirmation number, passenger details, and cost breakdown.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Browser Automation">
    ## Integration Steps

    <Steps>
      <Step title="Setup">
        <Steps>
          <Step icon="circle-dot" title="Crossmint Project">
            Create a project in the [Crossmint Console](https://staging.crossmint.com/signin?callbackUrl=/console) (staging environment)
          </Step>

          <Step icon="circle-dot" title="Server-side API Key">
            Obtain a server-side API key from the Overview page and save it for later use
          </Step>
        </Steps>
      </Step>

      <Step title="Select Website">
        **Production Environment:**
        Currently supported websites (more being added regularly):

        * [adidas.com](https://adidas.com)
        * [crocs.com](https://crocs.com)
        * [gymshark.com](https://gymshark.com)
        * [on.com](https://on.com)
        * [nike.com](https://www.nike.com)

        **Staging Environment:**

        * 300+ websites supported for testing (including SHEIN, Walmart, eBay and more)
        * [Contact us](https://portal.usepylon.com/crossmint/forms/contact-support) for the complete list of supported websites in staging

        <Note>
          The list of supported websites will keep getting updated as we increase our support.
        </Note>
      </Step>

      <Step title="Create Crossmint Order">
        Use the [Headless Checkout API](/api-reference/headless/create-order) to create a payment order, specifying the recipient details and payment method. The productLocator format is `url:<product-url>:<variant description>`.

        **Variant Description Examples:**

        * Size: `:size-medium`, `:size-9`, `:size-large`
        * Color: `:color-black`, `:color-red`
        * Combined: `:size-medium-color-black`

        ```javascript theme={null}
        const baseUrl = 'staging'; // or 'www' for prod environment
        const crossmintOrder = await fetch(`https://${baseUrl}.crossmint.com/api/2022-06-09/orders`, {
          method: 'POST',
          headers: {
            'X-API-KEY': `${API_KEY}`,
            'Content-Type': 'application/json'
          },
          body: JSON.stringify({
            recipient: {
              email: "john@example.com",
              physicalAddress: {
                name: "John Doe",
                line1: "ABC Street",
                city: "New York",
                state: "NY",
                postalCode: "10007",
                country: "US"
              }
            },
            locale: "en-US",
            payment: {
              receiptEmail: "john@example.com",
              method: "card-token",
            },
            lineItems: [{ productLocator: "url:https://www.nike.com/t/downshifter-13-mens-road-running-shoes-extra-wide-4M0LNf:size-9" }]
          })
        });

        const { order: paymentOrder } = await crossmintOrder.json();
        ```

        <Note>Orders may take a few minutes (\~5 minutes) due the multiple steps a browser operator agent must go through to complete a purchase.</Note>
      </Step>

      <Step title="Complete Payment with Card Token">
        <Note> If you haven't already, tokenize a user's credit card by following instructions in [this page](/solutions/ai-agents/agentic-commerce/payment-methods). </Note>

        Obtain the orderId from the previous step's response and call the following Crossmint API assuming you have already tokenized a card with Crossmint:

        ```json theme={null}
        POST https://staging.crossmint.com/api/unstable/orders/{{orderId}}/payment

        {
          "token": "9f243106-d4a4-4327-a7cb-e3ec22031ed2" // credit card token
        }
        ```

        The response will show that the payment is successful. Check the recipient's email for a purchase receipt.
      </Step>

      <Step title="Monitor Order Status">
        Poll the order status with Crossmint's [Get Order API](/api-reference/headless/get-order) to track delivery and present updates to your agent or end user.

        ```javascript theme={null}
        const baseUrl = 'staging'; // or 'www' for prod environment
        const checkStatus = async (orderId) => {
          const response = await fetch(`https://${baseUrl}.crossmint.com/api/2022-06-09/orders/${orderId}`, {
            headers: {
              'X-API-KEY': `${API_KEY}`
            }
          });

          const { order } = await response.json();

          switch(order.phase) {
            case 'completed':
              console.log('Browser automation order confirmed!');
              break;
            case 'pending':
              console.log('Processing order...');
              break;
            case 'failed':
              console.log('Order failed:', order.delivery.status);
              break;
          }

          return order;
        };

        const pollStatus = setInterval(async () => {
          const order = await checkStatus(paymentOrder.orderId);
          if (order.phase === 'completed' || order.phase === 'failed') {
            clearInterval(pollStatus);
          }
        }, 30000);
        ```
      </Step>

      <Step title="Receive Order Confirmation">
        Crossmint automatically sends a purchase receipt to the buyer's email with the order confirmation number, product details, and cost breakdown.
      </Step>
    </Steps>
  </Tab>
</Tabs>


# Order Management
Source: https://docs.crossmint.com/solutions/ai-agents/agentic-commerce/order-tracking

Track order delivery statuses and request order refunds

<Tabs>
  <Tab title="Order Tracking">
    Order tracking only works for Amazon orders right now.

    ## Integration Steps

    <Steps>
      <Step title="Obtain Crossmint API key">
        Create a project in the [Crossmint Console](https://staging.crossmint.com/signin?callbackUrl=/console), obtain a server-side API key from the Overview page, and make sure to save it for later use.
      </Step>

      <Step title="Fetch orderId">
        Obtain the `orderId` from the response of the [Create Order](/api-reference/headless/create-order) endpoint.
      </Step>

      <Step title="Track order">
        <CodeGroup>
          ```bash curl theme={null}
          curl -X GET "https://staging.crossmint.com/api/unstable/orders/${orderId}/tracking" \
          -H "X-API-KEY: ${API_KEY}" \
          -H "Content-Type: application/json"
          ```

          ```javascript JavaScript theme={null}
          const baseUrl = "staging"; // or 'www' for prod environment
          const orderId = "<ORDER_ID>"; // i.e. b2959ca5-65e4-466a-bd26-1bd05cb4f837
          const API_KEY = "<CROSSMINT_API_KEY>" // i.e. sk_staging_5qJURKJ...
          const response = await fetch(`https://${baseUrl}.crossmint.com/api/unstable/orders/${orderId}/tracking`, {
              method: "GET",
              headers: {
                  // API key requires `orders.read` scope.
                  "X-API-KEY": `${API_KEY}`,
                  "Content-Type": "application/json",
              },
          });

          const trackingData = await response.json();
          console.log("Tracking information:", trackingData);
          ```

          ```python Python theme={null}
          import requests

          order_id = "<ORDER_ID>" # i.e. b2959ca5-65e4-466a-bd26-1bd05cb4f837
          base_url = "staging"  # or 'www' for prod environment
          API_KEY = "<CROSSMINT_API_KEY>" # i.e. sk_staging_5qJURKJ...
          response = requests.get(
              f"https://{base_url}.crossmint.com/api/unstable/orders/{order_id}/tracking",
              headers={
                  "X-API-KEY": API_KEY,
                  "Content-Type": "application/json",
              }
          )

          tracking_data = response.json()
          print("Tracking information:", tracking_data)
          ```
        </CodeGroup>

        <Accordion title="Example Response">
          ```json theme={null}
          [
              {
                  "status": "shipped",
                  "packageTracking": {
                      "carrierName": "Amazon",
                      "carrierTrackingNumber": "TBA123456789"
                  },
                  "deliveryTimeRange": {
                      "lowerBound": "2025-08-16T12:28:34.97Z",
                      "upperBound": "2025-08-16T18:28:34.97Z"
                  }
              }
          ]
          ```

          * Status `delivered` is only guaranteed for Amazon packages at the moment.
          * If the package is in `delivered` state, lowerBound is equal to upperBound and it's just the time the package arrived.
        </Accordion>
      </Step>
    </Steps>
  </Tab>

  <Tab title="Order Refunds">
    Crossmint supports requests for refunds. As part of their request they can specify the reason they want a refund. Crossmint will process their request and email them with a shipping label to return the product in order to receive the refund.

    ## Integration Steps

    <Steps>
      <Step title="Obtain Crossmint API key">
        Create a project in the [Crossmint Console](https://staging.crossmint.com/signin?callbackUrl=/console), obtain a server-side API key from the Overview page, and make sure to save it for later use.
      </Step>

      <Step title="Identify product">
        * Fetch an order's products via the [Get Order API](/api-reference/headless/get-order)
        * Identify a specific product via its index in the lineItems array, i.e. 0.
      </Step>

      <Step title="Submit refund request">
        A user can only specify one product per refund request and the reason they are submiting the refund.

        <CodeGroup>
          ```bash curl theme={null}
          curl -X POST "https://staging.crossmint.com/api/unstable/orders/${orderId}/refunds" \
          -H "X-API-KEY: ${API_KEY}" \
          -H "Content-Type: application/json" \
          -d '{
              "lineItem": 0,
              "reason": "I want to return this product and get a refund as it is defective"
          }'
          ```

          ```javascript JavaScript theme={null}
          const baseUrl = "staging"; // or 'www' for prod environment
          const orderId = "<ORDER_ID>"; // i.e. b2959ca5-65e4-466a-bd26-1bd05cb4f837
          const API_KEY = "<CROSSMINT_API_KEY>" // i.e. sk_staging_5qJURKJ...
          const response = await fetch(`https://${baseUrl}.crossmint.com/api/unstable/orders/${orderId}/refunds`, {
              method: "POST",
              headers: {
                  // API key requires `orders.update` scope.
                  "X-API-KEY": `${API_KEY}`,
                  "Content-Type": "application/json",
              },
              body: JSON.stringify({
                  lineItem: 0,
                  reason: "I want to return this product and get a refund as it is defective" // or any relevant reason that applies
              }),
          });

          const refundData = await response.json();
          console.log("Refund request:", refundData);
          ```

          ```python Python theme={null}
          import requests
          import json

          order_id = "<ORDER_ID>" # i.e. b2959ca5-65e4-466a-bd26-1bd05cb4f837
          base_url = "staging"  # or 'www' for prod environment
          API_KEY = "<CROSSMINT_API_KEY>" # i.e. sk_staging_5qJURKJ...
          response = requests.post(
              f"https://{base_url}.crossmint.com/api/unstable/orders/{order_id}/refunds",
              headers={
                  "X-API-KEY": API_KEY,
                  "Content-Type": "application/json",
              },
              data=json.dumps({
                  "lineItem": 0,
                  "reason": "I want to return this product and get a refund as it is defective"  # or any relevant reason that applies
              })
          )

          refund_data = response.json()
          print("Refund request:", refund_data)
          ```
        </CodeGroup>

        <Accordion title="Example Response">
          ```json theme={null}
          {
              "orderId": "order_123456789",
              "lineItem": 0,
              "reason": "I want to return this product and get a refund as it is defective",
              "status": "refund-request-initiated"
          }
          ```
        </Accordion>
      </Step>

      <Step title="Track refund request status">
        Track the `status` value returned from the following endpoint. To fetch a specific product's refund status specify a `lineItem` index value as a query parameter, otherwise fetch them all, by default.

        <CodeGroup>
          ```bash curl theme={null}
          curl -X GET "https://staging.crossmint.com/api/unstable/orders/${orderId}/refunds" \
          -H "X-API-KEY: ${API_KEY}" \
          -H "Content-Type: application/json"
          ```

          ```javascript JavaScript theme={null}
          const baseUrl = "staging"; // or 'www' for prod environment
          const orderId = "<ORDER_ID>"; // i.e. b2959ca5-65e4-466a-bd26-1bd05cb4f837
          const API_KEY = "<CROSSMINT_API_KEY>" // i.e. sk_staging_5qJURKJ...
          const response = await fetch(`https://${baseUrl}.crossmint.com/api/unstable/orders/${orderId}/refunds`, {
              method: "GET",
              headers: {
                  "X-API-KEY": `${API_KEY}`,
                  "Content-Type": "application/json",
              },
          });

          const refundsData = await response.json();
          console.log("Refund requests:", refundsData);
          ```

          ```python Python theme={null}
          import requests

          order_id = "<ORDER_ID>" # i.e. b2959ca5-65e4-466a-bd26-1bd05cb4f837
          base_url = "staging"  # or 'www' for prod environment
          API_KEY = "<CROSSMINT_API_KEY>" # i.e. sk_staging_5qJURKJ...
          response = requests.get(
              f"https://{base_url}.crossmint.com/api/unstable/orders/{order_id}/refunds",
              headers={
                  "X-API-KEY": API_KEY,
                  "Content-Type": "application/json",
              }
          )

          refunds_data = response.json()
          print("Refund requests:", refunds_data)
          ```
        </CodeGroup>

        <Accordion title="Example Response">
          ```json theme={null}
          [
              {
                  "orderId": "order_123456789",
                  "lineItem": 1,
                  "reason": "I want to return this product and get a refund as it is defective",
                  "status": "refund-request-accepted"
              },
              {
                  "orderId": "order_123456789",
                  "lineItem": 2,
                  "reason": "Item arrived damaged",
                  "status": "refund-request-completed"
              }
          ]
          ```

          Potential `status` values:

          * `refund-request-initiated`: Refund request has been submitted
          * `refund-request-accepted`: Refund request has been approved
          * `refund-request-rejected`: Refund request has been denied
          * `refund-request-completed`: Refund has been processed and completed
        </Accordion>
      </Step>

      <Step title="Return product and receive refund">
        Crossmint will send a return shipping label to the email that was used to complete the order when the `status` from Step 4 is `refund-request-accepted`.
        Once the product is successfully returned, the `status` from Step 4 will be set to `refund-request-completed` and the user will receive the refund to the wallet that paid for the order.
      </Step>
    </Steps>
  </Tab>
</Tabs>


# Payment Methods
Source: https://docs.crossmint.com/solutions/ai-agents/agentic-commerce/payment-methods

Choose how your agent will pay

<Snippet />

With Crossmint, agents can transact on behalf of users using saved cards on file, stablecoins, or Crossmint credits. This guide explains how to implement each of those methods.

<Tabs>
  <Tab title="Agentic Tokens">
    ## Integration Steps

    <Note>
      Agentic tokens can only be generated for cards issued by Mastercard and Visa.
    </Note>

    <Steps>
      <Step title="Obtain Crossmint API key">
        Create a project in the [Crossmint Console](https://staging.crossmint.com/signin?callbackUrl=/console) (staging environment), obtain a server-side API key from the Overview page, and make sure to save it for later use.
      </Step>

      <Step title="Set up authentication">
        Crossmint's Agentic Payment SDK and APIs makes use of JWTs to authenticate users. For staging and quick prototyping, you can use Crossmint Auth. For production, Crossmint recommends integrating with a third-party provider (such as Stytch, Auth0, or Dynamic) or using a custom JWT with a JWKS endpoint.

        For detailed setup instructions, see:

        * [Crossmint Authentication](/authentication/introduction) - Quick setup for staging and prototyping
        * [JWT Authentication Guide](/introduction/platform/api-keys/jwt-authentication) - Third-party providers and custom JWT options, recommended for production
      </Step>

      <Step title="Let the user choose a saved card or add a new card">
        Set up the Crossmint providers and handle authentication. Once authenticated, render the `CrossmintPaymentMethodManagement` component to allow users to select an existing saved card or add a new one. This component handles card tokenization for new cards and creates Crossmint payment methods automatically.

        ```tsx theme={null}
        "use client";
        import { CrossmintProvider, CrossmintPaymentMethodManagement, CrossmintAuthProvider, useCrossmintAuth, LoginButton } from "@crossmint/client-sdk-react-ui";

        export default function AgenticTokenizedCard() {
          return (
            <CrossmintProvider apiKey="<crossmint-client-api-key>">
              <CrossmintAuthProvider>
                <CrossmintPaymentMethodManagementWrapper/>
              </CrossmintAuthProvider>
            </CrossmintProvider>
          );
        }

        function CrossmintPaymentMethodManagementWrapper() {
          const { jwt } = useCrossmintAuth();
          if (!jwt) {
            return <LoginButton />;
          }
          return (
            <CrossmintPaymentMethodManagement jwt={jwt} />
          );
        }
        ```

        <Accordion title="Custom JWT Authentication">
          If you're using custom JWT authentication, pass your own JWT:

          ```tsx theme={null}
          <CrossmintCardManagement jwt="<your-jwt-token>" />
          ```
        </Accordion>

        <Accordion title="Example Form">
          <img alt="Payment checkout example" />
        </Accordion>

        Use this card to test the flow in staging:

        * Mastercard: `5186161910000103`
        * For `CVV` or `CVC`, use any 3 digit number
        * For `Expiry Date` or `MM/YY`, enter any future date
      </Step>

      <Step title="Set up payment method callback">
        Set up the `onPaymentMethodSelected` callback on the `CrossmintPaymentMethodManagement` component to receive the `CrossmintPaymentMethod` when a user either selects an existing saved card or successfully adds a new one. This callback will be triggered in both scenarios.

        ```tsx theme={null}
        function CrossmintPaymentMethodManagementWrapper() {
          const { jwt } = useCrossmintAuth();
          if (!jwt) {
            return <LoginButton />;
          }
          
          const handlePaymentMethodSelected = (paymentMethod: CrossmintPaymentMethod) => {
            console.log("Payment method selected:", paymentMethod.paymentMethodId);
          };

          return (
            <CrossmintPaymentMethodManagement 
              jwt={jwt} 
              onPaymentMethodSelected={handlePaymentMethodSelected}
            />
          );
        }
        ```
      </Step>

      <Step title="Create order intent">
        Create an order intent within the `onPaymentMethodSelected` callback by calling Crossmint's order-intents API using the `paymentMethod.paymentMethodId`:

        ```tsx theme={null}
        // ... existing code from previous step ...

        const handlePaymentMethodSelected = async (paymentMethod: CrossmintPaymentMethod) => {
          const response = await fetch('https://staging.crossmint.com/api/unstable/order-intents', {
            method: 'POST',
            headers: {
              'X-API-KEY': '<crossmint-client-api-key>',
              'Authorization': `Bearer ${jwt}`,
              'Content-Type': 'application/json'
            },
            body: JSON.stringify({
              payment: {
                paymentMethodId: paymentMethod.paymentMethodId
              },
              mandates: [
                {
                  type: "maxAmount",
                  value: "100.00",
                  details: {
                    currency: "840",
                    period: "weekly"
                  }
                }
              ]
            })
          });

          const orderIntent = await response.json();
        };

        // ... rest of existing code ...
        ```

        <Note>
          **Mandates**: The `mandates` array allows you to set limits and controls on transactions. In the example above, we're using a `maxAmount` mandate that limits transactions to \$100.00 USD per week. This ensures that agents can only make purchases up to the specified amount within the weekly period.
        </Note>

        The order intent can be in one of the following phases:

        * `requires-verification`: The order intent requires verification with the credit card issuer
        * `active`: The order intent is ready to be used for order creation
      </Step>

      <Step title="Verify order intent">
        If the order intent phase is `requires-verification`, verify it with the credit card issuer to prompt the user to approve the purchase. Add the verification call to your `handlePaymentMethodSelected` callback from the previous step:

        ```tsx theme={null}
        import { verifyOrderIntent } from "@crossmint/client-sdk-react-ui";

        // ... existing code from previous step ...

        const handlePaymentMethodSelected = async (paymentMethod: CrossmintPaymentMethod) => {
          // ... existing order intent creation code ...
          const orderIntent = await response.json();
          
          // Add verification when phase requires it
          if (orderIntent.phase === "requires-verification") {
            await verifyOrderIntent(orderIntent.orderIntentId);
          }
        };

        // ... rest of existing code ...
        ```

        This step may require user interaction to approve the purchase with their card issuer.
      </Step>

      <Step title="Create order">
        Call Crossmint's [Create Order API](/api-reference/headless/create-order) to create the order with the products you want to purchase.

        <CodeGroup>
          ```bash cURL theme={null}
          curl --request POST \
              --url 'https://staging.crossmint.com/api/2022-06-09/orders' \
              --header 'x-api-key: <x-api-key>' \
              --header 'Content-Type: application/json' \
              --data '{
                "recipient": {
                  "email": "john.d@example.com",
                  "physicalAddress": {
                    "name": "John D",
                    "line1": "123 ABC Street",
                    "city": "New York City",
                    "state": "NY",
                    "postalCode": "10007",
                    "country": "US"
                  }
                },
                "locale": "en-US",
                "payment": {
                  "receiptEmail": "john.d@example.com",
                  "method": "basis-theory"
                },
                "lineItems": [
                  {
                    "productLocator": "url:https://www.nike.com/t/maverick-valor-course-tint-sunglasses-1TrBw8KB/IF0969X-021"
                  }
                ]
              }'
          ```

          ```js Node.js theme={null}
          const options = {
              method: 'POST',
              headers: {
                  'x-api-key': '<x-api-key>',
                  'Content-Type': 'application/json'
              },
              body: JSON.stringify({
                  recipient: {
                      email: 'john.d@example.com',
                      physicalAddress: {
                          name: 'John D',
                          line1: '123 ABC Street',
                          city: 'New York City',
                          state: 'NY',
                          postalCode: '10007',
                          country: 'US'
                      }
                  },
                  locale: 'en-US',
                  payment: {
                      receiptEmail: 'john.d@example.com',
                      method: 'basis-theory'
                  },
                  lineItems: [
                      {
                          productLocator: 'url:https://www.nike.com/t/maverick-valor-course-tint-sunglasses-1TrBw8KB/IF0969X-021'
                      }
                  ]
              })
          };

          fetch('https://staging.crossmint.com/api/2022-06-09/orders', options)
          .then(response => response.json())
          .then(response => console.log(response))
          .catch(err => console.error(err));
          ```

          ```python Python theme={null}
          import requests

          url = "https://staging.crossmint.com/api/2022-06-09/orders"
          headers = {
              "x-api-key": "<x-api-key>",
              "Content-Type": "application/json"
          }
          data = {
              "recipient": {
                  "email": "john.d@example.com",
                  "physicalAddress": {
                      "name": "John D",
                      "line1": "123 ABC Street",
                      "city": "New York City",
                      "state": "NY",
                      "postalCode": "10007",
                      "country": "US"
                  }
              },
              "locale": "en-US",
              "payment": {
                  "receiptEmail": "john.d@example.com",
                  "method": "basis-theory"
              },
              "lineItems": [
                  {
                      "productLocator": "url:https://www.nike.com/t/maverick-valor-course-tint-sunglasses-1TrBw8KB/IF0969X-021"
                  }
              ]
          }

          response = requests.post(url, json=data, headers=headers)
          print(response.json())
          ```
        </CodeGroup>

        <Accordion title="Example Response">
          ```json theme={null}
          {
            "clientSecret": "...",
            "order": {
              "orderId": "b2959ca5-65e4-466a-bd26-1bd05cb4f837",
              "phase": "payment",
            }
            ...
          }
          ```
        </Accordion>

        <Accordion title="How are products specified as part of a Crossmint order?">
          **General Websites**

          * Use `url:` prefix for any website with guest checkout on the internet
          * Product variants are specified in natural language, as shown below:

          ```
          url:https://www.nike.com/t/downshifter-13-mens-road-running-shoes-extra-wide-4M0LNf:9
          url:https://www.nike.com/t/downshifter-13-mens-road-running-shoes-extra-wide-4M0LNf:size-9
          url:https://www.nike.com/t/downshifter-13-mens-road-running-shoes-extra-wide-4M0LNf:size should be 9
          url:https://www.nike.com/t/downshifter-13-mens-road-running-shoes-extra-wide-4M0LNf:{"size":9}
          ```

          **Shopify**

          * Use `shopify:` prefix for Crossmint to place the order as Merchant of Record
          * Specify product variants by ID, fetching them using the route in Step 3 [here](/solutions/ai-agents/agentic-commerce/inventory#shopify)

          ```
          url:https://www.nike.com/t/downshifter-13-mens-road-running-shoes-extra-wide-4M0LNf:<
          ```

          **Amazon**

          * Use `amazon:` prefix for Crossmint to place the order as Merchant of Record
          * No variants are needed as Amazon URLs are unique

          ```
          amazon:https://www.amazon.com/Sparkling-Naturally-Essenced-Calories-Sweeteners/dp/B00O79SKV6
          ```
        </Accordion>
      </Step>

      <Step title="Complete payment">
        Use the `orderId` from the previous step's response and the `orderIntentId` from Step 4 to complete the payment.

        <CodeGroup>
          ```bash cURL theme={null}
          curl --request POST \
              --url 'https://staging.crossmint.com/api/2022-06-09/orders/<orderId>/payment' \
              --header 'x-api-key: <x-api-key>' \
              --header 'Authorization: Bearer <jwt>' \
              --header 'Content-Type: application/json' \
              --data '{
                "type": "crossmint-order-intent",
                "orderIntentId": "<order_intent_id_from_step_4>"
              }'
          ```

          ```js Node.js theme={null}
          const options = {
              method: 'POST',
              headers: {
                  'x-api-key': '<x-api-key>',
                  'Authorization': 'Bearer <jwt>',
                  'Content-Type': 'application/json'
              },
              body: JSON.stringify({
                  type: 'crossmint-order-intent',
                  orderIntentId: '<order_intent_id_from_step_4>'
              })
          };

          fetch('https://staging.crossmint.com/api/2022-06-09/orders/<orderId>/payment', options)
          .then(response => response.json())
          .then(response => console.log(response))
          .catch(err => console.error(err));
          ```

          ```python Python theme={null}
          import requests

          url = "https://staging.crossmint.com/api/2022-06-09/orders/<orderId>/payment"
          headers = {
              "x-api-key": "<x-api-key>",
              "Authorization": "Bearer <jwt>",
              "Content-Type": "application/json"
          }
          data = {
              "type": "crossmint-order-intent",
              "orderIntentId": "<order_intent_id_from_step_3>"
          }

          response = requests.post(url, json=data, headers=headers)
          print(response.json())
          ```
        </CodeGroup>

        Check the recipient's email inbox specified in Step 5 for a purchase receipt.
      </Step>
    </Steps>

    <CardGroup>
      <Card title="Try it out" icon="bolt" href="https://github.com/Crossmint/crossmint-checkout-tokenized-cc-demo/">
        See a demo that puts the above together in a repo you can quickly get started with
      </Card>
    </CardGroup>
  </Tab>

  <Tab title="Card Tokens">
    ## Integration Steps

    <Steps>
      <Step title="Obtain Crossmint API key">
        Create a project in the [Crossmint Console](https://staging.crossmint.com/signin?callbackUrl=/console) (staging environment), obtain a server-side API key from the Overview page, and make sure to save it for later use.
      </Step>

      <Step title="Set up authentication">
        Crossmint's Payment SDK and APIs makes use of JWTs to authenticate users. For staging and quick prototyping, you can use Crossmint Auth. For production, Crossmint recommends integrating with a third-party provider (such as Stytch, Auth0, or Dynamic) or using a custom JWT with a JWKS endpoint.

        For detailed setup instructions, see:

        * [Crossmint Authentication](/authentication/introduction) - Quick setup for staging and prototyping
        * [JWT Authentication Guide](/introduction/platform/api-keys/jwt-authentication) - Third-party providers and custom JWT options, recommended for production
      </Step>

      <Step title="Let the user choose a saved card or add a new card">
        Set up the Crossmint providers and handle authentication. Once authenticated, render the `CrossmintPaymentMethodManagement` component to allow users to select an existing saved card or add a new one. This component handles card tokenization for new cards and creates Crossmint payment methods automatically.

        ```tsx theme={null}
        "use client";
        import { CrossmintProvider, CrossmintPaymentMethodManagement, CrossmintAuthProvider, useCrossmintAuth, LoginButton } from "@crossmint/client-sdk-react-ui";

        export default function AgenticTokenizedCard() {
          return (
            <CrossmintProvider apiKey="<crossmint-client-api-key>">
              <CrossmintAuthProvider>
                <CrossmintPaymentMethodManagementWrapper/>
              </CrossmintAuthProvider>
            </CrossmintProvider>
          );
        }

        function CrossmintPaymentMethodManagementWrapper() {
          const { jwt } = useCrossmintAuth();
          if (!jwt) {
            return <LoginButton />;
          }
          return (
            <CrossmintPaymentMethodManagement jwt={jwt} />
          );
        }
        ```

        <Accordion title="Custom JWT Authentication">
          If you're using custom JWT authentication, pass your own JWT:

          ```tsx theme={null}
          <CrossmintCardManagement jwt="<your-jwt-token>" />
          ```
        </Accordion>

        <Accordion title="Example Form">
          <img alt="Payment checkout example" />
        </Accordion>

        Use this card to test the flow in staging:

        * Mastercard: `5186161910000103`
        * For `CVV` or `CVC`, use any 3 digit number
        * For `Expiry Date` or `MM/YY`, enter any future date
      </Step>

      <Step title="Set up payment method callback">
        Set up the `onPaymentMethodSelected` callback on the `CrossmintPaymentMethodManagement` component to receive the `CrossmintPaymentMethod` when a user either selects an existing saved card or successfully adds a new one. This callback will be triggered in both scenarios.

        ```tsx theme={null}
        function CrossmintPaymentMethodManagementWrapper() {
          const { jwt } = useCrossmintAuth();
          if (!jwt) {
            return <LoginButton />;
          }
          
          const handlePaymentMethodSelected = (paymentMethod: CrossmintPaymentMethod) => {
            console.log("Payment method selected:", paymentMethod.paymentMethodId);
          };

          return (
            <CrossmintPaymentMethodManagement 
              jwt={jwt} 
              onPaymentMethodSelected={handlePaymentMethodSelected}
            />
          );
        }
        ```
      </Step>

      <Step title="Create order">
        Call Crossmint's [Create Order API](/api-reference/headless/create-order) to create the order with the products you want to purchase.

        <CodeGroup>
          ```bash cURL theme={null}
          curl --request POST \
              --url 'https://staging.crossmint.com/api/2022-06-09/orders' \
              --header 'x-api-key: <x-api-key>' \
              --header 'Content-Type: application/json' \
              --data '{
                "recipient": {
                  "email": "john.d@example.com",
                  "physicalAddress": {
                    "name": "John D",
                    "line1": "123 ABC Street",
                    "city": "New York City",
                    "state": "NY",
                    "postalCode": "10007",
                    "country": "US"
                  }
                },
                "locale": "en-US",
                "payment": {
                  "receiptEmail": "john.d@example.com",
                  "method": "basis-theory"
                },
                "lineItems": [
                  {
                    "productLocator": "url:https://www.nike.com/t/maverick-valor-course-tint-sunglasses-1TrBw8KB/IF0969X-021"
                  }
                ]
              }'
          ```

          ```js Node.js theme={null}
          const options = {
              method: 'POST',
              headers: {
                  'x-api-key': '<x-api-key>',
                  'Content-Type': 'application/json'
              },
              body: JSON.stringify({
                  recipient: {
                      email: 'john.d@example.com',
                      physicalAddress: {
                          name: 'John D',
                          line1: '123 ABC Street',
                          city: 'New York City',
                          state: 'NY',
                          postalCode: '10007',
                          country: 'US'
                      }
                  },
                  locale: 'en-US',
                  payment: {
                      receiptEmail: 'john.d@example.com',
                      method: 'basis-theory'
                  },
                  lineItems: [
                      {
                          productLocator: 'url:https://www.nike.com/t/maverick-valor-course-tint-sunglasses-1TrBw8KB/IF0969X-021'
                      }
                  ]
              })
          };

          fetch('https://staging.crossmint.com/api/2022-06-09/orders', options)
          .then(response => response.json())
          .then(response => console.log(response))
          .catch(err => console.error(err));
          ```

          ```python Python theme={null}
          import requests

          url = "https://staging.crossmint.com/api/2022-06-09/orders"
          headers = {
              "x-api-key": "<x-api-key>",
              "Content-Type": "application/json"
          }
          data = {
              "recipient": {
                  "email": "john.d@example.com",
                  "physicalAddress": {
                      "name": "John D",
                      "line1": "123 ABC Street",
                      "city": "New York City",
                      "state": "NY",
                      "postalCode": "10007",
                      "country": "US"
                  }
              },
              "locale": "en-US",
              "payment": {
                  "receiptEmail": "john.d@example.com",
                  "method": "basis-theory"
              },
              "lineItems": [
                  {
                      "productLocator": "url:https://www.nike.com/t/maverick-valor-course-tint-sunglasses-1TrBw8KB/IF0969X-021"
                  }
              ]
          }

          response = requests.post(url, json=data, headers=headers)
          print(response.json())
          ```
        </CodeGroup>

        <Accordion title="Example Response">
          ```json theme={null}
          {
            "clientSecret": "...",
            "order": {
              "orderId": "b2959ca5-65e4-466a-bd26-1bd05cb4f837",
              "phase": "payment",
            }
            ...
          }
          ```
        </Accordion>

        <Accordion title="How are products specified as part of a Crossmint order?">
          **General Websites**

          * Use `url:` prefix for any website with guest checkout on the internet
          * Product variants are specified in natural language, as shown below:

          ```
          url:https://www.nike.com/t/downshifter-13-mens-road-running-shoes-extra-wide-4M0LNf:9
          url:https://www.nike.com/t/downshifter-13-mens-road-running-shoes-extra-wide-4M0LNf:size-9
          url:https://www.nike.com/t/downshifter-13-mens-road-running-shoes-extra-wide-4M0LNf:size should be 9
          url:https://www.nike.com/t/downshifter-13-mens-road-running-shoes-extra-wide-4M0LNf:{"size":9}
          ```

          **Shopify**

          * Use `shopify:` prefix for Crossmint to place the order as Merchant of Record
          * Specify product variants by ID, fetching them using the route in Step 3 [here](/solutions/ai-agents/agentic-commerce/inventory#shopify)

          ```
          url:https://www.nike.com/t/downshifter-13-mens-road-running-shoes-extra-wide-4M0LNf:<
          ```

          **Amazon**

          * Use `amazon:` prefix for Crossmint to place the order as Merchant of Record
          * No variants are needed as Amazon URLs are unique

          ```
          amazon:https://www.amazon.com/Sparkling-Naturally-Essenced-Calories-Sweeteners/dp/B00O79SKV6
          ```
        </Accordion>
      </Step>

      <Step title="Complete payment">
        Use the `orderId` from the previous step's response and the `paymentMethod.id` from Step 4 to complete the payment.

        <CodeGroup>
          ```bash cURL theme={null}
          curl --request POST \
              --url 'https://staging.crossmint.com/api/2022-06-09/orders/<orderId>/payment' \
              --header 'x-api-key: <x-api-key>' \
              --header 'Authorization: Bearer <jwt>' \
              --header 'Content-Type: application/json' \
              --data '{
                "type": "crossmint-payment-method",
                "paymentMethodId": "<payment_method_id_from_step_4>"
              }'
          ```

          ```js Node.js theme={null}
          const options = {
              method: 'POST',
              headers: {
                  'x-api-key': '<x-api-key>',
                  'Authorization': 'Bearer <jwt>',
                  'Content-Type': 'application/json'
              },
              body: JSON.stringify({
                  type: 'crossmint-payment-method',
                  paymentMethodId: '<payment_method_id_from_step_4>'
              })
          };

          fetch('https://staging.crossmint.com/api/2022-06-09/orders/<orderId>/payment', options)
          .then(response => response.json())
          .then(response => console.log(response))
          .catch(err => console.error(err));
          ```

          ```python Python theme={null}
          import requests

          url = "https://staging.crossmint.com/api/2022-06-09/orders/<orderId>/payment"
          headers = {
              "x-api-key": "<x-api-key>",
              "Authorization": "Bearer <jwt>",
              "Content-Type": "application/json"
          }
          data = {
              "type": "crossmint-payment-method",
              "paymentMethodId": "<payment_method_id_from_step_4>"
          }

          response = requests.post(url, json=data, headers=headers)
          print(response.json())
          ```
        </CodeGroup>

        Check the recipient's email inbox specified in Step 5 for a purchase receipt.
      </Step>
    </Steps>

    <CardGroup>
      <Card title="Try it out" icon="bolt" href="https://github.com/Crossmint/crossmint-checkout-tokenized-cc-demo/">
        See a demo that puts the above together in a repo you can quickly get started with
      </Card>
    </CardGroup>
  </Tab>

  <Tab title="USDC">
    ## Integration Steps

    <Steps>
      <Step title="Obtain Crossmint API key">
        Create a project in the [Crossmint Console](https://staging.crossmint.com/signin?callbackUrl=/console) (staging environment), obtain a server-side API key from the Overview page, and make sure to save it for later use.
      </Step>

      <Step title="Create wallet">
        <Note> If you already have a wallet for your agent jump to step 2.</Note>

        Create a dedicated wallet that will hold funds for the agent to perform transactions.

        * Visit the [Crossmint Console](https://staging.crossmint.com/signin?callbackUrl=/console)
        * Navigate to Wallets > Settings and select Smart Wallets.
        * Go to Wallets > Users, click "Create new wallet", and enter EVM as chain and `AGENT01` as the userId
        * Copy the wallet address from the table

        <Accordion title="Alternative: Create a wallet programmatically">
          You can also create an agent wallet programmatically via Crossmint's [Create Wallets API](/api-reference/wallets/create-wallet?playground=open).

          <CodeGroup>
            ```bash cURL theme={null}
            curl --request POST \
                --url 'https://staging.crossmint.com/api/2022-06-09/wallets' \
                --header 'Content-Type: application/json' \
                --header 'X-API-KEY: <x-api-key>' \
                --data '{
                  "type": "evm-smart-wallet",
                  "config": {
                    "adminSigner": {
                      "type": "evm-fireblocks-custodial"
                    }
                  }
                }'
            ```

            ```js Node.js theme={null}
            const options = {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    'X-API-KEY': '<x-api-key>'
                },
                body: JSON.stringify({
                    type: 'evm-smart-wallet',
                    config: {
                        adminSigner: {
                            type: 'evm-fireblocks-custodial'
                        }
                    }
                })
            };

            fetch('https://staging.crossmint.com/api/2022-06-09/wallets', options)
            .then(response => response.json())
            .then(response => console.log(response))
            .catch(err => console.error(err));
            ```

            ```python Python theme={null}
            import requests

            url = "https://staging.crossmint.com/api/2022-06-09/wallets"
            headers = {
                "Content-Type": "application/json",
                "X-API-KEY": "<x-api-key>"
            }
            data = {
                "type": "evm-smart-wallet",
                "config": {
                    "adminSigner": {
                        "type": "evm-fireblocks-custodial"
                    }
                }
            }

            response = requests.post(url, json=data, headers=headers)
            print(response.json())
            ```
          </CodeGroup>

          **Example response:**

          ```json theme={null}
          {
            "id": "01234567-89ab-cdef-0123-456789abcdef",
            "address": "0x1234567890123456789012345678901234567890",
            "type": "evm-smart-wallet",
            "chain": "ethereum-sepolia",
            "linkedUser": null,
            "createdAt": "2024-01-15T10:30:00.000Z"
          }
          ```

          <Warning> The `evm-fireblocks-custodial` configuration creates a custodial wallet. Switch to a non-custodial wallet when in production. Read more [here](/wallets/concepts/custody-modalities). </Warning>
        </Accordion>
      </Step>

      <Step title="Fund wallet">
        Fund the agent using [Crossmint's faucet website](https://usdc-faucet.vercel.app/) or programmatically via the [Fund Wallet API](https://docs.crossmint.com/api-reference/wallets/fund-wallet).
      </Step>

      <Step title="Create order">
        With available USDC funds in its wallet, the agent can now call Crossmint's [Create Orders API](/api-reference/headless/create-order) to purchase items from Amazon, Shopify, and other supported marketplaces.

        <CodeGroup>
          ```bash cURL theme={null}
          curl --request POST \
              --url 'https://staging.crossmint.com/api/2022-06-09/orders' \
              --header 'x-api-key: <x-api-key>' \
              --header 'Content-Type: application/json' \
              --data '{
                "recipient": {
                  "email": "j.doe@gmail.com",
                  "physicalAddress": {
                    "name": "John Doe",
                    "line1": "ABC Street",
                    "city": "New York",
                    "state": "NY",
                    "postalCode": "10007",
                    "country": "US"
                  }
                },
                "payment": {
                  "method": "ethereum-sepolia",
                  "currency": "usdc",
                  "payerAddress": "0x..."
                },
                "lineItems": [
                  {
                    "productLocator": "amazon:https://www.amazon.com/Celsius-Sparkling-Berry-Fluid-Ounce/dp/B001PN0HOU"
                  }
                ]
              }'
          ```

          ```js Node.js theme={null}
          const options = {
              method: 'POST',
              headers: {
                  'x-api-key': '<x-api-key>',
                  'Content-Type': 'application/json'
              },
              body: JSON.stringify({
                  recipient: {
                      email: 'j.doe@gmail.com',
                      physicalAddress: {
                          name: 'John Doe',
                          line1: 'ABC Street',
                          city: 'New York',
                          state: 'NY',
                          postalCode: '10007',
                          country: 'US'
                      }
                  },
                  payment: {
                      method: 'ethereum-sepolia',
                      currency: 'usdc',
                      payerAddress: '0x...' // Agent's wallet address created above
                  },
                  lineItems: [
                      {
                          productLocator: 'amazon:https://www.amazon.com/Celsius-Sparkling-Berry-Fluid-Ounce/dp/B001PN0HOU'
                      }
                  ]
              })
          };

          fetch('https://staging.crossmint.com/api/2022-06-09/orders', options)
          .then(response => response.json())
          .then(response => console.log(response))
          .catch(err => console.error(err));
          ```

          ```python Python theme={null}
          import requests

          url = "https://staging.crossmint.com/api/2022-06-09/orders"
          headers = {
              "x-api-key": "<x-api-key>",
              "Content-Type": "application/json"
          }
          data = {
              "recipient": {
                  "email": "j.doe@gmail.com",
                  "physicalAddress": {
                      "name": "John Doe",
                      "line1": "ABC Street",
                      "city": "New York",
                      "state": "NY",
                      "postalCode": "10007",
                      "country": "US"
                  }
              },
              "payment": {
                  "method": "ethereum-sepolia",
                  "currency": "usdc",
                  "payerAddress": "0x..."  # Agent's wallet address created above
              },
              "lineItems": [
                  {
                      "productLocator": "amazon:https://www.amazon.com/Celsius-Sparkling-Berry-Fluid-Ounce/dp/B001PN0HOU"
                  }
              ]
          }

          response = requests.post(url, json=data, headers=headers)
          print(response.json())
          ```
        </CodeGroup>

        <Accordion title="Example response">
          ```json theme={null}
          {
            "clientSecret": "...",
            "order": {
              "orderId": "b2959ca5-65e4-466a-bd26-1bd05cb4f837",
              ...
              "quote": {...},
              "payment": {
                "status": "awaiting-payment",
                "method": "ethereum-sepolia",
                "currency": "usdc",
                "preparation": {
                  "chain": "ethereum-sepolia",
                  "payerAddress": "0x1234abcd...",
                  "serializedTransaction": "0x02f90....."
                }
              }
            }
          }
          ```
        </Accordion>

        <Accordion title="How are products specified as part of a Crossmint order?">
          **General Websites**

          * Use `url:` prefix for any website with guest checkout on the internet
          * Product variants are specified in natural language, as shown below:

          ```
          url:https://www.nike.com/t/downshifter-13-mens-road-running-shoes-extra-wide-4M0LNf:9
          url:https://www.nike.com/t/downshifter-13-mens-road-running-shoes-extra-wide-4M0LNf:size-9
          url:https://www.nike.com/t/downshifter-13-mens-road-running-shoes-extra-wide-4M0LNf:size should be 9
          url:https://www.nike.com/t/downshifter-13-mens-road-running-shoes-extra-wide-4M0LNf:{"size":9}
          ```

          **Shopify**

          * Use `shopify:` prefix for Crossmint to place the order as Merchant of Record
          * Specify product variants by ID, fetching them using the route in Step 3 [here](/solutions/ai-agents/agentic-commerce/inventory#shopify)

          ```
          url:https://www.nike.com/t/downshifter-13-mens-road-running-shoes-extra-wide-4M0LNf:<
          ```

          **Amazon**

          * Use `amazon:` prefix for Crossmint to place the order as Merchant of Record
          * No variants are needed as Amazon URLs are unique

          ```
          amazon:https://www.amazon.com/Sparkling-Naturally-Essenced-Calories-Sweeteners/dp/B00O79SKV6
          ```
        </Accordion>

        <Note> A single order can include multiple products as part of the `lineItems` array only if all items originate from the same platform (either all Amazon or all Shopify). </Note>
      </Step>

      <Step title="Complete payment">
        The agent completes payment by passing the `serializedTransaction` from the previous step's response to Crossmint's [Create Transaction API](/api-reference/wallets/create-transaction)

        <CodeGroup>
          ```bash cURL theme={null}
          curl --request POST \
              --url 'https://staging.crossmint.com/api/2022-06-09/wallets/${agentWallet}/transactions' \
              --header 'Content-Type: application/json' \
              --header 'X-API-KEY: <x-api-key>' \
              --data '{
                "params": {
                  "calls": [{
                    "transaction": "0x...."
                  }],
                  "chain": "ethereum-sepolia"
                }
              }'
          ```

          ```js Node.js theme={null}
          const options = {
              method: 'POST',
              headers: {
                  'Content-Type': 'application/json',
                  'X-API-KEY': '<x-api-key>'
              },
              body: JSON.stringify({
                  params: {
                      calls: [{
                          transaction: '0x....' // serializedTransaction obtained from the previous step response
                      }],
                      chain: 'ethereum-sepolia'
                  }
              })
          };

          fetch('https://staging.crossmint.com/api/2022-06-09/wallets/${agentWallet}/transactions', options)
          .then(response => response.json())
          .then(response => console.log(response))
          .catch(err => console.error(err));
          ```

          ```python Python theme={null}
          import requests

          url = "https://staging.crossmint.com/api/2022-06-09/wallets/${agentWallet}/transactions"
          headers = {
              "Content-Type": "application/json",
              "X-API-KEY": "<x-api-key>"
          }
          data = {
              "params": {
                  "calls": [{
                      "transaction": "0x...."  # serializedTransaction obtained from the previous step response
                  }],
                  "chain": "ethereum-sepolia"
              }
          }

          response = requests.post(url, json=data, headers=headers)
          print(response.json())
          ```
        </CodeGroup>

        This completes the purchase flow, with the agent successfully buying items on behalf of the user using the USDC funds provided to it.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Crossmint Credits">
    ## Integration Steps

    Crossmint Credits are tokens minted by Crossmint and 1:1 with USD. They can only be used for product purchases that Crossmint acts as the Merchant of Record (MoR), i.e. agent sends funds to Crossmint and Crossmint buys the product from the merchant on behalf of the agent.

    <Note> Use this option if users will choose to top up the agent's balance using a **credit or debit card**. </Note>

    <Steps>
      <Step title="Obtain Crossmint API key">
        Create a project in the [Crossmint Console](https://staging.crossmint.com/signin?callbackUrl=/console) (staging environment), obtain a server-side API key from the Overview page, and make sure to save it for later use.
      </Step>

      <Step title="Create wallet">
        <Note> If you already have a wallet for your agent jump to step 2.</Note>

        Create a dedicated wallet that will hold funds for the agent to perform transactions.

        * Visit the [Crossmint Console](https://staging.crossmint.com/signin?callbackUrl=/console)
        * Navigate to Wallets > Settings and select Smart Wallets.
        * Go to Wallets > Users, click "Create new wallet", and enter EVM as chain and `AGENT01` as the userId
        * Copy the wallet address from the table

        <Accordion title="Alternative: Create a wallet programmatically">
          You can also create an agent wallet programmatically via Crossmint's [Create Wallets API](/api-reference/wallets/create-wallet?playground=open).

          <CodeGroup>
            ```bash cURL theme={null}
            curl --request POST \
                --url 'https://staging.crossmint.com/api/2022-06-09/wallets' \
                --header 'Content-Type: application/json' \
                --header 'X-API-KEY: <x-api-key>' \
                --data '{
                  "type": "evm-smart-wallet",
                  "config": {
                    "adminSigner": {
                      "type": "evm-fireblocks-custodial"
                    }
                  }
                }'
            ```

            ```js Node.js theme={null}
            const options = {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    'X-API-KEY': '<x-api-key>'
                },
                body: JSON.stringify({
                    type: 'evm-smart-wallet',
                    config: {
                        adminSigner: {
                            type: 'evm-fireblocks-custodial'
                        }
                    }
                })
            };

            fetch('https://staging.crossmint.com/api/2022-06-09/wallets', options)
            .then(response => response.json())
            .then(response => console.log(response))
            .catch(err => console.error(err));
            ```

            ```python Python theme={null}
            import requests

            url = "https://staging.crossmint.com/api/2022-06-09/wallets"
            headers = {
                "Content-Type": "application/json",
                "X-API-KEY": "<x-api-key>"
            }
            data = {
                "type": "evm-smart-wallet",
                "config": {
                    "adminSigner": {
                        "type": "evm-fireblocks-custodial"
                    }
                }
            }

            response = requests.post(url, json=data, headers=headers)
            print(response.json())
            ```
          </CodeGroup>

          **Example response:**

          ```json theme={null}
          {
            "id": "01234567-89ab-cdef-0123-456789abcdef",
            "address": "0x1234567890123456789012345678901234567890",
            "type": "evm-smart-wallet",
            "chain": "ethereum-sepolia",
            "linkedUser": null,
            "createdAt": "2024-01-15T10:30:00.000Z"
          }
          ```

          <Warning> The `evm-fireblocks-custodial` configuration creates a custodial wallet. Switch to a non-custodial wallet when in production. Read more [here](/wallets/concepts/custody-modalities). </Warning>
        </Accordion>
      </Step>

      <Step title="Fund wallet">
        In order to fund the agent with a user's card, render an embedded checkout window in your app, using Crossmint's Embedded Checkout.

        ```tsx theme={null}
        <CrossmintEmbeddedCheckout
            recipient={{
                // Agent's wallet address created above
                walletAddress: "0x...",
            }}
            lineItems={[
                {
                    tokenLocator:
                        "ethereum-sepolia:0xe9fFA6956BFfC367B26dD3c256CF0C978603Eaec:0xe9fFA6956BFfC367B26dD3c256CF0C978603Eaec",
                    executionParameters: {
                        mode: "exact-in",
                        // The amount the user wants to fund the wallet with
                        amount: "1",
                        maxSlippageBps: "0",
                    },
                },
            ]}
            payment={{
                // The user's email
                receiptEmail: "j.doe@gmail.com",
                crypto: {
                    enabled: false,
                },
                fiat: {
                    enabled: true,
                },
                defaultMethod: "fiat",
            }}
        />
        ```

        The `0xe9fFA6956BFfC367B26dD3c256CF0C978603Eaec` token address represents the credits your agent will hold in its wallet and can use to purchase items from supported marketplaces.
      </Step>

      <Step title="Create order">
        With available funds in the wallet, the agent can now call Crossmint's [Create Orders API](/api-reference/headless/create-order) to purchase items from Amazon, Shopify, and other supported marketplaces.

        ```typescript theme={null}
        // API Route: POST https://staging.crossmint.com/api/2022-06-09/orders

        const orderData = {
            recipient: {
                email: "j.doe@gmail.com",
                physicalAddress: {
                    name: "John Doe",
                    line1: "ABC Street",
                    city: "New York",
                    state: "NY",
                    postalCode: "10007",
                    country: "US",
                },
            },
            payment: {
                method: "ethereum-sepolia",
                // Payment is done via Crossmint Credits
                currency: "credit",
                // Agent's wallet address created above
                payerAddress: "0x...",
            },
            lineItems: [{ productLocator: "amazon:https://www.amazon.com/Celsius-Sparkling-Berry-Fluid-Ounce/dp/B001PN0HOU" }],
        };
        ```

        <Accordion title="Example response">
          ```json theme={null}
          {
            "clientSecret": "...",
            "order": {
              "orderId": "b2959ca5-65e4-466a-bd26-1bd05cb4f837",
              ...
              "quote": {...},
              "payment": {
                "status": "awaiting-payment",
                "method": "ethereum-sepolia",
                "currency": "usdc",
                "preparation": {
                  "chain": "ethereum-sepolia",
                  "payerAddress": "0x1234abcd...",
                  "serializedTransaction": "0x02f90....."
                }
              }
            }
          }
          ```
        </Accordion>

        <Accordion title="How are products specified as part of a Crossmint order?">
          **General Websites**

          * Use `url:` prefix for any website with guest checkout on the internet
          * Product variants are specified in natural language, as shown below:

          ```
          url:https://www.nike.com/t/downshifter-13-mens-road-running-shoes-extra-wide-4M0LNf:9
          url:https://www.nike.com/t/downshifter-13-mens-road-running-shoes-extra-wide-4M0LNf:size-9
          url:https://www.nike.com/t/downshifter-13-mens-road-running-shoes-extra-wide-4M0LNf:size should be 9
          url:https://www.nike.com/t/downshifter-13-mens-road-running-shoes-extra-wide-4M0LNf:{"size":9}
          ```

          **Shopify**

          * Use `shopify:` prefix for Crossmint to place the order as Merchant of Record
          * Specify product variants by ID, fetching them using the route in Step 3 [here](/solutions/ai-agents/agentic-commerce/inventory#shopify)

          ```
          url:https://www.nike.com/t/downshifter-13-mens-road-running-shoes-extra-wide-4M0LNf:<
          ```

          **Amazon**

          * Use `amazon:` prefix for Crossmint to place the order as Merchant of Record
          * No variants are needed as Amazon URLs are unique

          ```
          amazon:https://www.amazon.com/Sparkling-Naturally-Essenced-Calories-Sweeteners/dp/B00O79SKV6
          ```
        </Accordion>

        <Note> A single order can include multiple products as part of the `lineItems` array only if all items originate from the same platform (either all Amazon or all Shopify). </Note>
      </Step>

      <Step title="Complete payment">
        The agent completes payment by passing the `serializedTransaction` from the previous step's response to Crossmint's [Create Transaction API](/api-reference/wallets/create-transaction)

        <CodeGroup>
          ```bash cURL theme={null}
          curl --request POST \
              --url 'https://staging.crossmint.com/api/2022-06-09/wallets/${agentWallet}/transactions' \
              --header 'Content-Type: application/json' \
              --header 'X-API-KEY: <x-api-key>' \
              --data '{
                "params": {
                  "calls": [{
                    "transaction": "0x...."
                  }],
                  "chain": "ethereum-sepolia"
                }
              }'
          ```

          ```js Node.js theme={null}
          const options = {
              method: 'POST',
              headers: {
                  'Content-Type': 'application/json',
                  'X-API-KEY': '<x-api-key>'
              },
              body: JSON.stringify({
                  params: {
                      calls: [{
                          transaction: '0x....' // serializedTransaction obtained from the previous step response
                      }],
                      chain: 'ethereum-sepolia'
                  }
              })
          };

          fetch('https://staging.crossmint.com/api/2022-06-09/wallets/${agentWallet}/transactions', options)
          .then(response => response.json())
          .then(response => console.log(response))
          .catch(err => console.error(err));
          ```

          ```python Python theme={null}
          import requests

          url = "https://staging.crossmint.com/api/2022-06-09/wallets/${agentWallet}/transactions"
          headers = {
              "Content-Type": "application/json",
              "X-API-KEY": "<x-api-key>"
          }
          data = {
              "params": {
                  "calls": [{
                      "transaction": "0x...."  # serializedTransaction obtained from the previous step response
                  }],
                  "chain": "ethereum-sepolia"
              }
          }

          response = requests.post(url, json=data, headers=headers)
          print(response.json())
          ```
        </CodeGroup>

        This completes the purchase flow, with the agent autonomously buying items on behalf of the user using Crossmint credits in its wallet.
      </Step>
    </Steps>
  </Tab>
</Tabs>


# Moving to Production
Source: https://docs.crossmint.com/solutions/ai-agents/agentic-commerce/production-deployment

Deploy autonomous commercial transactions to production

<Snippet />

## Moving to Production

Once you've tested your integration in staging, follow these steps to deploy to production:

<Steps>
  <Step title="Create Production Project">
    Create a new project in the [Crossmint Console](https://www.crossmint.com/signin?callbackUrl=/console) using the
    **production** environment
  </Step>

  <Step title="Production API Key">
    Generate a production API key with the required scopes: `orders.create`, `orders.ws.search`, `orders.ws.create`,
    `orders.read`, `wallets:transactions.create`
  </Step>

  <Step title="Update Configuration">
    Update your application to use the production API key and production endpoints
  </Step>

  <Step title="Test Production Flow">
    Perform end-to-end testing with real payment methods to ensure everything works correctly
  </Step>
</Steps>


# Overview
Source: https://docs.crossmint.com/solutions/ai-agents/introduction

Allow agents to purchase physical goods programmatically

<iframe title="YouTube video player" />

<Snippet />

Consumers increasingly rely on AI agents to inform their purchase decisions. However, agents face a critical limitation:
they cannot complete the actual purchase. They're blocked by CAPTCHAs, anti-fraud systems, and lack of access to payment
credentials.

Crossmint Checkout enables your AI agent to make purchases for its users.

Crossmint enables agents to pay using credit cards or stablecoins, supporting an inventory of over 1 billion
items - from Amazon and Shopify to any browser-accessible guest checkout.

## Steps To Integrate

<CardGroup>
  <Card title="1. Delegate Payment Method to Agent" icon="wallet" href="/solutions/ai-agents/agentic-commerce/payment-methods">
    Delegate the user's card, or stablecoins, for the agent to make transactions.
  </Card>

  <Card title="2. Create a Purchase Order" icon="cart-shopping" href="/solutions/ai-agents/agentic-commerce/inventory">
    Use the delegated payment method to make purchases from the agent backend.
  </Card>

  <Card title="3. Check Order Lifecycle" icon="truck" href="/solutions/ai-agents/agentic-commerce/order-tracking">
    Track the status of your agent's orders, including fulfillment, shipping, and delivery updates.
  </Card>

  <Card title="4. Move to Production" icon="rocket" href="/solutions/ai-agents/agentic-commerce/production-deployment">
    Review production-readiness requirements and deploy your agentic commerce integration live.
  </Card>
</CardGroup>

## FAQs

<AccordionGroup>
  <Accordion title="What payment methods are supported?">
    * Credit Cards: Visa, Mastercard, Discover, American Express

    * Agent Credit Card Tokens: Visa Intelligent Commerce and Mastercard Agent Pay (in private Beta)

    * Stablecoins: USDC, USDT, with additional options available on request

    * Closed-loop tokens: Merchant-specific credits (e.g., "Starbucks dollars")
  </Accordion>

  <Accordion title="What can agents purchase?">
    * Any credit card-enabled guest checkout accessible via browser

    * Amazon (US), all Shopify merchants, and global flight bookings

    * Additional merchants added monthly through direct integrations
  </Accordion>

  <Accordion title="What other tools does Crossmint offer to agents?">
    All Crossmint APIs are agent-compatible. Key tools for agentic use cases include:

    * [**Programmable Wallets**](/wallets/quickstarts/nodejs): Enable agents to securely hold and transact with funds.
      These remain non-custodial and don't require you to hold licenses.

    * [**Verifiable Credentials**](/minting/quickstarts/credentials): Issue and verify cryptographic credentials
      to authenticate agents.
  </Accordion>

  <Accordion title="Who acts as merchant of record in a purchase?">
    You (the agent developer) never act as merchant of record. Depending on the purchase route and
    user preferences, either the end merchant or Crossmint serves as the merchant of record. From the user's perspective,
    this distinction is transparent.
  </Accordion>

  <Accordion title="How do returns and refunds work?">
    In most cases, customers can work directly with the end merchant. Crossmint will soon provide APIs
    to initiate returns and support requests directly through your agent.
  </Accordion>

  <Accordion title="Is this solution legally compliant?">
    Crossmint's solution complies with PCI standards and all commercial regulations in our operating regions.
    As an agent developer, you don't need to manage PCI compliance, sales tax collection, or similar requirements -
    Crossmint handles these on your behalf.
  </Accordion>

  <Accordion title="Is this production ready?">
    Yes. Crossmint Checkout processes tens of millions of dollars in annual transaction volume. The only feature not
    fully live is Visa and Mastercard agent tokens, which will be released publicly with them later this year.
  </Accordion>
</AccordionGroup>


# Global Payroll
Source: https://docs.crossmint.com/solutions/fintech/global-payroll

Pay employees and contractors worldwide instantly

## Overview

Transform your payroll operations with instant, borderless payments. Pay employees and contractors globally using
stablecoins, eliminating wire transfer delays, reducing costs by up to 90%, and providing workers with instant access
to their earnings - regardless of their location or banking infrastructure.

This solution is ideal for:

<AccordionGroup>
  <Accordion title="Remote-First Companies">
    Pay distributed teams across the globe instantly. Eliminate the complexity of managing multiple banking relationships and currency conversions for international payroll.
  </Accordion>

  <Accordion title="Contractor Management Platforms">
    Enable instant payments to freelancers and contractors worldwide. Offer competitive payment terms with same-day or real-time settlement options.
  </Accordion>

  <Accordion title="BPO & Outsourcing Firms">
    Streamline payroll for offshore teams and reduce transfer costs. Pay workers in emerging markets where traditional banking infrastructure is limited.
  </Accordion>
</AccordionGroup>

## Common Architectures

1. **Instant Payroll**: Convert fiat payroll to stablecoins and distribute to employee wallets instantly
2. **Programmable Payroll**: Automate recurring payroll distributions on custom schedules or conditions

<Info>
  Need a custom flow for your use case? Our support team can help you design, build, and optimize it end-to-end. [Reach out to get started](https://www.crossmint.com/contact/sales).
</Info>

## How It Works

1. **Compliance**: Use Crossmint's licenses or bring your own
2. **Wallets**: Use Crossmint's wallets, which can be configured in both custodial, or non-custodial modes
3. **Onramp**: Optionally, have the user initiate the transaction with credit card or bank transfer
4. **Stablecoin Transfer**: Instant transfers, without needing to deal with gas fees, retries, sanctions checks
5. **Receive Funds**: Receive the money in stablecoin, bank account, or local payment methods

All stablecoins are supported, in over 50 supported [chains](/introduction/supported-chains).

## Integration Steps

*Integration guide coming soon. [Contact our sales team](https://www.crossmint.com/contact/sales) to request a consultation to help you design and integrate.*


# Neobanks
Source: https://docs.crossmint.com/solutions/fintech/neobanks

Launch a global stablecoin neobank product in days

This guide walks through how to build a modern stablecoin-powered neobank from scratch—or integrate stablecoin capabilities into your existing banking platform—using Crossmint's infrastructure.

## Overview

With stablecoins, you can launch global accounts and other financial products in days, build better experiences than traditional banking, and unlock new revenue streams.

<Accordion title="Key benefits">
  * **Global reach** — Serve customers in 180+ different countries from day one.
  * **New revenue streams** — Generate 3-4% of interest on deposits and offer embedded financial products including cards, trading, prediction markets, and more.
  * **Instant settlement** — Enable 24/7 instant transfers instead of 2-5 day settlement windows.
  * **Lower costs** — Reduce international transfer costs. Eliminate correspondent banking fees and reduce pre-funding requirements.
</Accordion>

Crossmint offers the full technology stack and licensing to help you launch faster, without having to orchestrate many different vendors, including wallets, on and offramps, and additional embedded finance products.

## Key Architectural Decisions

Building a stablecoin-powered neobank requires making several foundational architectural decisions. These choices shape your product capabilities, regulatory requirements, and unit economics. The optimal architecture depends on whether you're launching a new digital bank or enhancing an existing platform, your preference around custody, and what infrastructure you have already built.

### Key components

There are three key components:

1. **Wallets** — The foundation of the system. Wallets allow users to hold, send, and receive stablecoins and other crypto assets.
2. **On and offramps** — Allow users to fund and withdraw funds from their wallets.
3. **Embedded financial services** — Additional products built on top of wallets, including yield, cards, swaps, trading, and more.

### Existing vs new neobanks

**Existing neobanks** typically reuse their core banking and payment infrastructure, adding stablecoins as a complementary payment rail. Some expose both fiat and stablecoin balances within their current geographies, while others launch separate, globally available products built primarily around stablecoins.

**New neobanks** have the advantage of building stablecoin-first from the ground up. They can design the entire customer experience and flows around blockchain rails from day one. They also often start with plug-and-play on/offramps to go-to-market faster instead of relying on traditional payments processors.

### Custody model

The custody decision is fundamental—it determines who controls the private keys to customer funds, which shapes your regulatory obligations, liability exposure, operational complexity, and product capabilities. Crossmint supports multiple custody models, and many neobanks use different approaches for different customer segments or account types.

The general recommendation is to use non-custodial wallets as they offer global coverage from day one, more functionality, lower cost, compliance, and operational overhead; without compromising on user experience.

<AccordionGroup>
  <Accordion title="Custodial wallets">
    Private keys are held by Crossmint, an affiliated partner, or by you on behalf of your users. You can choose between segregated wallets or an omnibus wallet structure.

    Omnibus wallets are generally not recommended. They significantly constrain future functionality and external integrations, and concentrate risk by pooling funds in a single structure.

    **Best for:** Companies focusing on only one or a small subset of geographies. Closed-loop systems. Non-financial use cases.

    **Tradeoffs:** Significantly higher operational and compliance burden and costs (KYC, insurance, additional security controls, travel rule checks in and out of the wallets). More complex and fragile external integrations (e.g., cards, banking rails, and third-party payment providers).
  </Accordion>

  <Accordion title="Non-custodial wallets">
    Users control their own private keys, accessed through intuitive web2-style authentication (email, social login, biometrics, passkeys). Behind the scenes, Crossmint handles all of the complexity so the blockchain is invisible to the user.

    **Best for:** Global products. Apps that interact with third-parties or protocols: paying merchants, signing transactions, accessing DeFi protocols.

    **Tradeoffs:** Same UX as custodial wallets. Some traditional banking features (like reversing fraudulent transactions) become difficult or impossible.
  </Accordion>

  <Accordion title="Hybrid custody">
    Crossmint allows you to define custody granularly at the user, asset, or transaction level. This allows you to combine both strategically, everything with the same API. For example, offering custodial wallets in the US and non-custodial internationally. Or start with one model and then migrate to the other one, without having to migrate vendors or change wallet addresses.
  </Accordion>
</AccordionGroup>

### Onramp structure

How users move between fiat currency and stablecoins is critical to your product's accessibility and regulatory posture. You have flexibility in how much of this infrastructure you own vs leverage from Crossmint.

<AccordionGroup>
  <Accordion title="Stablecoin payouts">
    You pre-fund Crossmint and use a single API to deliver funds to users' wallets. This model gives you full control over the onramp experience while Crossmint handles the licensing, stablecoin settlement, and compliance checks. Best for teams that already work with their own PSPs and just need the stablecoin last-mile. Read more about [stablecoin orchestration](/stablecoin-orchestration/money-movement/overview).
  </Accordion>

  <Accordion title="End-to-end onramps/offramps">
    Crossmint manages the entire flow including payment processing, fraud prevention, chargebacks, currency conversion, KYC/AML, and regulatory compliance. Best for teams who want a plug-and-play solution, want to reduce their chargeback exposure, or don't have an internal anti-fraud team. Read more about the [onramp](/payments/introduction).
  </Accordion>
</AccordionGroup>

### Approach to yield

There are multiple ways to generate yield. You can read more about [yield strategies](/wallets/concepts/wallet-extensions/yield-introduction).

### Embedded financial services

Beyond core banking capabilities, stablecoins unlock a rich ecosystem of embedded financial products that can offer more value to your customers and unlock new revenue streams:

* **Cards** — Virtual and physical debit cards that spend directly from stablecoin balances, with instant settlement and transparent fees. Capture interchange revenue while offering customers global spending power.
* **Trading** — Enable swaps between stablecoins, cryptocurrencies, and other digital assets. Capture spread revenue while providing customers access to crypto investment opportunities.
* **Yield products** — High-yield savings accounts, automated yield optimization, and access to structured products. Generate fee revenue while offering rates that crush traditional banks.
* **Prediction markets** — Let customers participate in decentralized prediction markets for events, elections, or market outcomes—a unique offering unavailable through traditional banks.
* **DeFi access** — For crypto-savvy users, provide direct access to lending protocols, DEXs, and other DeFi primitives through your interface.

The key is selecting the right mix for your target customer segment and regulatory environment. Start with core features and add capabilities incrementally based on user demand and market readiness.

<Info>
  Need a custom solution? Crossmint's Forward Deployment Engineers can help you design, build, and optimize it end-to-end. [Reach out to set up a personalized consultation](https://www.crossmint.com/contact/sales).
</Info>

## Solution Components

Crossmint's platform provides all the building blocks needed to implement any of the architectures above via simple APIs. Key solution components include:

<CardGroup>
  <Card title="Embedded wallets" icon="wallet" href="/wallets/overview">
    Create wallets for your users.
  </Card>

  <Card title="Onramp" icon="arrow-up-to-line" href="/payments/introduction">
    Allow users to fund their wallets directly.
  </Card>

  <Card title="Stablecoin orchestration" icon="coins" href="/stablecoin-orchestration/money-movement/overview">
    Send stablecoins to users.
  </Card>

  <Card title="Cards" icon="credit-card" href="https://www.crossmint.com/contact/sales">
    Issue stablecoin-linked cards.
  </Card>

  <Card title="Yield" icon="chart-line-up" href="/wallets/concepts/wallet-extensions/yield-introduction">
    Earn yield on balances.
  </Card>
</CardGroup>

## Get Started

<Snippet />


# Remittances
Source: https://docs.crossmint.com/solutions/fintech/remittances

Build modern remittance flows that are faster, lower cost, and unlock new revenue streams

This guide explains the key architectural decisions involved in building stablecoin remittance flows and how to implement them with Crossmint's infrastructure.

## Overview

Stablecoins provide remittance providers with a faster and more cost-effective alternative to traditional correspondent banking infrastructure.

Key benefits include:

* **Lower costs:** Eliminate SWIFT and correspondent banking fees. Reduce costs from 5-10% to a few basis points.
* **Faster settlement:** Provides instant settlement, improves working capital, and reduces pre-funding requirements across corridors.
* **New Revenue Streams:** Earn yield on operational treasury and user balances, and offer digital wallets and embedded financial products—such as yield, cards, and trading—through a single integration across 150+ markets.
* **Unlock Underserved Corridors:** Enable service in markets with limited banking infrastructure or where traditional correspondent banking is prohibitively expensive.

## How it Works

Stablecoin remittance products can be built in multiple ways. The right approach depends on your current infrastructure and the user experience you want to create for senders and recipients.

In practice, every remittance flow is defined by two independent decisions:

1. How funds enter the system
2. How recipients receive funds

### 1. How funds enter the system

#### Treasury-based model

In this model, the remittance provider receives fiat from senders and converts it into stablecoins, which are held in a centrally managed treasury wallet. You can pre-fund the treasury to enable instant payouts, or convert to stablecoins real time. Best for existing remittance providers without a sender wallet.

#### Sender wallet model

Senders first fund a wallet, then initiate transfers from their balance. This introduces an extra step, but unlocks additional capabilities: in-app balances for senders, peer-to-peer transfers, recurring or programmable payments, and a broader wallet-based product offering. Best for wallet-first companies.

### 2. How recipients receive funds

#### Fiat payout

Stablecoins are used purely as the settlement rail. Funds are automatically converted to local currency and delivered via bank transfer, mobile money, or cash pickup.

#### Stablecoin payout

Recipients receive funds directly into an embedded wallet. This lets them hold USD-denominated value, hedge against local currency volatility, earn yield, or cash out on their own terms—while unlocking new revenue streams for you. Wallets can be pre-generated, so recipients don't need to sign up before receiving funds; they simply log in and see their balance instantly.

### Combining these modules

These models are fully composable and can be combined to support different remittance flows, for example:

* Treasury-based funding → stablecoin payouts (most common)
* Treasury-based funding → fiat payouts
* Sender wallets → stablecoin payouts
* Sender wallets → fiat payouts

<Frame type="simple">
  <img alt="Treasury-Based Model Architecture" />
</Frame>

<Frame type="simple">
  <img alt="Sender Wallet Model Architecture" />
</Frame>

<Info>
  Need a custom flow for your use case? Our team can help you design, build, and optimize it end-to-end. [Reach out to set up a personalized consultation](https://www.crossmint.com/contact/sales).
</Info>

## Solution Components

Crossmint's platform provides all the building blocks needed to implement any of the architectures above via simple APIs. Key solution components include:

<CardGroup>
  <Card title="Treasury wallets" icon="vault" href="/stablecoin-orchestration/treasury-wallet/overview">
    Create treasury wallets to manage your own funds.
  </Card>

  <Card title="Embedded wallets" icon="wallet" href="/wallets/overview">
    Create wallets for your users: receivers and/or senders.
  </Card>

  <Card title="B2B Onramp" icon="building-columns" href="/stablecoin-orchestration/onramp/overview">
    Fund your treasury with stablecoins.
  </Card>

  <Card title="B2C Onramp" icon="credit-card" href="/stablecoin-orchestration/onramp/overview">
    Embed a widget on your app and allow users to fund their wallets.
  </Card>

  <Card title="Regulated payouts" icon="shield-check" href="/stablecoin-orchestration/regulated-transfers/overview">
    Send stablecoins to third-parties using Crossmint's licenses, with built-in AML, sanctions and travel rule checks.
  </Card>

  <Card title="Offramp" icon="money-bill-wave" href="https://www.crossmint.com/contact/sales">
    Convert stablecoins to local currency and deliver to bank accounts, mobile wallets, or local payment rails across key remittance corridors.
  </Card>
</CardGroup>

## Get Started

<CardGroup>
  <Card title="Contact Sales" icon="phone" href="https://www.crossmint.com/contact/sales">
    Contact our sales team to request a consultation to help you design and integrate.
  </Card>
</CardGroup>


# Stablecoin Payouts
Source: https://docs.crossmint.com/solutions/fintech/stablecoin-payouts

Instant, low-cost global payments with stablecoins

## Overview

Enable your platform to send instant payments globally using stablecoins. Convert fiat to stablecoins and distribute
funds to recipients worldwide with minimal fees, instant settlement, and 24/7 availability - eliminating the limitations
of traditional banking systems.

This solution is ideal for:

<AccordionGroup>
  <Accordion title="Marketplace Platforms">
    Pay sellers, creators, and service providers globally with instant settlements. Enable cross-border payments without the delays and high fees of traditional payment rails.
  </Accordion>

  <Accordion title="Gig Economy Apps">
    Provide instant earnings access to drivers, shoppers, and freelancers. Pay out in real-time regardless of banking hours or geographic location.
  </Accordion>

  <Accordion title="Aid disbursement">
    Low cost, global aid disbursement in stablecoins
  </Accordion>
</AccordionGroup>

## Common Architectures

1. **Fiat-to-Stablecoin Payouts**: Accept fiat deposits, convert to stablecoins, and send to recipients' wallets
2. **Direct Stablecoin Distribution**: Hold treasury in stablecoins and distribute directly to recipients

<Info>
  Need a custom flow for your use case? Our team can help you design, build, and optimize it end-to-end. [Reach out to get started](https://www.crossmint.com/contact/sales).
</Info>

## How It Works

1. **Compliance**: Use Crossmint's licenses or bring your own
2. **Wallets**: Use Crossmint's wallets, which can be configured in both custodial, or non-custodial modes
3. **Onramp**: Optionally, have the user initiate the transaction with credit card or bank transfer
4. **Stablecoin Transfer**: Instant transfers, without needing to deal with gas fees, retries, sanctions checks
5. **Receive Funds**: Receive the money in stablecoin, bank account, or local payment methods

All stablecoins are supported, in over 50 supported [chains](/introduction/supported-chains).

## Integration Steps

*Integration guide coming soon. [Contact our sales team](https://www.crossmint.com/contact/sales) to request a consultation to help you design and integrate.*


# Example Workflows
Source: https://docs.crossmint.com/solutions/n8n/example-workflows

Ready-to-use workflow templates to get you started

These ready-to-use examples live in the `workflows-examples/` folder of the [GitHub repository](https://github.com/crossmint/n8n-nodes-crossmint).

## Buy Celsius

**File**: `buy-celsius.json`

This workflow demonstrates the complete wallet lifecycle and checkout process:

* Create or retrieve a wallet
* Get wallet details
* Check wallet balance
* Create and pay for an order

<img alt="Crossmint nodes examples" />

<Card title="Download workflow" icon="download" href="https://github.com/crossmint/n8n-nodes-crossmint/blob/main/workflows-examples/buy-celsius.json">
  Import this workflow into your n8n instance
</Card>

## Buy Any Item from Amazon or Shopify Using Natural Language

**File**: `buy-items-amazon.json`

An advanced workflow that combines AI and automation:

1. Receives product requests in natural language
2. Uses OpenAI to parse and extract product details
3. Automatically purchases items from Amazon using stablecoins

<img alt="Buy items from Amazon workflow" />

<Card title="Download workflow" icon="download" href="https://github.com/crossmint/n8n-nodes-crossmint/blob/main/workflows-examples/buy-items-amazon.json">
  Import this workflow into your n8n instance
</Card>

## How to Use These Workflows

<Steps>
  <Step title="Download the workflow JSON">
    Click the download link for the workflow you want to use
  </Step>

  <Step title="Import into n8n">
    In n8n, go to **Create Workflow**, in the top right select the **options menu** (three dots), hit **Import from File** and select the JSON file
  </Step>

  <Step title="Configure credentials">
    Set up your Crossmint API credentials in the workflow nodes
  </Step>

  <Step title="Update personal data">
    Replace placeholder values with your own:

    * Email addresses
    * Wallet addresses
    * Admin signer private keys
    * Product URLs or IDs
    * Delivery address
  </Step>

  <Step title="Test in Staging">
    Run the workflow in Staging environment first to verify everything works
  </Step>

  <Step title="Execute">
    Run the workflow and monitor the results
  </Step>
</Steps>

## Need More Help?

<CardGroup>
  <Card title="Ask the Expert GPT" icon="robot" href="https://chatgpt.com/g/g-68d13ccc81ac8191a0c3716ce980faff-n8n-crossmint-expert">
    Get AI-powered guidance on building workflows
  </Card>

  <Card title="Wallets Node" icon="wallet" href="/solutions/n8n/nodes/wallets">
    Learn about all wallet operations and features
  </Card>

  <Card title="Checkout Node" icon="credit-card" href="/solutions/n8n/nodes/checkout">
    Automate purchases from Amazon and Shopify
  </Card>

  <Card title="View All Examples" icon="github" href="https://github.com/crossmint/n8n-nodes-crossmint/tree/main/workflows-examples">
    Browse all workflow examples on GitHub
  </Card>
</CardGroup>


# Checkout Node
Source: https://docs.crossmint.com/solutions/n8n/nodes/checkout

Automate purchases from Amazon and Shopify using digital money

The Crossmint Checkout node enables you to automate purchasing physical products using digital money like USDC. This is a two-step process: first create an order, then pay for it.

## Operations

### Create Order

Creates a purchase order for a product from Amazon or Shopify.

**Parameters:**

* **Platform** — `amazon` or `shopify`
* **Product Identifier** — Product URL or ASIN/ID (e.g., Amazon URL or `B01DFSADS2`)
* **Recipient Email** — For order confirmation
* **Recipient Name** — Full name for shipping
* **Address Line 1/2** — Street address
* **City** — City name
* **State** — State/province (optional)
* **Postal Code** — ZIP/postal code
* **Country** — Country code
* **Environment** — Staging or Production
* **Payment Method** — Blockchain network (e.g., `solana`)
* **Payment Currency** — Token to use (e.g., `usdc`)
* **Payer Address** — Wallet address that will pay for the order

**Response:**

The response includes a `serializedTransaction` that you'll need for the next step.

### Pay Order

Completes the payment for a previously created order using a wallet's private key.

**Parameters:**

* **Serialized Transaction** — From the Create Order response
* **Payment Chain** — Network for payment (e.g., `solana`)
* **Payer Wallet Address** — Address of the paying wallet
* **Private Key** — Private key to authorize the payment

**Response:**

Returns the payment status and transaction details.

## Complete Workflow Example

Here's a typical workflow for purchasing an item:

<Steps>
  <Step title="Create Order">
    Use the **Create Order** operation with:

    * Product URL or ID
    * Shipping details
    * Payment method and payer wallet
  </Step>

  <Step title="Extract Transaction">
    From the Create Order response, extract the `serializedTransaction` field
  </Step>

  <Step title="Pay Order">
    Use the **Pay Order** operation with:

    * The serialized transaction
    * The payer wallet's private key
    * Payment chain information
  </Step>

  <Step title="Verify Completion">
    Check the response to confirm the payment was successful
  </Step>
</Steps>

## Supported Platforms

### Amazon

Purchase any product available on Amazon using cryptocurrency.

**Product Identifier Formats:**

* Full Amazon URL: `https://www.amazon.com/dp/B08N5WRWNW`
* ASIN only: `B08N5WRWNW`

### Shopify

Purchase products from Shopify-powered stores.

**Product Identifier Formats:**

* Product URL from the Shopify store

## Payment Methods

Currently supported:

* **Solana** — Pay with USDC or other SPL tokens on Solana

## Testing

<Callout type="info">
  Always test your checkout workflows in the **Staging** environment before moving to production. Use test USDC from the [Circle Faucet](https://faucet.circle.com/).
</Callout>

## Security Considerations

<Callout type="warning">
  <b>Private Key Security</b>

  The Pay Order operation requires a private key to sign transactions. Follow these security practices:

  1. Store private keys in n8n environment variables, never hardcode them
  2. Use different keys for staging vs production
  3. Only use keys with the minimum required balance
  4. Monitor wallet activity regularly
  5. Never share private keys or expose them in logs
</Callout>

## Example Use Cases

* **AI Shopping Assistants** — Build chatbots that can purchase items on behalf of users
* **Automated Reordering** — Set up workflows that automatically reorder supplies when inventory is low
* **Reward Systems** — Create systems that automatically purchase and ship rewards to users
* **Subscription Boxes** — Automate recurring purchases and deliveries

## Next Steps

<CardGroup>
  <Card title="Wallets Node" icon="wallet" href="/solutions/n8n/nodes/wallets">
    Learn about managing wallets for payments
  </Card>

  <Card title="Example Workflows" icon="diagram-project" href="/solutions/n8n/example-workflows">
    See the Checkout node in action with complete examples
  </Card>

  <Card title="Source Code" icon="github" href="https://github.com/crossmint/n8n-nodes-crossmint">
    Browse source code
  </Card>

  <Card title="Ask ChatGPT" icon="comments" href="https://chatgpt.com/g/g-68d13ccc81ac8191a0c3716ce980faff-n8n-crossmint-expert">
    Ask Crossmint Expert GPT for n8n guidance
  </Card>
</CardGroup>


# Wallets Node
Source: https://docs.crossmint.com/solutions/n8n/nodes/wallets

Manage blockchain wallets, balances, and token transfers

The Crossmint Wallets node provides operations for managing blockchain wallets that can hold and transfer digital money like USDC.

## Operations

### Get or Create Wallet

Creates a non-custodial smart wallet or retrieves an existing one. You control it via a private key that authorizes all transactions. This operation is idempotent.

**Parameters:**

* **Chain Type** — Blockchain type (`solana`)
* **Owner Type** — Optional owner identifier type (`email`, `userId`, `phone`, `twitter`, `x`, `none`)
* **Owner Details** — Specific owner information based on the selected type
* **Admin Signer** — Private key that authorizes all transactions from this wallet (see [Admin Signer Private Key](#admin-signer-private-key) below)

### Get Wallet

Retrieves wallet details using its locator (address, email, user ID, etc.).

**Parameters:**

* **Wallet** — Wallet identifier (`address`, `email`, `userId`, `phone`, `twitter`, `x`)
* **Chain Type** — Required for non-address locators (`solana`)

### Create Transfer

Sends tokens (like USDC) between wallets. Requires the wallet's private key to sign and authorize.

**Parameters:**

* **Blockchain Type** — `solana`
* **Origin Wallet** — Source wallet
* **Recipient Wallet** — Destination wallet
* **Token Chain** — Specific network (`solana`)
* **Token Name** — Token symbol/identifier (e.g., `usdc`)
* **Amount** — Token amount

### Get Balance

Checks token balances for a wallet across one or more networks.

**Parameters:**

* **Wallet** — Locator (`address`, `email`, `userId`, `phone`, `twitter`, `x`)
* **Chain Type** — Required for non-address locators (`solana`)
* **Chains** — e.g., `solana`
* **Tokens** — Comma-separated list of token symbols

### Sign Transaction

Signs a transaction with a private key and submits the signature to complete pending transactions.

**Parameters:**

* **Chain** — Network for signing
* **Wallet Address** — From the Create Transfer response
* **Transaction ID** — ID that needs approval
* **Transaction Data** — Hash/message to sign from transfer response
* **Signer Address** — Address of the external signer
* **Signer Private Key** — Private key to sign the transaction
* **Wait for Completion** — Poll until final status

## Wallet Locators

Wallet locators provide a flexible way to identify wallets with different identifiers.

### Locator Types

| Type               | Format                                  | Example                                        | Use Case                            |
| ------------------ | --------------------------------------- | ---------------------------------------------- | ----------------------------------- |
| **Wallet Address** | Solana address                          | `7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU` | Direct blockchain address reference |
| **Email**          | `email:{email}:{chainType}:smart`       | `email:user@example.com:solana:smart`          | User identification by email        |
| **User ID**        | `userId:{id}:{chainType}:smart`         | `userId:user-123:solana:smart`                 | Custom user identifier              |
| **Phone Number**   | `phoneNumber:{phone}:{chainType}:smart` | `phoneNumber:+1234567890:solana:smart`         | SMS-based identification            |
| **Twitter Handle** | `twitter:{handle}:{chainType}:smart`    | `twitter:username:solana:smart`                | Social media identification         |
| **X Handle**       | `x:{handle}:{chainType}:smart`          | `x:username:solana:smart`                      | X (formerly Twitter) identification |

For more details, see <a href="https://docs.crossmint.com/api-reference/wallets/get-wallet-by-locator">Wallet Locators</a>.

### Chain Types

* **Solana** — Solana blockchain

## Admin Signer Private Key

The **Admin Signer Private Key** is a critical security component that gives you full control over your Crossmint wallet.

### What is an Admin Signer?

The Admin Signer is the private key that acts as the "master key" for your smart wallet. It's used to:

* Authorize all transactions
* Sign transfer approvals
* Control wallet permissions and operations

### Key Requirements

**Solana**

* Base58 encoded string
* Typically 64 bytes when decoded
* Example: `5Kb8kLf9CJtPkDCe4jfE9TjC8d7X9e3Jh4F6h8F2K3h7J9F4K6h8F2K3h7J9F4K6h`

### Generating Private Keys

**Online Tools**

* **Crossmint Generator**: <a href="https://crypto-address-generator.val.run/">[https://crypto-address-generator.val.run/](https://crypto-address-generator.val.run/)</a>

**Local/Terminal (recommended for production)**

1. Install Solana CLI — <a href="https://solana.com/docs/intro/installation">Installation guide</a>
2. Generate a keypair:

```bash theme={null}
solana-keygen new --outfile ~/my-wallet.json --no-bip39-passphrase
cat ~/my-wallet.json
```

**Hardware Wallets**

* Export/derive keys securely from Ledger or other hardware wallets

<Callout type="warning">
  <b>Security best practices</b>

  <ol>
    <li>Never share your private key</li>
    <li>Store in environment variables or secure vaults</li>
    <li>Use different keys for staging vs production</li>
    <li>Back up securely (multiple locations)</li>
    <li>Test with small amounts on testnet first</li>
    <li>Rotate keys periodically</li>
  </ol>
</Callout>

### How It Works in Crossmint

1. **Wallet Creation** — Your private key becomes the admin signer for the smart wallet
2. **Transaction Flow** — Create transaction → Crossmint generates approval → Sign with private key → Submit signature
3. **Non-Custodial** — You control the key and the wallet

## Get Test USDC

For testing in the Staging environment, you can get free test USDC:

* **Circle Faucet**: <a href="https://faucet.circle.com/">[https://faucet.circle.com/](https://faucet.circle.com/)</a>

## Next Steps

<CardGroup>
  <Card title="Checkout Node" icon="credit-card" href="/solutions/n8n/nodes/checkout">
    Learn about the Checkout node for automated purchases
  </Card>

  <Card title="Example Workflows" icon="diagram-project" href="/solutions/n8n/example-workflows">
    See the Wallets node in action
  </Card>

  <Card title="Source Code" icon="github" href="https://github.com/crossmint/n8n-nodes-crossmint">
    Browse source code
  </Card>

  <Card title="Ask ChatGPT" icon="comments" href="https://chatgpt.com/g/g-68d13ccc81ac8191a0c3716ce980faff-n8n-crossmint-expert">
    Ask Crossmint Expert GPT for n8n guidance
  </Card>
</CardGroup>


# Overview
Source: https://docs.crossmint.com/solutions/n8n/overview

Full-featured n8n integration for Crossmint Wallet and Checkout APIs

## What is n8n?

n8n is an open-source workflow automation tool that lets you connect different apps and services together via n8n nodes. Think of it as a way to automate tasks between different tools without writing code.

<img alt="n8n automated workflow example" />

<figcaption>Example n8n workflow demonstrating automated Amazon purchases powered by LLMs</figcaption>

## Available Crossmint Nodes in N8N

Crossmint n8n community package provides two powerful nodes:

* **Crossmint Wallets** — Manage blockchain wallets, check balances, and transfer tokens
* **Crossmint Checkout** — Automate purchases of physical products from Amazon and Shopify using digital money

## Example Use Cases

* **Payroll System** — Automate payments to employees and contractors worldwide
* **Agentic Payments** — Allow agents to purchase items on Amazon and Shopify
* **Automated Tipping** — Tip users on X (Twitter) automatically

## Learn more

<CardGroup>
  <Card title="Quickstart" icon="bolt" href="/solutions/n8n/quickstart">
    Build your first workflow in under 5 minutes
  </Card>

  <Card title="Ask ChatGPT" icon="comments" href="https://chatgpt.com/g/g-68d13ccc81ac8191a0c3716ce980faff-n8n-crossmint-expert">
    Ask Crossmint Expert GPT for n8n guidance
  </Card>
</CardGroup>


# Quickstart ⚡
Source: https://docs.crossmint.com/solutions/n8n/quickstart

Build your first workflow in under 5 minutes

In this quickstart you will create a simple workflow that creates a wallet and fetches its balance.

## Installation

<Steps>
  <Step title="Create an n8n account">
    Register with n8n <a href="https://app.n8n.cloud/register">here</a>, otherwise <a href="https://app.n8n.cloud/login">login</a> to your existing account.
  </Step>

  <Step title="Create a new workflow">
    On the top right of your n8n dashboard, click the **Create workflow** button.
  </Step>

  <Step title="Install Crossmint Node">
    In the middle of the screen, click <b>Add first step</b>. In the search bar, type <b>Crossmint</b> to find the Crossmint nodes.<br /><br />
    For both <b>Crossmint Wallets</b> and <b>Crossmint Checkout</b> nodes, you need to click the <b>Install Node</b> button to add them to your workspace.
  </Step>
</Steps>

You now have access to two nodes: **Crossmint Wallets** and **Crossmint Checkout**. You can close the Settings page and get ready to build your first workflow.

## Get Started

<Steps>
  <Step title="Create a wallet node">
    <ol>
      <li>Click the <b>+</b> button on the top left of your screen to start a new workflow.</li>
      <li>Click the <b>+</b> button in the middle of your screen to add a new node.</li>

      <li>
        <p>Search for <b>Crossmint</b> and you will see:</p>

        <ul>
          <li><b>Crossmint Wallets</b></li>
          <li><b>Crossmint Checkout</b></li>
        </ul>
      </li>

      <img alt="Crossmint node search" />

      <li>For this example, choose the <b>Get or Create Wallet</b> operation.</li>
    </ol>

    <img alt="Crossmint node search" />
  </Step>

  <Step title="Obtain a Crossmint credential">
    <ol>
      <li>Create an account on <a href="https://staging.crossmint.com/console/overview">Crossmint Console</a>.</li>
      <li>Copy your <b>server-side API key</b> from the project settings.</li>
    </ol>

    <img alt="Crossmint staging console" />

    <ol>
      <li>Back in n8n, in the Crossmint Wallets node, open <b>Credential to connect with</b> and choose <b>Create New</b>.</li>
      <li>Enter your Crossmint <b>API Key</b> and hit Save.</li>
    </ol>

    <img alt="Crossmint API credential form" />

    <Note>
      To test this flow in production, obtain a Crossmint API key from the <a href="https://www.crossmint.com/console/overview">Crossmint Console</a>.
    </Note>
  </Step>

  <Step title="Configure the wallet">
    Specify the wallet's required parameters:

    * **Owner Type**: Select `Email`
    * **Owner Details**: Enter an email address you control
    * **Admin Signer**: Set this to a private key you can generate from <a href="/solutions/n8n/nodes/wallets#generating-private-keys">here</a>.

    <img alt="Crossmint node configuration" />
  </Step>

  <Step title="Execute the workflow">
    Click **Execute Node** to run the workflow. You should see a successful response with your wallet details.
  </Step>

  <Step title="Fund the wallet">
    Use Circle's USDC <a href="https://faucet.circle.com/">faucet</a> to fund the wallet
  </Step>

  <Step title="Add node to get the wallet's balance">
    <ol>
      <li>Add another Crossmint Wallets node to your workflow</li>
      <li>Select the <b>Get Balance</b> operation</li>
      <li>Configure it to use the wallet address returned from the previous step</li>
    </ol>
  </Step>

  <Step title="Execute workflow">
    Execute the final workflow to see your wallet's USDC balance.
  </Step>
</Steps>

## Next Steps

Congratulations! You've created your first Crossmint workflow in n8n. Here's what you can explore next:

<CardGroup>
  <Card title="Example Workflows" icon="diagram-project" href="/solutions/n8n/example-workflows">
    Try ready-to-use workflow templates
  </Card>

  <Card title="Ask ChatGPT" icon="comments" href="https://chatgpt.com/g/g-68d13ccc81ac8191a0c3716ce980faff-n8n-crossmint-expert">
    Ask Crossmint Expert GPT for n8n guidance
  </Card>
</CardGroup>


# Overview
Source: https://docs.crossmint.com/solutions/overview

Browse guides tailored to your business vertical or use case

## Fintech

<CardGroup>
  <Card title="Remittances" icon="earth-americas" href="/solutions/fintech/remittances">
    Enable fast, low-cost international money transfers with stablecoins
  </Card>

  <Card title="Stablecoin Payouts" icon="coins" href="/solutions/fintech/stablecoin-payouts">
    Instant, low-cost global payments for marketplaces and platforms
  </Card>

  <Card title="Global Payroll" icon="money-check-dollar" href="/solutions/fintech/global-payroll">
    Pay employees and contractors worldwide instantly with stablecoins
  </Card>

  <Card title="Neobanks" icon="building" href="/solutions/fintech/neobanks">
    Create stablecoin backed banking-like products, with deposits, cards, and more
  </Card>
</CardGroup>

## Agents and Automation

<CardGroup>
  <Card title="Agentic Commerce" icon="robot" href="/solutions/ai-agents/introduction">
    Enable AI agents to purchase physical goods programmatically
  </Card>

  <Card title="n8n" icon="diagram-project" href="/solutions/n8n/overview">
    Create workflows to automate payments, money movement, and purchasing
  </Card>
</CardGroup>

## IP Tokenization

<CardGroup>
  <Card title="StoryKit" icon="play" href="/solutions/story-protocol/introduction">
    Transform intellectual property into programmable digital assets
  </Card>
</CardGroup>


# Images Quickstart ⚡
Source: https://docs.crossmint.com/solutions/story-protocol/images-quickstart

Register your designs on Story in under 5 minutes

In this quickstart, you will:

* Register a design portfolio as an IP collection
* Register a image design as an IP asset

<Note> This quickstart is under development as new features are added to the Story Protocol daily. </Note>

## Preparation Steps

<Steps>
  <Step title="Create a Developer Account and Project">
    <Snippet />
  </Step>

  <Step title="Get an API Key">
    Create a server-side API key with these scopes:
    `collection.create`,
    `collection.update`,
    `collection.read`,
    `nfts.create`,
    `nfts.read`.

    This allows your API key to perform any kind of asset registration action.
  </Step>
</Steps>

## Register Design Portfolio

<Steps>
  <Step title="Create an IP Collection">
    <CodeGroup>
      ```typescript createCollection.ts theme={null}
      const response = await fetch("https://staging.crossmint.com/api/v1/ip/collections", {
          method: "POST",
          headers: {
              "X-API-KEY": "<YOUR_API_KEY>",
              "Content-Type": "application/json"
          },
          body: JSON.stringify({
              metadata: {
                  description: "My image design portfolio",
                  name: "My Image Design Portfolio",
                  symbol: "MIDP"
              },
              chain: "story-testnet"
          })
      });

      const collection = await response.json();
      console.log("Collection created:", collection);
      ```

      ```typescript response theme={null}
      {
          id: '1ffb0fc3-b652-4a0e-b748-3e09c3608826',
          actionId: '1ffb0fc3-b652-4a0e-b748-3e09c3608826',
          metadata: {
              name: 'My Image Design Portfolio',
              symbol: 'MIDP',
              description: 'My image design portfolio'
          },
          onChain: { chain: 'story-testnet' }
      }
      ```
    </CodeGroup>

    Additional metadata can be added to the collection to help with discovery, such as a cover image. Check out the [API reference](/api-reference/ip/create-ip-collection) for more information.

    To create the portfolio, run the script:

    <CodeGroup>
      ```bash TypeScript theme={null}
      npx tsx createCollection.ts
      ```
    </CodeGroup>
  </Step>
</Steps>

## Register Image Design

<Steps>
  <Step title="Create a Design">
    Use OpenAI's DALL-E 3 to create a design:

    <CodeGroup>
      ```typescript createDesign.ts theme={null}
      import OpenAI from 'openai'

      async function main() {
      const openai = new OpenAI({
          apiKey: "<YOUR_OPENAI_API_KEY>"
      })

      const image = await openai.images.generate({
          model: 'dall-e-2',
          prompt: 'A futuristic bridge connecting two digital worlds, with a sleek mint-colored pathway'
      });

      console.log(image.data[0].url) // the url to the newly created image
      }

      main();
      ```
    </CodeGroup>

    The resulting image looks like this:

    <img alt="Create Design" />
  </Step>

  <Step title="Register Image Design on Story">
    <CodeGroup>
      ```typescript registerIPAsset.ts theme={null}
      const response = await fetch("https://staging.crossmint.com/api/v1/ip/collections/{collectionId}/ipassets", {
          method: "POST",
          headers: {
              "X-API-KEY": "<YOUR_API_KEY>",
              "Content-Type": "application/json"
          },
          body: JSON.stringify({
              owner: 'email:creator@example.com:story-testnet',
              nftMetadata: {
                  name: 'My Image Design',
                  description: 'An image designed to represent a futuristic bridge connecting two digital worlds, with a sleek mint-colored pathway',
                  image: '<YOUR_IMAGE_URL>'
              },
              ipAssetMetadata: {
                  title: 'My Image Design',
                  createdAt: '2025-02-11T11:13:00',
                  ipType: 'image',
                  creators: [
                      {
                          name: 'John Doe',
                          email: 'user@example.com',
                          crossmintUserLocator: 'email:user@example.com:story-testnet',
                          contributionPercent: 100
                      },
                  ],
                  attributes: [
                      {
                          key: 'Model',
                          value: 'dall-e-2'
                      },
                      {
                          key: 'Prompt',
                          value: 'A futuristic bridge connecting two digital worlds, with a sleek mint-colored pathway'
                      },
                  ]
              }
          })
      });

      const ipAsset = await response.json();
      console.log("IP Asset:", ipAsset);
      ```

      ```typescript response theme={null}
      {
          "id": "d290f1ee-6c54-4b01-90e6-d701748f0851",
          "actionId": "d290f1ee-6c54-4b01-90e6-d701748f0851",
          "nftMetadata": {
              "name": "My Image Design",
              "description": "An image designed to represent a futuristic bridge connecting two digital worlds, with a sleek mint-colored pathway",
              "image": "<YOUR_IMAGE_URL>"
          },
          "ipAssetMetadata": {
              "title": "My Image Design",
              "createdAt": "2025-02-11T11:13:00",
              "ipType": "image",
              "creators": [
                  {
                      "name": "John Doe",
                      "email": "email:user@example.com",
                      "contributionPercent": 100
                  }
              ],
              "attributes": [
                  {
                      "key": "Model",
                      "value": "dall-e-2"
                  },
                  {
                      "key": "Prompt",
                      "value": "A futuristic bridge connecting two digital worlds, with a sleek mint-colored pathway"
                  }
              ]
          },
          "onChain": {
              "status": "success",
              "chain": "story-testnet",
              "contractAddress": "0x123",
              "ipAssetId": "0xAC6062FF53fa41e61Fe01B89B83d9dB96b5F9280",
              "tokenId": "1",
              "txId": "0x123",
              "explorerLink": "https://explorer.story.foundation/ipa/0xAC6062FF53fa41e61Fe01B89B83d9dB96b5F9280"
          }
      }
      ```
    </CodeGroup>

    Run the script to register the song:

    <CodeGroup>
      ```bash TypeScript theme={null}
      npx tsx registerIPAsset.ts
      ```
    </CodeGroup>
  </Step>
</Steps>

## Retrieve Your IP Asset

<Steps>
  <Step title="Get IP Asset Details">
    After registering your IP asset, you can retrieve its details to verify the information or display it in your application.

    <CodeGroup>
      ```typescript getIPAsset.ts theme={null}
      const response = await fetch("https://staging.crossmint.com/api/v1/ip/collections/{collectionId}/ipassets/{ipAssetId}", {
          method: "GET",
          headers: {
              "X-API-KEY": "<YOUR_API_KEY>",
              "Content-Type": "application/json"
          }
      });

      const ipAsset = await response.json();
      console.log("IP Asset:", ipAsset);
      ```

      ```typescript response theme={null}
      {
          "id": "d290f1ee-6c54-4b01-90e6-d701748f0851",
          "nftMetadata": {
              "name": "My Image Design",
              "description": "An image designed to represent a futuristic bridge connecting two digital worlds, with a sleek mint-colored pathway",
              "image": "<YOUR_IMAGE_URL>"
          },
          "ipAssetMetadata": {
              "title": "My Image Design",
              "createdAt": "2025-02-11T11:13:00",
              "ipType": "image",
              "creators": [
                  {
                      "name": "John Doe",
                      "email": "email:user@example.com",
                      "contributionPercent": 100
                  }
              ],
              "attributes": [
                  {
                      "key": "Model",
                      "value": "dall-e-2"
                  },
                  {
                      "key": "Prompt",
                      "value": "A futuristic bridge connecting two digital worlds, with a sleek mint-colored pathway"
                  }
              ]
          },
          "onChain": {
              "status": "success",
              "chain": "story-testnet",
              "contractAddress": "0x123",
              "ipAssetId": "d290f1ee-6c54-4b01-90e6-d701748f0851",
              "tokenId": "1",
              "txId": "0x123",
              "explorerLink": "https://explorer.story.foundation/ipa/0xAC6062FF53fa41e61Fe01B89B83d9dB96b5F9280"
          }
      }
      ```
    </CodeGroup>

    Replace `{collectionId}` with your collection ID and `{ipAssetId}` with the IP asset ID returned when you registered the asset. Then run the script:

    <CodeGroup>
      ```bash TypeScript theme={null}
      npx tsx getIPAsset.ts
      ```
    </CodeGroup>
  </Step>
</Steps>

## Confirm Image Registration

<Steps>
  <Step title="Get Action Status">
    You can easily check the IP asset registration status to ensure the action has completed before proceeding.

    <CodeGroup>
      ```typescript getAction.ts theme={null}
      const response = await fetch("https://staging.crossmint.com/api/v1/ip/actions/{actionId}", {
          method: "GET",
          headers: {
              "X-API-KEY": "<YOUR_API_KEY>",
              "Content-Type": "application/json"
          }
      });

      const action = await response.json();
      console.log("Action:", action);
      ```

      ```typescript response theme={null}
      {
          id: '1ffb0fc3-b652-4a0e-b748-3e09c3608826',
          status: 'success'
      }
      ```
    </CodeGroup>

    Use the action ID returned in any of the previous steps and run the script:

    <CodeGroup>
      ```bash TypeScript theme={null}
      npx tsx getAction.ts
      ```
    </CodeGroup>
  </Step>
</Steps>


# Overview
Source: https://docs.crossmint.com/solutions/story-protocol/introduction

Create, manage, and monetize IP assets on Story Protocol using Crossmint

<Frame type="simple">
  <img alt="Story Protocol" />
</Frame>

Story Protocol is a decentralized platform that helps creators protect and monetize their intellectual property (IP) through blockchain technology. Crossmint simplifies the process of building applications on top of Story Protocol. With Crossmint's StoryKit, you can:

* Let content creators easily register their IP without dealing with blockchain complexities such as gas fees, key management, and smart contract interactions
* Help storytellers and artists tokenize their creative works (like stories, characters, or artwork) through simple API calls
* Enable creators to sell licenses and rights to their IP directly to fans and businesses, accepting both fiat and crypto payments

## Key Characteristics

<CardGroup>
  <Card title="User Auth & Wallets" icon="wallet">
    Authenticate users and create wallets for them using web3 or traditional sign-in methods
  </Card>

  <Card icon="palette" title="IP Assets">
    Create and manage IP assets using RESTful APIs
  </Card>

  <Card icon="credit-card" title="Payments">
    Monetize your IP by accepting fiat or crypto for it
  </Card>
</CardGroup>

## How Does it Work?

Crossmint's infrastructure lets developers easily plug into Story Protocol's core IP framework without dealing with blockchain complexities around user authentication and wallet creation, gas fees and minting of assets at scale, as well as payments.

#### User Authentication & Wallets

* Out of the box support for user authentication and wallet management

  <Frame type="simple">
    <img alt="GIF of user login flow" />
  </Frame>

#### Create & Manage Assets

* Support for Story Protocol Groups (SPG) collection creation
* Support for minting, registration, and licensing of IP assets
* Support for co-creator specification and collaborative ownership
* Secure metadata storage using IPFS
* Support for modifying asset license terms and co-creators
* Ensure that only verified owners can update or delete data

#### Transfer Assets & Collect Royalties

* Support for NFT transfers
* Built-in royalty collection for commercially licensed assets

### Monetize your IP

* Accept fiat or crypto payments using Crossmint's Checkout API

## What can I build with this?

* Create and license stories and characters for use in games, NFT collections, or other applications
* Register original beats, melodies, or vocals and license them to other artists with automated royalty distribution
* License 3D clothing elements, textures, or patterns for use across virtual worlds and games

## Get Started

<CardGroup>
  <Card title="Wallets Quickstart" icon="wallet" href="/solutions/story-protocol/wallets/server-side-wallets">
    Create user wallets on Story
  </Card>

  <Card title="Music Quickstart" icon="wallet" href="/solutions/story-protocol/music-quickstart">
    Register your music on Story
  </Card>

  <Card title="Literature Quickstart" icon="wallet" href="/solutions/story-protocol/literature-quickstart">
    Register your literature works on Story
  </Card>

  <Card title="Images Quickstart" icon="wallet" href="/solutions/story-protocol/images-quickstart">
    Register your designs on Story
  </Card>

  <Card title="API Reference" icon="wallet" href="/api-reference/ip/create-ip-collection">
    Review API routes for building on Story
  </Card>
</CardGroup>


# Literature Quickstart ⚡
Source: https://docs.crossmint.com/solutions/story-protocol/literature-quickstart

Register your literature works on Story in under 5 minutes

In this quickstart, you will:

* Register a book series as an IP collection
* Register a book as an IP asset

<Note> This quickstart is under development as new features are added to the Story Protocol daily. </Note>

## Preparation Steps

<Steps>
  <Step title="Create a Developer Account and Project">
    <Snippet />
  </Step>

  <Step title="Get an API Key">
    Create a server-side API key with these scopes:
    `collection.create`,
    `collection.update`,
    `collection.read`,
    `nfts.create`,
    `nfts.read`.

    This allows your API key to perform any kind of asset registration action.
  </Step>
</Steps>

## Register a Book Series

<Steps>
  <Step title="Create an IP Collection">
    This quickstart will register the Harry Potter book series as an IP collection.

    <CodeGroup>
      ```typescript createCollection.ts theme={null}
      const response = await fetch("https://staging.crossmint.com/api/v1/ip/collections", {
          method: "POST",
          headers: {
              "X-API-KEY": "<YOUR_API_KEY>",
              "Content-Type": "application/json"
          },
          body: JSON.stringify({
              metadata: {
                  description: "The collection of Harry Potter books",
                  name: "Harry Potter Series",
                  symbol: "HP"
              },
              chain: "story-testnet"
          })
      });

      const collection = await response.json();
      console.log("Collection created:", collection);
      ```

      ```typescript response theme={null}
      {
          id: '1ffb0fc3-b652-4a0e-b748-3e09c3608826',
          actionId: '1ffb0fc3-b652-4a0e-b748-3e09c3608826',
          metadata: {
              name: 'Harry Potter Series',
              symbol: 'HP',
              description: 'The collection of Harry Potter books'
          },
          onChain: { chain: 'story-testnet' }
      }
      ```
    </CodeGroup>

    Customize the collection's metadata according to your needs and run the script:

    <CodeGroup>
      ```bash TypeScript theme={null}
      npx tsx createCollection.ts
      ```
    </CodeGroup>
  </Step>
</Steps>

## Register a Book

<Steps>
  <Step title="Register an IP Asset">
    Every written work may have different contributors and metadata. When defining an IP asset you can:

    * Specify multiple contributors (like authors, illustrators, and publishers) with their respective revenue shares
    * Attach relevant media files
    * Include important metadata like creation dates and identifiers

    <CodeGroup>
      ```typescript registerIPAsset.ts theme={null}
      const response = await fetch("https://staging.crossmint.com/api/v1/ip/collections/{collectionId}/ipassets", {
          method: "POST",
          headers: {
              "X-API-KEY": "<YOUR_API_KEY>",
              "Content-Type": "application/json"
          },
          body: JSON.stringify({
              owner: 'email:creator@example.com:story-testnet',
              nftMetadata: {
                  name: 'Art #123',
                  description: 'A unique story NFT',
                  image: 'https://example.com/nft/123.png'
              },
              ipAssetMetadata: {
                  title: 'Harry Potter and the Philosopher\'s Stone',
                  createdAt: '1997-06-26T00:00:00',
                  ipType: 'literature',
                  image: 'link_to_epub',
                  imageHash: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
                  mediaUrl: 'link_to_epub',
                  mediaHash: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
                  mediaType: 'application/epub+zip',
                  creators: [
                      {
                          name: 'JK Rowling',
                          email: 'JKRowling@example.com',
                          address: '0x123',
                          description: 'Author',
                          contributionPercent: 80,
                          socialMedia: [
                              {
                                  platform: 'Wikipedia',
                                  url: 'https://en.wikipedia.org/wiki/J._K._Rowling'
                              }
                          ]
                      },
                      {
                          name: 'Thomas Taylor',
                          email: 'ThomasTaylor@example.com',
                          crossmintUserLocator: 'email:ThomasTaylor@example.com:story-testnet',
                          description: 'Illustrator',
                          contributionPercent: 15
                      },
                      {
                          name: 'Bloomsbury Publishing',
                          email: 'BloomsburyPublishing@example.com',
                          address: '0x123',
                          description: 'Publisher',
                          contributionPercent: 5,
                          socialMedia: [
                              {
                                  platform: 'Website',
                                  url: 'https://www.bloomsbury.com/'
                              }
                          ]
                      }
                  ],
                  media: [
                      {
                          name: 'ePub',
                          url: 'link_to_epub',
                          mimeType: 'application/epub+zip'
                      },
                      {
                          name: 'Book Summary PDF',
                          url: 'link_to_book_summary_pdf',
                          mimeType: 'application/pdf'
                      }
                  ],
                  attributes: [
                      {
                          key: 'ISBN',
                          value: '978-0-7475-3269-0'
                      },
                      {
                          key: 'Genre',
                          value: 'Fantasy'
                      }
                  ]
              }
          })
      });

      const ipAsset = await response.json();
      console.log("IP Asset:", ipAsset);
      ```

      ```typescript response theme={null}
      {
          "id": "d290f1ee-6c54-4b01-90e6-d701748f0851",
          "actionId": "d290f1ee-6c54-4b01-90e6-d701748f0851",
          "nftMetadata": {
              "name": "Art #123",
              "description": "A unique story NFT",
              "image": "https://example.com/nft/123.png"
          },
          "ipAssetMetadata": {
              "title": "Harry Potter and the Philosopher's Stone",
              "createdAt": "1997-06-26T00:00:00",
              "ipType": "literature",
              "creators": [
              {
                  "name": "JK Rowling",
                  "email": "email:JKRowling@example.com",
                  "description": "Author",
                  "contributionPercent": 80,
                  "socialMedia": [
                  {
                      "platform": "Wikipedia",
                      "url": "https://en.wikipedia.org/wiki/J._K._Rowling"
                  }
                  ]
              },
              {
                  "name": "Thomas Taylor",
                  "email": "email:ThomasTaylor@example.com",
                  "description": "Illustrator",
                  "contributionPercent": 15
              },
              {
                  "name": "Bloomsbury Publishing",
                  "email": "email:BloomsburyPublishing@example.com",
                  "description": "Publisher",
                  "contributionPercent": 5,
                  "socialMedia": [
                  {
                      "platform": "Website",
                      "url": "https://www.bloomsbury.com/"
                  }
                  ]
              }
              ],
              "media": [
              {
                  "name": "ePub",
                  "url": "link_to_epub",
                  "mimeType": "application/epub+zip"
              },
              {
                  "name": "Book Summary PDF",
                  "url": "link_to_book_summary_pdf",
                  "mimeType": "application/pdf"
              }
              ],
              "attributes": [
              {
                  "key": "ISBN",
                  "value": "978-0-7475-3269-0"
              },
              {
                  "key": "Genre",
                  "value": "Fantasy"
              }
              ]
          },
          "onChain": {
              "status": "success",
              "chain": "story-testnet",
              "contractAddress": "0x123",
              "ipAssetId": "0xAC6062FF53fa41e61Fe01B89B83d9dB96b5F9280",
              "tokenId": "1",
              "txId": "0x123",
              "explorerLink": "https://explorer.story.foundation/ipa/0xAC6062FF53fa41e61Fe01B89B83d9dB96b5F9280"
          }
      }
      ```
    </CodeGroup>

    Now, run the script:

    <CodeGroup>
      ```bash TypeScript theme={null}
      npx tsx registerIPAsset.ts
      ```
    </CodeGroup>
  </Step>
</Steps>

## Retrieve Your IP Asset

<Steps>
  <Step title="Get IP Asset Details">
    After registering your IP asset, you can retrieve its details to verify the information or display it in your application.

    <CodeGroup>
      ```typescript getIPAsset.ts theme={null}
      const response = await fetch("https://staging.crossmint.com/api/v1/ip/collections/{collectionId}/ipassets/{ipAssetId}", {
          method: "GET",
          headers: {
              "X-API-KEY": "<YOUR_API_KEY>",
              "Content-Type": "application/json"
          }
      });

      const ipAsset = await response.json();
      console.log("IP Asset:", ipAsset);
      ```

      ```typescript response theme={null}
      {
          "id": "d290f1ee-6c54-4b01-90e6-d701748f0851",
          "nftMetadata": {
              "name": "Art #123",
              "description": "A unique story NFT",
              "image": "https://example.com/nft/123.png"
          },
          "ipAssetMetadata": {
              "title": "Harry Potter and the Philosopher's Stone",
              "createdAt": "1997-06-26T00:00:00",
              "ipType": "literature",
              "creators": [
                  {
                      "name": "JK Rowling",
                      "email": "email:JKRowling@example.com",
                      "description": "Author",
                      "contributionPercent": 80,
                      "socialMedia": [
                          {
                              "platform": "Wikipedia",
                              "url": "https://en.wikipedia.org/wiki/J._K._Rowling"
                          }
                      ]
                  },
                  {
                      "name": "Thomas Taylor",
                      "email": "email:ThomasTaylor@example.com",
                      "description": "Illustrator",
                      "contributionPercent": 15
                  },
                  {
                      "name": "Bloomsbury Publishing",
                      "email": "email:BloomsburyPublishing@example.com",
                      "description": "Publisher",
                      "contributionPercent": 5,
                      "socialMedia": [
                          {
                              "platform": "Website",
                              "url": "https://www.bloomsbury.com/"
                          }
                      ]
                  }
              ],
              "media": [
                  {
                      "name": "ePub",
                      "url": "link_to_epub",
                      "mimeType": "application/epub+zip"
                  },
                  {
                      "name": "Book Summary PDF",
                      "url": "link_to_book_summary_pdf",
                      "mimeType": "application/pdf"
                  }
              ],
              "attributes": [
                  {
                      "key": "ISBN",
                      "value": "978-0-7475-3269-0"
                  },
                  {
                      "key": "Genre",
                      "value": "Fantasy"
                  }
              ]
          },
          "onChain": {
              "status": "success",
              "chain": "story-testnet",
              "contractAddress": "0x123",
              "ipAssetId": "d290f1ee-6c54-4b01-90e6-d701748f0851",
              "tokenId": "1",
              "txId": "0x123",
              "explorerLink": "https://explorer.story.foundation/ipa/0xAC6062FF53fa41e61Fe01B89B83d9dB96b5F9280"
          }
      }
      ```
    </CodeGroup>

    Replace `{collectionId}` with your collection ID and `{ipAssetId}` with the IP asset ID returned when you registered the asset. Then run the script:

    <CodeGroup>
      ```bash TypeScript theme={null}
      npx tsx getIPAsset.ts
      ```
    </CodeGroup>
  </Step>
</Steps>

## Confirm Book Registration

<Steps>
  <Step title="Get Action Status">
    You can easily check the IP asset registration status to ensure the action has completed before proceeding.

    <CodeGroup>
      ```typescript getAction.ts theme={null}
      const response = await fetch("https://staging.crossmint.com/api/v1/ip/actions/{actionId}", {
          method: "GET",
          headers: {
              "X-API-KEY": "<YOUR_API_KEY>",
              "Content-Type": "application/json"
          }
      });

      const action = await response.json();
      console.log("Action:", action);
      ```

      ```typescript response theme={null}
      {
          id: '1ffb0fc3-b652-4a0e-b748-3e09c3608826',
          status: 'success'
      }
      ```
    </CodeGroup>

    Use the action ID returned in any of the previous steps and run the script:

    <CodeGroup>
      ```bash TypeScript theme={null}
      npx tsx getAction.ts
      ```
    </CodeGroup>
  </Step>
</Steps>


# Music Quickstart ⚡
Source: https://docs.crossmint.com/solutions/story-protocol/music-quickstart

Register your music on Story in under 5 minutes

In this quickstart, you will:

* Register a music album as an IP collection
* Register a music track as an IP asset

<Note> This quickstart is under development as new features are added to the Story Protocol daily. </Note>

## Preparation Steps

<Steps>
  <Step title="Create a Developer Account and Project">
    <Snippet />
  </Step>

  <Step title="Get an API Key">
    Create a server-side API key with these scopes:
    `collection.create`,
    `collection.update`,
    `collection.read`,
    `nfts.create`,
    `nfts.read`.

    This allows your API key to perform any kind of asset registration action.
  </Step>
</Steps>

## Register Music Album

<Steps>
  <Step title="Create an IP Collection">
    <CodeGroup>
      ```typescript createCollection.ts theme={null}
      const response = await fetch("https://staging.crossmint.com/api/v1/ip/collections", {
          method: "POST",
          headers: {
              "X-API-KEY": "<YOUR_API_KEY>",
              "Content-Type": "application/json"
          },
          body: JSON.stringify({
              metadata: {
                  description: "My first music album",
                  name: "My First Album",
                  symbol: "MFA"
              },
              chain: "story-testnet"
          })
      });

      const collection = await response.json();
      console.log("Collection created:", collection);
      ```

      ```typescript response theme={null}
      {
          id: '1ffb0fc3-b652-4a0e-b748-3e09c3608826',
          actionId: '1ffb0fc3-b652-4a0e-b748-3e09c3608826',
          metadata: {
              name: 'My First Album',
              symbol: 'MFA',
              description: 'My first music album'
          },
          onChain: { chain: 'story-testnet' }
      }
      ```
    </CodeGroup>

    Additional metadata can be added to the collection to help with discovery, such as a cover image. Check out the [API reference](/api-reference/ip/create-ip-collection) for more information.

    To create the album, run the script:

    <CodeGroup>
      ```bash TypeScript theme={null}
      npx tsx createCollection.ts
      ```
    </CodeGroup>
  </Step>
</Steps>

## Register Song

<Steps>
  <Step title="Create a Song">
    Go to [Suno](https://suno.ai/), a music platform for AI-generated music, to create a song:

    * Input a prompt to create a song
    * Click on the final result to get the song's URL (i.e. `https://suno.com/song/c001fd6e-d6cd-474f-a7b6-6e6a9b3e2515`)
    * Copy the song ID in the URL (i.e. `c001fd6e-d6cd-474f-a7b6-6e6a9b3e2515`)
    * Copy the following URL: `https://cdn1.suno.ai/${SONG_ID}.mp3`, making sure to replace SONG\_ID with your own
  </Step>

  <Step title="Register Song on Story">
    <CodeGroup>
      ```typescript registerIPAsset.ts theme={null}
      const response = await fetch("https://staging.crossmint.com/api/v1/ip/collections/{collectionId}/ipassets", {
          method: "POST",
          headers: {
              "X-API-KEY": "<YOUR_API_KEY>",
              "Content-Type": "application/json"
          },
          body: JSON.stringify({
              owner: 'email:creator@example.com:story-testnet',
              nftMetadata: {
                  name: 'Snowflake Funk',
                  description: 'A disco groovy song for a house party during the winter time',
                  image: 'https://cdn2.suno.ai/image_large_c001fd6e-d6cd-474f-a7b6-6e6a9b3e2515.jpeg'
              },
              ipAssetMetadata: {
                  title: 'Snowflake Funk',
                  createdAt: '2025-02-11T11:13:00',
                  ipType: 'music',
                  image: 'https://cdn1.suno.ai/c001fd6e-d6cd-474f-a7b6-6e6a9b3e2515.mp3',
                  imageHash: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
                  mediaUrl: 'https://cdn1.suno.ai/c001fd6e-d6cd-474f-a7b6-6e6a9b3e2515.mp3',
                  mediaHash: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
                  mediaType: 'audio/mpeg',
                  creators: [
                      {
                          name: 'John Doe',
                          email: 'john.doe@example.com',
                          crossmintUserLocator: 'email:john.doe@example.com:story-testnet',
                          contributionPercent: 100
                      },
                  ],
                  media: [
                      {
                          name: 'Snowflake Funk',
                          url: 'https://cdn1.suno.ai/c001fd6e-d6cd-474f-a7b6-6e6a9b3e2515.mp3',
                          mimeType: 'audio/mpeg'
                      },
                  ],
                  attributes: [
                      {
                          key: 'Suno Artist',
                          value: 'InfluentialCoda427'
                      },
                      {
                          key: 'Source',
                          value: 'Suno.com'
                      }
                  ]
              }
          })
      });

      const ipAsset = await response.json();
      console.log("IP Asset:", ipAsset);
      ```

      ```typescript response theme={null}
      {
          "id": "d290f1ee-6c54-4b01-90e6-d701748f0851",
          "actionId": "d290f1ee-6c54-4b01-90e6-d701748f0851",
          "nftMetadata": {
              "name": "Snowflake Funk",
              "description": "A disco groovy song for a house party during the winter time",
              "image": "https://cdn2.suno.ai/image_large_c001fd6e-d6cd-474f-a7b6-6e6a9b3e2515.jpeg"
          },
          "ipAssetMetadata": {
              "title": "Snowflake Funk",
              "createdAt": "2025-02-11T11:13:00",
              "ipType": "music",
              "creators": [
                  {
                      "name": "John Doe",
                      "email": "email:user@example.com",
                      "contributionPercent": 100
                  }
              ],
              "media": [
                  {
                      "name": "Snowflake Funk",
                      "url": "https://cdn1.suno.ai/c001fd6e-d6cd-474f-a7b6-6e6a9b3e2515.mp3",
                      "mimeType": "audio/mpeg"
                  }
              ],
              "attributes": [
                  {
                      "key": "Suno Artist",
                      "value": "InfluentialCoda427"
                  },
                  {
                      "key": "Source",
                      "value": "Suno.com"
                  }
              ]
          },
          "onChain": {
              "status": "success",
              "chain": "story-testnet",
              "contractAddress": "0x123",
              "ipAssetId": "0xAC6062FF53fa41e61Fe01B89B83d9dB96b5F9280",
              "tokenId": "1",
              "txId": "0x123",
              "explorerLink": "https://explorer.story.foundation/ipa/0xAC6062FF53fa41e61Fe01B89B83d9dB96b5F9280"
          }
      }
      ```
    </CodeGroup>

    Run the script to register the song:

    <CodeGroup>
      ```bash TypeScript theme={null}
      npx tsx registerIPAsset.ts
      ```
    </CodeGroup>
  </Step>
</Steps>

## Retrieve Your IP Asset

<Steps>
  <Step title="Get IP Asset Details">
    After registering your IP asset, you can retrieve its details to verify the information or display it in your application.

    <CodeGroup>
      ```typescript getIPAsset.ts theme={null}
      const response = await fetch("https://staging.crossmint.com/api/v1/ip/collections/{collectionId}/ipassets/{ipAssetId}", {
          method: "GET",
          headers: {
              "X-API-KEY": "<YOUR_API_KEY>",
              "Content-Type": "application/json"
          }
      });

      const ipAsset = await response.json();
      console.log("IP Asset:", ipAsset);
      ```

      ```typescript response theme={null}
      {
          "id": "d290f1ee-6c54-4b01-90e6-d701748f0851",
          "nftMetadata": {
              "name": "Snowflake Funk",
              "description": "A disco groovy song for a house party during the winter time",
              "image": "https://cdn2.suno.ai/image_large_c001fd6e-d6cd-474f-a7b6-6e6a9b3e2515.jpeg"
          },
          "ipAssetMetadata": {
              "title": "Snowflake Funk",
              "createdAt": "2025-02-11T11:13:00",
              "ipType": "music",
              "creators": [
                  {
                      "name": "John Doe",
                      "email": "email:user@example.com",
                      "contributionPercent": 100
                  }
              ],
              "media": [
                  {
                      "name": "Snowflake Funk",
                      "url": "https://cdn1.suno.ai/c001fd6e-d6cd-474f-a7b6-6e6a9b3e2515.mp3",
                      "mimeType": "audio/mpeg"
                  }
              ],
              "attributes": [
                  {
                      "key": "Suno Artist",
                      "value": "InfluentialCoda427"
                  },
                  {
                      "key": "Source",
                      "value": "Suno.com"
                  }
              ]
          },
          "onChain": {
              "status": "success",
              "chain": "story-testnet",
              "contractAddress": "0x123",
              "ipAssetId": "d290f1ee-6c54-4b01-90e6-d701748f0851",
              "tokenId": "1",
              "txId": "0x123",
              "explorerLink": "https://explorer.story.foundation/ipa/0xAC6062FF53fa41e61Fe01B89B83d9dB96b5F9280"
          }
      }
      ```
    </CodeGroup>

    Replace `{collectionId}` with your collection ID and `{ipAssetId}` with the IP asset ID returned when you registered the asset. Then run the script:

    <CodeGroup>
      ```bash TypeScript theme={null}
      npx tsx getIPAsset.ts
      ```
    </CodeGroup>
  </Step>
</Steps>

## Confirm Song Registration

<Steps>
  <Step title="Get Action Status">
    You can easily check the IP asset registration status to ensure the action has completed before proceeding.

    <CodeGroup>
      ```typescript getAction.ts theme={null}
      const response = await fetch("https://staging.crossmint.com/api/v1/ip/actions/{actionId}", {
          method: "GET",
          headers: {
              "X-API-KEY": "<YOUR_API_KEY>",
              "Content-Type": "application/json"
          }
      });

      const action = await response.json();
      console.log("Action:", action);
      ```

      ```typescript response theme={null}
      {
          id: '1ffb0fc3-b652-4a0e-b748-3e09c3608826',
          status: 'success'
      }
      ```
    </CodeGroup>

    Use the action ID returned in any of the previous steps and run the script:

    <CodeGroup>
      ```bash TypeScript theme={null}
      npx tsx getAction.ts
      ```
    </CodeGroup>
  </Step>
</Steps>


# Client Wallets Quickstart ⚡
Source: https://docs.crossmint.com/solutions/story-protocol/wallets/client-side-wallets

Create client wallets and create your first NFT on Story in under 5 minutes

## Introduction

In this quickstart, you will create new user wallets on Story and use passkeys for sending transactions using this wallet. By the end of this guide, you'll be able to:

* Create client-side wallets on Story Protocol
* Configure multiple authentication methods
* Mint your first NFT using the wallet

## Preparation Steps

<Steps>
  <Step title="Create a developer account">
    <Snippet />
  </Step>

  <Step title="Get an API Key">
    Create a client-side API key with these scopes:
    `wallets.create`,
    `wallets.read`,
    `wallets:balance.read`,
    `wallets:transactions.create`,
    `wallets:transactions.read`,
    `users.read`,
    `users.create`.

    Check the "JWT Auth" box.

    This allows your API key to create new client wallets.
  </Step>
</Steps>

## Create Client Wallets

<Steps>
  <Step title="Setup Application">
    Follow the [React Wallets Quickstart](/wallets/quickstarts/react) guide to use Crossmint's Wallets SDK in your application.
  </Step>

  <Step title="Configure Story's Chain">
    Set `story-testnet` as the `chain` property.

    <CodeGroup>
      ```tsx providers.tsx theme={null}
      "use client";

      import { CrossmintProvider, CrossmintAuthProvider, CrossmintWalletsProvider } from "@crossmint/client-sdk-react-ui";

      const clientApiKey = process.env.NEXT_PUBLIC_CROSSMINT_CLIENT_KEY as string;

      export default function Providers({ children }: { children: React.ReactNode }) {
          return (
              <CrossmintProvider apiKey={clientApiKey}>
                  <CrossmintAuthProvider
                      loginMethods={["google", "twitter", "farcaster", "email"]}
                  >
                      <CrossmintWalletProvider
                          createOnLogin={{
                              chain: "story-testnet",
                              signer: {
                                  type: "<your-signer-type>",
                              },
                          }}
                      >
                          {children}
                      </CrossmintWalletProvider>
                  </CrossmintAuthProvider>
              </CrossmintProvider>
          );
      }
      ```
    </CodeGroup>
  </Step>

  <Step title="Format Login Component">
    Adjust the login component's style to match your application's design. You can experiment with it [here](https://playground.crossmint.com/wallets/auth).

    <Frame type="simple">
      <img alt="GIF of user login flow" />
    </Frame>
  </Step>
</Steps>

<Note>
  This quickstart uses [Crossmint Auth](/authentication/introduction) for convenience. You can [bring your own auth provider](/wallets/guides/bring-your-own-auth), which is recommended for production scenarios.
</Note>

## Send Arbitrary Transaction

<Steps>
  <Step title="Specify the NFT Contract">
    Define the address and interface (ABI) of the NFT smart contract on Story Protocol.

    <CodeGroup>
      ```tsx components/utils.ts theme={null}
      export const NFT_CONTRACT_ADDRESS = "0x937bef10ba6fb941ed84b8d249abc76031429a9a" as const;
      export const NFT_CONTRACT_ABI = [
          {
              inputs: [
                  {
                      internalType: "address",
                      name: "recipient",
                      type: "address",
                  },
                  {
                      internalType: "string",
                      name: "tokenURI",
                      type: "string",
                  },
              ],
              name: "mintNFT",
              outputs: [
                  {
                      internalType: "uint256",
                      name: "",
                      type: "uint256",
                  },
              ],
              stateMutability: "nonpayable",
              type: "function",
          },
      ];
      ```
    </CodeGroup>
  </Step>

  <Step title="Create a React Component for the Transaction">
    Create a user-friendly interface that:

    * Displays the transaction status
    * Allows users to send an arbitrary transaction to the NFT contract
    * Displays the transaction hash and a link to the Story Explorer

    <CodeGroup>
      ```tsx components/SendTransactionComponent.tsx theme={null}
      import { EVMWallet, useWallet } from "@crossmint/client-sdk-react-ui";
      import React from "react";
      import { NFT_CONTRACT_ADDRESS, NFT_CONTRACT_ABI } from "./utils";
      import { encodeFunctionData } from "viem";

      export default function SendTransactionComponent() {
          const { wallet } = useWallet();
          const [txStatus, setTxStatus] = React.useState<'idle' | 'pending' | 'success' | 'error'>('idle');
          const [txError, setTxError] = React.useState<string | null>(null);
          const [tx, setTx] = React.useState<string | null>(null);

          if (wallet) {
              return (
                  <div className="max-w-md mx-auto bg-white rounded-xl  overflow-hidden p-6 space-y-4 ">

                      <button
                          onClick={async () => {
                              try {
                                  setTxStatus('pending');
                                  setTxError(null);
                                  const data = encodeFunctionData({
                                      abi: NFT_CONTRACT_ABI,
                                      functionName: "mintNFT",
                                      args: [wallet.address, "test-uri"],
                                  });

                                  const evmWallet = EVMWallet.from(wallet);
                                  const { hash: tx } = await evmWallet.sendTransaction({
                                      to: NFT_CONTRACT_ADDRESS,
                                      data: data,
                                  });
                                  setTx(tx);
                                  setTxStatus('success');
                              } catch (error) {
                                  setTxStatus('error');
                                  setTxError(error instanceof Error ? error.message : 'Transaction failed');
                                  setTx(null);
                              }
                          }}
                          disabled={txStatus === 'pending'}
                          className="w-full flex items-center justify-center space-x-2 bg-blue-600 hover:bg-blue-700 text-white px-4 py-2 rounded-lg transition-colors"
                      >
                          {txStatus === 'pending' ? (
                              <>
                                  <svg className="animate-spin -ml-1 mr-3 h-5 w-5 text-white" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
                                      <circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4"></circle>
                                      <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path>
                                  </svg>
                                  <span>Processing...</span>
                              </>
                          ) : (
                              'Send Transaction'
                          )}
                      </button>

                      <div className="mt-4">
                          {txStatus === 'pending' && (
                              <div className="flex items-center space-x-2 text-amber-500">
                                  <svg className="animate-spin h-5 w-5" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
                                      <circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4"></circle>
                                      <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path>
                                  </svg>
                                  <span>Transaction in progress...</span>
                              </div>
                          )}
                          {txStatus === 'success' && (
                              <div className="flex items-center space-x-2 text-emerald-600">
                                  <svg className="h-5 w-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
                                      <path strokeLinecap="round" strokeLinejoin="round" strokeWidth="2" d="M5 13l4 4L19 7"></path>
                                  </svg>
                                  <span>Transaction successful!</span>
                                  {tx && (
                                      <a
                                          href={`https://www.oklink.com/story-odyssey/tx/${tx}`}
                                          target="_blank"
                                          rel="noopener noreferrer"
                                          className="underline hover:text-emerald-700"
                                      >
                                          View in explorer
                                      </a>
                                  )}
                              </div>
                          )}
                          {txStatus === 'error' && (
                              <div className="flex items-center space-x-2 text-rose-500">
                                  <svg className="h-5 w-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
                                      <path strokeLinecap="round" strokeLinejoin="round" strokeWidth="2" d="M6 18L18 6M6 6l12 12"></path>
                                  </svg>
                                  <span>Transaction failed: {txError}</span>
                              </div>
                          )}
                      </div>
                  </div>
              );
          }
          return null;
      }
      ```
    </CodeGroup>
  </Step>

  <Step title="Add the Transaction Component to the App">
    Incorporate the transaction component into the main wallet interface, using the `useWallet` hook to manage wallet state and pass it to the transaction component.

    <CodeGroup>
      ```tsx app/components/WalletComponent.tsx theme={null}
      export default function WalletComponent() {
          const { wallet, status, error } = useWallet();
          return (
              <>
                  <Card className="p-4">
                      <Status wallet={wallet} status={status} error={error} />
                  </Card>
                  <SendTransactionComponent wallet={wallet} />
              </>
          );
      }
      ```
    </CodeGroup>
  </Step>
</Steps>


# Server Wallets Quickstart ⚡
Source: https://docs.crossmint.com/solutions/story-protocol/wallets/server-side-wallets

Create server wallets on Story in under 5 minutes

In this quickstart, you will create new user wallets on Story.

<Note> This quickstart is under development as new features are added to the Story Protocol daily. </Note>

## Preparation Steps

<Steps>
  <Step title="Create a Developer Account and Project">
    <Snippet />
  </Step>

  <Step title="Get an API Key">
    Create a server-side API key with these scopes:
    `wallets.create`,
    `wallets:transactions.create`,
    `wallets:transactions.sign`.

    This allows your API key to create new server wallets.
  </Step>
</Steps>

## Create Server Wallets

<Steps>
  <Step title="Choose a Wallet Type">
    Below is a summary of available wallet types and their characteristics:

    | Custodial | Type               | Admin Signer               |
    | --------- | ------------------ | -------------------------- |
    | True      | `evm-smart-wallet` | `evm-fireblocks-custodial` |
    | False     | `evm-smart-wallet` | `evm-keypair`              |
  </Step>

  <Step title="Create a Wallet">
    <CodeGroup>
      ```typescript createWallet.ts theme={null}
      const response = await fetch("https://staging.crossmint.com/api/2022-06-09/wallets", {
          method: "POST",
          headers: {
              "X-API-KEY": "<YOUR_API_KEY>",
              "Content-Type": "application/json",
          },
          body: JSON.stringify({
              type: "<WALLET_TYPE>",
              // Here you can pass a user ID, email, phone number, twitter handle etc. depending on how the user is identified in your application
              linkedUser: "email:user@example.com",
              config:{
                  adminSigner: {type: "<ADMIN_SIGNER>"},
              }
          }),
      });

      const wallet = await response.json();
      console.log("Wallet created:", wallet);
      ```

      ```typescript response theme={null}
      {
          type: 'evm-smart-wallet',
          config: {
              adminSigner: {
                  type: 'evm-fireblocks-custodial',
                  address: '0xc55C0a7695DC5D9322aE5204AED91BF13c3412F2',
                  locator: 'evm-fireblocks-custodial:0xc55C0a7695DC5D9322aE5204AED91BF13c3412F2'
              }
          },
          address: '0x8B11c6D3a7115A462a91183824c83574c9190E06',
          linkedUser: 'email:user@example.com',
          createdAt: '2025-02-07T21:34:29.109Z'
      }
      ```
    </CodeGroup>

    Now, run the script:

    <CodeGroup>
      ```bash TypeScript theme={null}
      npx tsx createWallet.ts
      ```
    </CodeGroup>
  </Step>
</Steps>

## Send Arbitrary Transaction

<Steps>
  <Step title="Prepare the transaction">
    Set up a Story Protocol client using the wallet created in the previous step and prepare a transaction to create a new NFT collection

    <CodeGroup>
      ```typescript prepareTransaction.ts theme={null}
      const client = StoryClient.newClient({
          transport: http(RPC_PROVIDER_URL),
          account: wallet.address,
      });

      const creationTx = await client.nftClient.createNFTCollection({
          name: "A collection of IP fantasy assets",
          symbol: "XMT",
          contractURI: "ipfs://QmXYnQJjUxojhh6NKkxPkcXNKFo4pU2hxUyJjqzTcQL9rE",
          isPublicMinting: true,
          mintOpen: true,
          mintFeeRecipient: wallet.address,
          txOptions: {
              encodedTxDataOnly: true,
          },
      });
      ```
    </CodeGroup>
  </Step>

  <Step title="Send the transaction">
    Send the prepared transaction to Crossmint's API, which handles the blockchain interaction. The transaction creates the NFT collection on Story Protocol's network without requiring user's signature or handling of gas fees.

    <CodeGroup>
      ```typescript createTransaction.ts theme={null}
      const response = await fetch(`https://staging.crossmint.com/api/2022-06-09/wallets/${wallet.address}/transactions`, {
          method: "POST",
          headers: {
              "X-API-KEY": "<YOUR_API_KEY>",
              "Content-Type": "application/json",
          },
          body: JSON.stringify({
              params: {
                  call: {
                      // Encoded transaction data
                      data: creationTx.encodedTxData.data,
                      // Transaction destination
                      to: creationTx.encodedTxData.to,
                  },
                  chain: "story-testnet",
              },
          }),
      });

      const transaction = await response.json();
      console.log("Transaction created:", transaction.id);
      ```
    </CodeGroup>

    <Note>
      Story Protocol transactions through Crossmint smart wallets are completely gas-free! You can focus on building your
      application without worrying about managing gas fees or token balances.
    </Note>
  </Step>

  <Step title="Monitor Transaction Status">
    Check the transaction status using the transaction ID.

    <CodeGroup>
      ```javascript checkStatus.js theme={null}
      const response = await fetch(
          `https://staging.crossmint.com/api/2022-06-09/wallets/${wallet.address}/transactions/${transaction.id}`,
          {
              method: "GET",
              headers: {
                  "X-API-KEY": "<YOUR_API_KEY>",
              },
          }
      );

      const status = await response.json();
      console.log("Status:", status.status);
      ```
    </CodeGroup>
  </Step>
</Steps>


# Onramp to External Wallets
Source: https://docs.crossmint.com/stablecoin-orchestration/onramp/guides/onramp-to-external-wallets

Enable onramp orders to wallets not created by Crossmint

This guide walks you through how to enable onramp orders to external wallets (EOAs or any other smart wallet from a different wallet provider).

## 1. Link External Wallet to Crossmint User

Before creating an onramp order to an external wallet, you must link the wallet to a Crossmint user, using the Link External Wallet API:

<CodeGroup>
  ```bash cURL theme={null}
  curl --request PUT \
      --url https://staging.crossmint.com/api/2025-06-09/users/{userLocator}/linked-wallets/{walletAddress} \
      --header 'X-API-KEY: <x-api-key>' \
      --header 'Content-Type: application/json' \
      --data '{
          "chainType": "evm",
          "proof": "<signature>"
      }'
  ```

  ```js Node.js theme={null}
  const options = {
      method: 'PUT',
      headers: {
          'X-API-KEY': '<x-api-key>',
          'Content-Type': 'application/json'
      },
      body: JSON.stringify({
          chainType: "evm",
          proof: "<signature>"
      })
  };

  const userLocator = "email:user@example.com";
  const walletAddress = "0x1234567890abcdef1234567890abcdef12345678";

  fetch(`https://staging.crossmint.com/api/2025-06-09/users/${userLocator}/linked-wallets/${walletAddress}`, options)
      .then(response => response.json())
      .then(response => console.log(response))
      .catch(err => console.error(err));
  ```
</CodeGroup>

The `proof` field is optional:

* If you omit it, you are simply linking the external wallet to the user without proving ownership yet.
* If you pass it, you prove ownership of the wallet in the same request.

When linking without proof, the API responds with a verification challenge:

```json theme={null}
{
    "address": "0x1234567890abcdef1234567890abcdef12345678",
    "chainType": "evm",
    "type": "external-wallet",
    "ownership": {
        "verified": false,
        "verificationChallenge": "crossmint.com wants you to sign in with your blockchain account:\n0x1234...5678\n\nI am signing this message to prove ownership of my wallet address 0x1234...5678 for Crossmint verification.\n\nURI: https://..."
    }
}
```

The `verificationChallenge` follows the [CAIP-122](https://chainagnostic.org/CAIPs/caip-122) standard.

## 2. Create Onramp Order

Create an onramp order using the [Create Order API](/api-reference/headless/create-order) with the linked external wallet address as the recipient.

<CodeGroup>
  ```bash cURL theme={null}
  curl --request POST \
      --url https://staging.crossmint.com/api/2022-06-09/orders \
      --header 'X-API-KEY: <x-api-key>' \
      --header 'Content-Type: application/json' \
      --data '{
          "recipient": {
              "walletAddress": "0x1234567890abcdef1234567890abcdef12345678"
          },
          "payment": {
              "method": "card",
              "receiptEmail": "user@example.com"
          },
          "lineItems": [
              {
                  "tokenLocator": "base-sepolia:0x036CbD53842c5426634e7929541eC2318f3dCF7e",
                  "executionParameters": {
                      "mode": "exact-in",
                      "amount": "10"
                  }
              }
          ]
      }'
  ```

  ```js Node.js theme={null}
  const options = {
      method: 'POST',
      headers: {
          'X-API-KEY': '<x-api-key>',
          'Content-Type': 'application/json'
      },
      body: JSON.stringify({
          recipient: {
              walletAddress: "0x1234567890abcdef1234567890abcdef12345678"
          },
          payment: {
              method: "card",
              receiptEmail: "user@example.com"
          },
          lineItems: [
              {
                  tokenLocator: "base-sepolia:0x036CbD53842c5426634e7929541eC2318f3dCF7e",
                  executionParameters: {
                      mode: "exact-in",
                      amount: "10"
                  }
              }
          ]
      })
  };

  fetch('https://staging.crossmint.com/api/2022-06-09/orders', options)
      .then(response => response.json())
      .then(response => console.log(response))
      .catch(err => console.error(err));
  ```
</CodeGroup>

Depending on the transaction value and the user's past activity, the order may or may not require wallet ownership verification:

* **Below threshold**: If the transaction value is below 1,000 euros **and** the user's past 30-day onramp transaction volume is below 1,000 euros, ownership verification is not required. The order proceeds directly to the kyc/payment phase.
* **Above threshold**: If either threshold is surpassed, the order status will be `requires-recipient-verification` and the user must sign a message to prove wallet ownership.

When ownership verification is required, the order response will look like this:

```json theme={null}
{
    "clientSecret": "...",
    "order": {
        "orderId": "987e81ab-8c8f-464e-95e9-11ceda80d559",
        "phase": "payment",
        "lineItems": [...],
        "quote": {...},
        "payment": {
            "status": "requires-recipient-verification",
            "method": "card",
            "currency": "usd",
            "preparation": {
                "message": "crossmint.com wants you to sign in with your blockchain account:\n0x1234...5678\n\nI am signing this message to prove ownership of my wallet address 0x1234...5678 for Crossmint verification.\n\nURI: https://...\nVersion: 1\nNonce: ...\nIssued At: ...\nExpiration Time: ...\nRequest ID: ...\nChain ID: base-sepolia",
                "email": "user@example.com"
            }
        }
    }
}
```

## 3. Sign Message

If the order requires ownership verification, the user must sign the `preparation.message` returned in the order response using their wallet's private key.

<CodeGroup>
  ```js EVM (ethers.js) theme={null}
  import { Wallet } from "ethers";

  const wallet = new Wallet("<private_key>");
  const message = order.payment.preparation.message;
  const signature = await wallet.signMessage(message);
  ```

  ```js Solana (tweetnacl) theme={null}
  import nacl from "tweetnacl";
  import { decodeUTF8 } from "tweetnacl-util";
  import { encode as base64Encode } from "@stablelib/base64";

  const message = order.payment.preparation.message;
  const messageBytes = decodeUTF8(message);
  const signatureBytes = nacl.sign.detached(messageBytes, keypair.secretKey);
  const signature = base64Encode(signatureBytes);
  ```
</CodeGroup>

## 4. Submit Signature

Use the same Link External Wallet API to submit the signature as proof of ownership. Pass the signature in the `proof` field:

<CodeGroup>
  ```bash cURL theme={null}
  curl --request PUT \
      --url https://staging.crossmint.com/api/2025-06-09/users/{userLocator}/linked-wallets/{walletAddress} \
      --header 'X-API-KEY: <x-api-key>' \
      --header 'Content-Type: application/json' \
      --data '{
          "chainType": "evm",
          "proof": "<signature>"
      }'
  ```

  ```js Node.js theme={null}
  const options = {
      method: 'PUT',
      headers: {
          'X-API-KEY': '<x-api-key>',
          'Content-Type': 'application/json'
      },
      body: JSON.stringify({
          chainType: "evm",
          proof: "<signature>"
      })
  };

  const userLocator = "email:user@example.com";
  const walletAddress = "0x1234567890abcdef1234567890abcdef12345678";

  fetch(`https://staging.crossmint.com/api/2025-06-09/users/${userLocator}/linked-wallets/${walletAddress}`, options)
      .then(response => response.json())
      .then(response => console.log(response))
      .catch(err => console.error(err));
  ```
</CodeGroup>

Once ownership is verified, the response will confirm verification:

```json theme={null}
{
    "address": "0x1234567890abcdef1234567890abcdef12345678",
    "chainType": "evm",
    "type": "external-wallet",
    "ownership": {
        "verified": true
    }
}
```

## 5. Complete Order

Once the signature is submitted and verified, fetch the order using the [Get Order API](/api-reference/headless/get-order). The order status should now have proceeded to the next phase:

* **`requires-kyc`**: The user hasn't completed KYC yet and will be guided through the KYC flow first.
* **`awaiting-payment`**: The user has completed KYC and can proceed to complete payment.

The user will be guided through Crossmint's embedded components to complete their order, handling payment and any remaining compliance steps automatically.


# Register User Data
Source: https://docs.crossmint.com/stablecoin-orchestration/onramp/guides/register-user-data

Pass user KYC data to Crossmint for seamless USDC onramp

<Note> Ideal for companies that have verified users through their own identity verification (IDV) provider. </Note>

Companies can compliantly pass user KYC data to Crossmint, enabling seamless USDC onramp purchase flows.

If you prefer to have individual users provide their KYC data client-side, Crossmint supports that as well. See the [React Quickstart](/stablecoin-orchestration/onramp/quickstarts/react) for that approach.

## How It Works

Crossmint relies on your company running KYC, ID verification, and liveness checks with your own IDV provider (such as Persona or Sumsub). You then share the full KYC data with Crossmint via API. In order to complete orders, Crossmint runs sanction and PEP (Politically Exposed Persons) screens, and performs ongoing monitoring to ensure compliance.

## Register User with Full KYC Data

Check the requirements [here](/stablecoin-orchestration/users-compliance/data-requirements), on what information needs to be attached to the user using the [Create User API](/api-reference/users/upsert-user).

## Create an Onramp Order

Once the user is registered with their KYC data, you can create an onramp order. The order will use the registered KYC data for compliance checks.

<Note>
  **Important**: The KYC data is linked to the order through the email address. The `payment.receiptEmail` field must match the email address used when registering the user's KYC data via the [Create User API](/api-reference/users/upsert-user). This is how Crossmint associates the pre-registered KYC information with the order.
</Note>

<CodeGroup>
  ```bash cURL theme={null}
  curl --request POST \
      --url https://staging.crossmint.com/api/2022-06-09/orders \
      --header 'X-API-KEY: <x-api-key>' \
      --header 'Content-Type: application/json' \
      --data '{
          "recipient": {
              "walletAddress": "<recipient-wallet-address>"
          },
          "payment": {
              "method": "card",
              "receiptEmail": "johnd@example.com"
          },
          "lineItems": [
              {
                  "tokenLocator": "base-sepolia:0x036CbD53842c5426634e7929541eC2318f3dCF7e",
                  "executionParameters": {
                      "mode": "exact-in",
                      "amount": "1"
                  }
              }
          ]
      }'
  ```

  ```js Node.js theme={null}
  const options = {
      method: 'POST',
      headers: {
          'X-API-KEY': '<x-api-key>',
          'Content-Type': 'application/json'
      },
      body: JSON.stringify({
          recipient: {
              walletAddress: "<recipient-wallet-address>"
          },
          payment: {
              method: "card",
              // This email MUST match the email used in kycData.email when registering the user
              receiptEmail: "johnd@example.com"
          },
          lineItems: [
              {
                  tokenLocator: "base-sepolia:0x036CbD53842c5426634e7929541eC2318f3dCF7e",
                  executionParameters: {
                      mode: "exact-in",
                      amount: "1"
                  }
              }
          ]
      })
  };

  fetch('https://staging.crossmint.com/api/2022-06-09/orders', options)
      .then(response => response.json())
      .then(response => console.log(response))
      .catch(err => console.error(err));
  ```

  ```python Python theme={null}
  import requests

  url = "https://staging.crossmint.com/api/2022-06-09/orders"

  payload = {
      "recipient": {
          "walletAddress": "<recipient-wallet-address>"
      },
      "payment": {
          "method": "card",
          "receiptEmail": "johnd@example.com"
      },
      "lineItems": [
          {
              "tokenLocator": "base-sepolia:0x036CbD53842c5426634e7929541eC2318f3dCF7e",
              "executionParameters": {
                  "mode": "exact-in",
                  "amount": "1"
              }
          }
      ]
  }
  headers = {
      "X-API-KEY": "<x-api-key>",
      "Content-Type": "application/json"
  }

  response = requests.post(url, json=payload, headers=headers)

  print(response.json())
  ```
</CodeGroup>

<Info>
  The `lineItems` field accepts both a single object or an array. The examples above use an array for consistency, but you can also pass a single line item object directly.
</Info>

### Linking KYC Data to Orders

When you create an order, Crossmint automatically looks up the user's KYC data based on the email address provided in `payment.receiptEmail`. Here's the complete flow:

<Steps>
  <Step title="Register user with KYC data">
    First, register the user's KYC information using the [Create User API](/api-reference/users/upsert-user). Make sure to include the user's email in the `email` field within `kycData`:

    ```javascript theme={null}
    const userLocator = "userId:johnd-123";

    const options = {
      method: 'PUT',
      headers: {
        'X-API-KEY': '<x-api-key>',
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        userDetails: {
          firstName: "John",
          lastName: "Doe",
          dateOfBirth: "1995-01-01",
          countryOfResidence: "DE"
        },
        kycData: {
          addressOfResidence: {
            line1: "123 Hauptstrasse",
            line2: "Apt 5",
            city: "Berlin",
            postalCode: "10115"
          },
          email: "johnd@example.com",  // This email will be used to link KYC data
          identityDocument: {
            type: "passport",
            number: "AS12321"
          }
        }
      })
    };

    fetch(`https://staging.crossmint.com/api/2025-06-09/users/${userLocator}`, options)
      .then(response => response.json())
      .then(response => console.log(response))
      .catch(err => console.error(err));
    ```
  </Step>

  <Step title="Create order with matching email">
    When creating the onramp order, use the same email address in `payment.receiptEmail`:

    ```javascript theme={null}
    const options = {
      method: 'POST',
      headers: {
        'X-API-KEY': '<x-api-key>',
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        recipient: {
          walletAddress: "<recipient-user-wallet-address>"
        },
        payment: {
          method: "card",
          receiptEmail: "johnd@example.com"  // Must match kycData.email
        },
        lineItems: [
          {
            tokenLocator: "base-sepolia:0x036CbD53842c5426634e7929541eC2318f3dCF7e",
            executionParameters: {
              mode: "exact-in",
              amount: "1"
            }
          }
        ]
      })
    };

    fetch('https://staging.crossmint.com/api/2022-06-09/orders', options)
      .then(response => response.json())
      .then(response => console.log(response))
      .catch(err => console.error(err));
    ```
  </Step>
</Steps>

## Order Responses

### Success: Full KYC Data Present

When all required KYC data has been provided and validated, the order moves to the payment phase:

```json theme={null}
{
  "clientSecret": "...",
  "order": {
    "orderId": "987e81ab-8c8f-464e-95e9-11ceda80d559",
    "phase": "payment",
    "locale": "en-US",
    "lineItems": [...],
    "quote": {...},
    "payment": {
      "method": "card",
      "currency": "usd",
      "status": "awaiting-payment"
    }
  }
}
```

### Success: Additional KYC Inquiry

When full KYC data is present but Crossmint needs to run additional compliance checks, the order enters a processing state. This typically resolves within a few seconds as Crossmint runs the appropriate checks:

```json theme={null}
{
  "clientSecret": "...",
  "order": {
    "orderId": "987e81ab-8c8f-464e-95e9-11ceda80d559",
    "phase": "payment",
    "locale": "en-US",
    "lineItems": [...],
    "quote": {...},
    "payment": {
      "method": "card",
      "currency": "usd",
      "status": "pending-kyc-review"
    }
  }
}
```

### Error: Missing KYC Data

If no user personal data is provided, or if the data is insufficient, the order will fail:

```json theme={null}
{
  "error": true,
  "message": "Required full KYC user data is missing to complete the order"
}
```

## Next Steps

<CardGroup>
  <Card title="React Quickstart" icon="react" href="/stablecoin-orchestration/onramp/quickstarts/react">
    Build an embedded onramp checkout with React
  </Card>

  <Card title="Onramp Overview" icon="circle-info" href="/stablecoin-orchestration/onramp/overview">
    Learn more about Crossmint's onramp capabilities
  </Card>
</CardGroup>


# Overview
Source: https://docs.crossmint.com/stablecoin-orchestration/onramp/overview

Allow your customers to obtain stablecoins using credit card, apple pay, and more

<img alt="Onramp Fiat to Crypto" />

Crossmint's Onramp allows your customers to obtain stablecoins with the highest conversion rates in the industry.
Embed onramping flows natively in your app with plug-and-play widgets and APIs. The SDK handles payment processing,
compliance, and chargebacks, so you can focus on building your product.

**Key Features**

* **Native integrations**: embedded flow which feels native to your app.
* **Progressive onboarding**: light KYC for up to \$1,000 per year. Above that threshold, full KYC applies.
* **Full chargeback protection**: Crossmint manages disputes and assumes chargeback risk.
* **Multiple payment methods**: credit/debit cards, Apple Pay, Google Pay, personal bank accounts.
* **Real-time observability**: monitor events via dashboards, webhooks, and APIs.
* **Integrated Crossmint wallets**: modular APIs, fully integrated with Crossmint's wallets.

## Integration Options

| Integration Type                                                   | Best for                                                                    | Customization level                         | Supported Platforms                           |
| :----------------------------------------------------------------- | :-------------------------------------------------------------------------- | :------------------------------------------ | :-------------------------------------------- |
| **[Embedded](/stablecoin-orchestration/onramp/quickstarts/react)** | Teams that want a plug-and-play experience, with minimal engineering effort | Medium — prebuilt UI with branding controls | Web, mobile apps (React, React Native, Swift) |

## Get Started

<Snippet />

<CardGroup>
  <Card title="Quickstart ⚡" icon="bolt" href="/stablecoin-orchestration/onramp/quickstarts/react">
    Allow your users to buy stablecoins with credit cards in under 5 minutes
  </Card>

  <Card title="Onramp Embedded Quickstart" icon="github" href="https://github.com/Crossmint/onramp-quickstart">
    See a full working example
  </Card>

  <Card title="Fintech Starter App" icon="building-columns" href="https://github.com/crossmint/fintech-starter-app">
    Demo webapp of a bank-like product with Crossmint wallets and onramp
  </Card>
</CardGroup>

## FAQs

<AccordionGroup>
  <Accordion title="How can I test the product? And how do I move to production?">
    The product is self-serve on **staging**. You can get an API key on the [staging console](https://staging.crossmint.com/signin?callbackUrl=/console) and follow the instructions on the docs.

    To move to production, you need a production API key. To obtain **production** access, reach out to our [sales team](https://www.crossmint.com/contact/sales).
  </Accordion>

  <Accordion title="Which tokens are supported?">
    Today, we support **USDC** and **USDT**. Access to other stablecoins available upon request. Check the checkout for
    support for other digital assets.
  </Accordion>

  <Accordion title="How can I track sales?">
    You can monitor purchases onchain or using webhooks. Sales dashboards, logs, and advanced analytics are also
    available in the console.
  </Accordion>

  <Accordion title="What are the transaction limits?">
    The standard transaction limits are **\$1,000 per user and day**. If you need higher limits, [contact us](https://www.crossmint.com/contact/sales).
  </Accordion>

  <Accordion title="Which geographies are supported?">
    To obtain the latest list of supported geographies, [contact us](https://www.crossmint.com/contact/sales).
  </Accordion>

  <Accordion title="What are the KYC requirements for the onramp?">
    All users must complete KYC in order to use the onramp. Two levels of KYC are supported:

    * **Light KYC**: applies to low-volume users. It requires providing full name, date of birth, nationality, country of residence, email, and government-issued ID number (no photo).
      * No more than €1,000 transacted in aggregate within a rolling 12-month period.

    * **Full KYC**: is required once the above threshold is exceeded, or if a risk flag is raised. In addition to the information collected for light KYC, users must provide source of funds, employment status, and complete a liveness check with document ID verification.

    Users will undergo light or full KYC based on their activity. Light KYC requires the following information: Full name, date of birth, country, and government-issued ID number (no photo required).

    Full KYC requires, in addition to the above, residential address, source of funds, employment status, liveness check and document ID verification.
  </Accordion>
</AccordionGroup>


# Kotlin
Source: https://docs.crossmint.com/stablecoin-orchestration/onramp/quickstarts/kotlin

Allow your Android users to buy stablecoins with credit cards and Google Pay

<Note>
  The Kotlin SDK is currently in **Beta**.
</Note>

In this guide, you'll learn how to:

* Install the Kotlin SDK
* Create an Onramp order for your authenticated users
* Use the embedded checkout component to handle KYC, payment, and delivery

<Frame type="simple">
  <img alt="Crossmint Onramp Embedded Checkout Demo" />
</Frame>

<CardGroup>
  <Snippet />

  <Card title="Kotlin SDK on GitHub" icon="github" href="https://github.com/Crossmint/crossmint-kotlin-checkout">
    View the Kotlin checkout example repository.
  </Card>
</CardGroup>

<Snippet />

## Requirements

* **Android SDK 24+**
* **Jetpack Compose**
* Android Studio Arctic Fox or later

## 1. Installation

Install the Crossmint Kotlin SDK using Maven Central.

<Steps>
  <Step title="Add Dependency">
    Add the following dependency to your app's `build.gradle.kts` file:

    ```kotlin theme={null}
    dependencies {
        implementation("com.crossmint:crossmint-sdk-android:0.0.9")
    }
    ```
  </Step>

  <Step title="Create API key">
    Create a [server-side API key](https://docs.crossmint.com/introduction/platform/api-keys/server-side) with the
    `orders.create` and `orders.read` scopes enabled. In staging, all scopes are included in your API key.
  </Step>
</Steps>

## 2. Create Order

<Note>
  If you want to enable onramp orders to external wallets (EOAs or third-party smart wallets) instead of Crossmint wallets, see the [Onramp to External Wallets](/stablecoin-orchestration/onramp/guides/onramp-to-external-wallets) guide before proceeding.
</Note>

Use the [Create Order API](/api-reference/headless/create-order) to initiate the purchase process from your backend.

<Snippet />

## 3. Use Component

Once you have the order response with `orderId` and `clientSecret`, use Crossmint's embedded checkout component in your Jetpack Compose view.

The component supports **native Google Pay** for a seamless Android payment experience.

```kotlin theme={null}
import com.crossmint.kotlin.checkout.CheckoutEnvironment
import com.crossmint.kotlin.checkout.CrossmintEmbeddedCheckout
import com.crossmint.kotlin.checkout.models.*

CrossmintEmbeddedCheckout(
    orderId = "<your_order_id>",
    clientSecret = "<your_client_secret>",
    payment = CheckoutPayment(
        crypto = CheckoutCryptoPayment(enabled = false),
        fiat = CheckoutFiatPayment(
            enabled = true,
            allowedMethods = CheckoutAllowedMethods(
                googlePay = true,  // Native Google Pay support
                applePay = false,
                card = true
            )
        )
    ),
    appearance = CheckoutAppearance(
        rules = CheckoutAppearanceRules(
            destinationInput = CheckoutDestinationInputRule(display = "hidden"),
            receiptEmailInput = CheckoutReceiptEmailInputRule(display = "hidden")
        )
    ),
    environment = CheckoutEnvironment.STAGING
)
```

### Key Features

* **Native Google Pay**: Seamless integration with Android payment system
* **Jetpack Compose Components**: Modern declarative UI framework
* **Automatic KYC**: Handles verification flow automatically
* **Customizable Appearance**: Control visibility of UI elements

## 4. Track Order

<Snippet />

## 5. Transaction Completion

<Snippet />

## 6. Next Steps

<Snippet />

* View the <a href="https://github.com/Crossmint/crossmint-kotlin-checkout">Kotlin checkout example repo</a> on GitHub


# React
Source: https://docs.crossmint.com/stablecoin-orchestration/onramp/quickstarts/react

Allow your users to buy stablecoins with credit cards in under 5 minutes

<Frame type="simple">
  <img alt="Crossmint Onramp Embedded Checkout Demo" />
</Frame>

<CardGroup>
  <Snippet />

  <Card title="Onramp Embedded Quickstart" icon="github" href="https://github.com/Crossmint/onramp-embedded-quickstart">
    See a full working example.
  </Card>
</CardGroup>

<Snippet />

Crossmint's Checkout API lets you build a seamless onramp so users can buy crypto with a credit card.

In this guide, you'll learn how to:

* Create a Crossmint order using a server action
* Use Crossmint's embedded checkout component to handle KYC, payment, and delivery automatically

## 1. Prerequisites

<Steps>
  <Step title="Install the SDK">
    Install the Crossmint client SDK:

    <Snippet />
  </Step>

  <Step title="Create API keys">
    Create a [server-side API key](https://docs.crossmint.com/introduction/platform/api-keys/server-side) with the
    `orders.create` and `orders.read` scopes enabled.

    <br />

    Create a [client-side API key](https://docs.crossmint.com/introduction/platform/api-keys/client-side) for the
    embedded checkout component.
  </Step>

  <Step title="Add environment variables">
    Add environment variables to your `.env.local`:

    ```sh .env.local theme={null}
    NEXT_PUBLIC_CROSSMINT_CLIENT_SIDE_API_KEY="_YOUR_CLIENT_API_KEY_"
    CROSSMINT_SERVER_SIDE_API_KEY="_YOUR_SERVER_API_KEY_"
    ```
  </Step>
</Steps>

## 2. Create the Server Action

<Note>
  If you want to enable onramp orders to external wallets (EOAs or third-party smart wallets) instead of Crossmint wallets, see the [Onramp to External Wallets](/stablecoin-orchestration/onramp/guides/onramp-to-external-wallets) guide before proceeding.
</Note>

Create a server action that will create orders via the Crossmint API:

```typescript app/actions/createOrder.ts theme={null}
"use server";

const USDC_TOKEN_LOCATORS = {
    solanaDevnet: "solana:4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU",
    baseSepolia: "base-sepolia:0x036CbD53842c5426634e7929541eC2318f3dCF7e",
    stellarTestnet: "stellar:CBIELTK6YBZJU5UP2WWQEUCYKLPU6AUNZ2BQ4WWFEIE3USCIHMXQDAMA",
};

interface CreateOrderParams {
    walletAddress: string;
    receiptEmail: string;
    amount: string;
    chain: "solanaDevnet" | "baseSepolia" | "stellarTestnet";
}

export async function createOrder({ walletAddress, receiptEmail, amount, chain }: CreateOrderParams) {
    const serverApiKey = process.env.CROSSMINT_SERVER_SIDE_API_KEY;
    if (serverApiKey == null) {
        throw new Error("CROSSMINT_SERVER_SIDE_API_KEY is not set");
    }

    const response = await fetch("https://staging.crossmint.com/api/2022-06-09/orders", {
        method: "POST",
        headers: {
            "Content-Type": "application/json",
            "x-api-key": serverApiKey,
        },
        body: JSON.stringify({
            lineItems: [
                {
                    tokenLocator: USDC_TOKEN_LOCATORS[chain],
                    executionParameters: {
                        mode: "exact-in",
                        amount,
                    },
                },
            ],
            payment: {
                method: "card",
                receiptEmail,
            },
            recipient: {
                walletAddress,
            },
        }),
    });

    if (!response.ok) {
        const error = await response.json();
        throw new Error(error.message || "Failed to create order");
    }

    return response.json();
}
```

## 3. Build the Onramp Component

Create a client component that handles the order creation and displays the embedded checkout:

```tsx app/components/OnrampCheckout.tsx theme={null}
"use client";

import { useState } from "react";
import { CrossmintProvider, CrossmintEmbeddedCheckout } from "@crossmint/client-sdk-react-ui";
import { createOrder } from "../actions/createOrder";

const CLIENT_API_KEY = process.env.NEXT_PUBLIC_CROSSMINT_CLIENT_SIDE_API_KEY || "";

// Destination wallets for testing transfers on each network
const TEST_WALLETS = {
    solanaDevnet: "<destination_wallet_address>",
    baseSepolia: "<destination_wallet_address>",
    stellarTestnet: "<destination_wallet_address>",
};

export default function OnrampCheckout() {
    const [order, setOrder] = useState<{ orderId: string; clientSecret: string } | null>(null);
    const [chain, setChain] = useState<"solanaDevnet" | "baseSepolia" | "stellarTestnet">("solanaDevnet");
    const [email, setEmail] = useState("user@example.com");
    const [wallet, setWallet] = useState(TEST_WALLETS.solanaDevnet);
    const [amount, setAmount] = useState("5");
    const [isLoading, setIsLoading] = useState(false);

    function handleChainChange(newChain: "solanaDevnet" | "baseSepolia" | "stellarTestnet") {
        setChain(newChain);
        setWallet(TEST_WALLETS[newChain]);
    }

    async function handleSubmit() {
        setIsLoading(true);
        try {
            const result = await createOrder({ walletAddress: wallet, receiptEmail: email, amount, chain });
            setOrder({ orderId: result.order.orderId, clientSecret: result.clientSecret });
        } catch (error) {
            console.error("Failed to create order:", error);
        } finally {
            setIsLoading(false);
        }
    }

    if (order != null) {
        return (
            <CrossmintProvider apiKey={CLIENT_API_KEY}>
                <div className="max-w-[450px] w-full mx-auto p-6 rounded-xl bg-white">
                    <CrossmintEmbeddedCheckout
                        orderId={order.orderId}
                        clientSecret={order.clientSecret}
                        payment={{
                            receiptEmail: email,
                            crypto: { enabled: false },
                            fiat: { enabled: true },
                            defaultMethod: "fiat",
                        }}
                    />
                </div>
            </CrossmintProvider>
        );
    }

    return (
        <div className="max-w-md mx-auto p-8 rounded-xl border border-gray-300 bg-white shadow-sm space-y-6">
            <h2 className="text-2xl font-semibold text-gray-900">Buy USDC</h2>

            <div className="space-y-2">
                <label className="text-sm font-medium text-gray-900">Network</label>
                <div className="grid grid-cols-3 gap-2">
                    <button
                        type="button"
                        onClick={() => handleChainChange("solanaDevnet")}
                        className={`p-3 rounded-lg border text-sm font-medium transition-colors ${
                            chain === "solanaDevnet"
                                ? "bg-green-600 text-white border-green-600"
                                : "bg-white text-gray-900 border-gray-300 hover:bg-gray-100"
                        }`}
                    >
                        Solana Devnet
                    </button>
                    <button
                        type="button"
                        onClick={() => handleChainChange("baseSepolia")}
                        className={`p-3 rounded-lg border text-sm font-medium transition-colors ${
                            chain === "baseSepolia"
                                ? "bg-blue-600 text-white border-blue-600"
                                : "bg-white text-gray-900 border-gray-300 hover:bg-gray-100"
                        }`}
                    >
                        Base Sepolia
                    </button>
                    <button
                        type="button"
                        onClick={() => handleChainChange("stellarTestnet")}
                        className={`p-3 rounded-lg border text-sm font-medium transition-colors ${
                            chain === "stellarTestnet"
                                ? "bg-purple-600 text-white border-purple-600"
                                : "bg-white text-gray-900 border-gray-300 hover:bg-gray-100"
                        }`}
                    >
                        Stellar Testnet
                    </button>
                </div>
            </div>

            <div className="space-y-2">
                <label className="text-sm font-medium text-gray-900">Email</label>
                <input
                    type="email"
                    value={email}
                    onChange={(e) => setEmail(e.target.value)}
                    className="w-full px-3 py-2 rounded-lg border border-gray-300 bg-white text-gray-900 text-sm"
                />
            </div>

            <div className="space-y-2">
                <label className="text-sm font-medium text-gray-900">Recipient Wallet</label>
                <input
                    type="text"
                    value={wallet}
                    onChange={(e) => setWallet(e.target.value)}
                    className="w-full px-3 py-2 rounded-lg border border-gray-300 bg-white text-gray-900 text-sm font-mono"
                />
            </div>

            <div className="space-y-2">
                <label className="text-sm font-medium text-gray-900">Amount (USD)</label>
                <input
                    type="number"
                    value={amount}
                    onChange={(e) => setAmount(e.target.value)}
                    className="w-full px-3 py-2 rounded-lg border border-gray-300 bg-white text-gray-900 text-sm"
                />
            </div>

            <button
                onClick={handleSubmit}
                disabled={isLoading || !email || !wallet}
                className="w-full py-3 rounded-lg bg-black text-white font-medium hover:bg-gray-800 disabled:opacity-50 transition-colors"
            >
                {isLoading ? "Creating Order..." : "Continue to Checkout"}
            </button>
        </div>
    );
}
```

## 4. Add the Component to Your Page

Import and render the `OnrampCheckout` component in your page:

```tsx app/page.tsx theme={null}
import OnrampCheckout from "./components/OnrampCheckout";

export default function Home() {
    return (
        <main className="min-h-screen flex items-center justify-center">
            <OnrampCheckout />
        </main>
    );
}
```

That's it! When users fill in their details and click "Continue to Checkout", the server action creates an order and the embedded checkout component handles KYC, payment, and delivery automatically.

<Tip>
  **Testing:** Use the test credit card number `4242 4242 4242 4242` with any future expiration date and any 3-digit CVC.
</Tip>

## 5. Transaction Completion

<Snippet />

## 6. Next Steps

<Snippet />


# React Native
Source: https://docs.crossmint.com/stablecoin-orchestration/onramp/quickstarts/react-native

Allow your mobile users to buy stablecoins with credit cards

<Frame type="simple">
  <img alt="Crossmint Onramp Embedded Checkout Demo" />
</Frame>

<CardGroup>
  <Snippet />

  <Card title="Onramp Embedded Quickstart" icon="github" href="https://github.com/Crossmint/onramp-embedded-quickstart">
    See a full working example.
  </Card>
</CardGroup>

<Snippet />

Crossmint Checkout lets you build a seamless onramp for React Native users to buy stablecoins with a credit card, Apple Pay, or Google Pay.

In this guide, you'll learn how to:

* Create a Crossmint order via an API endpoint
* Use Crossmint's embedded checkout component to handle KYC, payment, and delivery automatically

## Requirements

* React Native 0.60+
* Expo (recommended) or bare React Native CLI
* iOS 13.0+ / Android 5.0+

## 1. Prerequisites

<Steps>
  <Step title="Install the SDK">
    <Snippet />
  </Step>

  <Step title="Create API keys">
    Create a [server-side API key](https://docs.crossmint.com/introduction/platform/api-keys/server-side) with the
    `orders.create` and `orders.read` scopes enabled.

    <br />

    Create a [client-side API key](https://docs.crossmint.com/introduction/platform/api-keys/client-side) for the
    embedded checkout component.
  </Step>

  <Step title="Add environment variables">
    Add environment variables to your `.env`:

    ```sh .env theme={null}
    EXPO_PUBLIC_CROSSMINT_CLIENT_SIDE_API_KEY="_YOUR_CLIENT_API_KEY_"
    ```

    <Note>For Expo projects, use the `EXPO_PUBLIC_` prefix. For bare React Native, configure environment variables according to your setup.</Note>
  </Step>
</Steps>

## 2. Create the API Endpoint

<Note>
  If you want to enable onramp orders to external wallets (EOAs or third-party smart wallets) instead of Crossmint wallets, see the [Onramp to External Wallets](/stablecoin-orchestration/onramp/guides/onramp-to-external-wallets) guide before proceeding.
</Note>

To initiate an onramp, you must first create a purchase order on your backend. This example uses Express, but you can use any backend framework:

```typescript server/createOrder.ts theme={null}
import express from "express";

const app = express();
app.use(express.json());

const USDC_TOKEN_LOCATORS = {
    solanaDevnet: "solana:4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU",
    baseSepolia: "base-sepolia:0x036CbD53842c5426634e7929541eC2318f3dCF7e",
    stellarTestnet: "stellar:CBIELTK6YBZJU5UP2WWQEUCYKLPU6AUNZ2BQ4WWFEIE3USCIHMXQDAMA",
};

app.post("/api/create-order", async (req, res) => {
    const { walletAddress, receiptEmail, amount, chain } = req.body;
    const serverApiKey = process.env.CROSSMINT_SERVER_SIDE_API_KEY;

    if (serverApiKey == null) {
        return res.status(500).json({ error: "Server API key not configured" });
    }

    const response = await fetch("https://staging.crossmint.com/api/2022-06-09/orders", {
        method: "POST",
        headers: {
            "Content-Type": "application/json",
            "x-api-key": serverApiKey,
        },
        body: JSON.stringify({
            lineItems: [
                {
                    tokenLocator: USDC_TOKEN_LOCATORS[chain],
                    executionParameters: {
                        mode: "exact-in",
                        amount,
                    },
                },
            ],
            payment: {
                method: "card",
                receiptEmail,
            },
            recipient: {
                walletAddress,
            },
        }),
    });

    if (!response.ok) {
        const error = await response.json();
        return res.status(response.status).json(error);
    }

    const data = await response.json();
    res.json(data);
});

app.listen(3000);
```

## 3. Build an Onramp checkout UI in your app

Now let's go to your app. Create a React Native screen that handles order creation and displays a checkout:

```tsx screens/OnrampScreen.tsx theme={null}
import { useState } from "react";
import { View, Text, TextInput, TouchableOpacity, StyleSheet, ActivityIndicator } from "react-native";
import { CrossmintProvider, CrossmintEmbeddedCheckout } from "@crossmint/client-sdk-react-native-ui";

const CLIENT_API_KEY = process.env.EXPO_PUBLIC_CROSSMINT_CLIENT_SIDE_API_KEY || "";
const API_URL = "http://localhost:3000"; // Replace with your backend URL

// Destination wallets for testing transfers on each network
const TEST_WALLETS = {
    solanaDevnet: "<destination_wallet_address>",
    baseSepolia: "<destination_wallet_address>",
    stellarTestnet: "<destination_wallet_address>",
};

type Chain = "solanaDevnet" | "baseSepolia" | "stellarTestnet";

export default function OnrampScreen() {
    const [order, setOrder] = useState<{ orderId: string; clientSecret: string } | null>(null);
    const [chain, setChain] = useState<Chain>("solanaDevnet");
    const [email, setEmail] = useState("user@example.com");
    const [wallet, setWallet] = useState(TEST_WALLETS.solanaDevnet);
    const [amount, setAmount] = useState("5");
    const [isLoading, setIsLoading] = useState(false);

    function handleChainChange(newChain: Chain) {
        setChain(newChain);
        setWallet(TEST_WALLETS[newChain]);
    }

    async function handleSubmit() {
        setIsLoading(true);
        try {
            const response = await fetch(`${API_URL}/api/create-order`, {
                method: "POST",
                headers: { "Content-Type": "application/json" },
                body: JSON.stringify({ walletAddress: wallet, receiptEmail: email, amount, chain }),
            });
            if (!response.ok) {
                throw new Error("Failed to create order");
            }
            const result = await response.json();
            setOrder({ orderId: result.order.orderId, clientSecret: result.clientSecret });
        } catch (error) {
            console.error("Failed to create order:", error);
        } finally {
            setIsLoading(false);
        }
    }

    if (order != null) {
        return (
            <CrossmintProvider apiKey={CLIENT_API_KEY}>
                <View style={styles.checkoutContainer}>
                    <CrossmintEmbeddedCheckout
                        orderId={order.orderId}
                        clientSecret={order.clientSecret}
                        payment={{
                            receiptEmail: email,
                            crypto: { enabled: false },
                            fiat: { enabled: true },
                            defaultMethod: "fiat",
                        }}
                    />
                </View>
            </CrossmintProvider>
        );
    }

    return (
        <View style={styles.container}>
            <Text style={styles.title}>Buy USDC</Text>

            <View style={styles.fieldGroup}>
                <Text style={styles.label}>Network</Text>
                <View style={styles.toggleRow}>
                    <TouchableOpacity
                        style={[styles.toggleButton, chain === "solanaDevnet" && styles.toggleButtonActiveSolana]}
                        onPress={() => handleChainChange("solanaDevnet")}
                    >
                        <Text style={[styles.toggleText, chain === "solanaDevnet" && styles.toggleTextActive]}>
                            Solana Devnet
                        </Text>
                    </TouchableOpacity>
                    <TouchableOpacity
                        style={[styles.toggleButton, chain === "baseSepolia" && styles.toggleButtonActiveBase]}
                        onPress={() => handleChainChange("baseSepolia")}
                    >
                        <Text style={[styles.toggleText, chain === "baseSepolia" && styles.toggleTextActive]}>
                            Base Sepolia
                        </Text>
                    </TouchableOpacity>
                    <TouchableOpacity
                        style={[styles.toggleButton, chain === "stellarTestnet" && styles.toggleButtonActiveStellar]}
                        onPress={() => handleChainChange("stellarTestnet")}
                    >
                        <Text style={[styles.toggleText, chain === "stellarTestnet" && styles.toggleTextActive]}>
                            Stellar Testnet
                        </Text>
                    </TouchableOpacity>
                </View>
            </View>

            <View style={styles.fieldGroup}>
                <Text style={styles.label}>Email</Text>
                <TextInput
                    style={styles.input}
                    value={email}
                    onChangeText={setEmail}
                    keyboardType="email-address"
                    autoCapitalize="none"
                />
            </View>

            <View style={styles.fieldGroup}>
                <Text style={styles.label}>Recipient Wallet</Text>
                <TextInput
                    style={[styles.input, styles.monoInput]}
                    value={wallet}
                    onChangeText={setWallet}
                    autoCapitalize="none"
                />
            </View>

            <View style={styles.fieldGroup}>
                <Text style={styles.label}>Amount (USD)</Text>
                <TextInput
                    style={styles.input}
                    value={amount}
                    onChangeText={setAmount}
                    keyboardType="numeric"
                />
            </View>

            <TouchableOpacity
                style={[styles.submitButton, (isLoading || !email || !wallet) && styles.submitButtonDisabled]}
                onPress={handleSubmit}
                disabled={isLoading || !email || !wallet}
            >
                {isLoading ? (
                    <ActivityIndicator color="#fff" />
                ) : (
                    <Text style={styles.submitButtonText}>Continue to Checkout</Text>
                )}
            </TouchableOpacity>
        </View>
    );
}

const styles = StyleSheet.create({
    container: {
        flex: 1,
        padding: 24,
        backgroundColor: "#fff",
    },
    checkoutContainer: {
        flex: 1,
        backgroundColor: "#fff",
    },
    title: {
        fontSize: 24,
        fontWeight: "600",
        color: "#111",
        marginBottom: 24,
    },
    fieldGroup: {
        marginBottom: 20,
    },
    label: {
        fontSize: 14,
        fontWeight: "500",
        color: "#111",
        marginBottom: 8,
    },
    toggleRow: {
        flexDirection: "row",
        gap: 8,
    },
    toggleButton: {
        flex: 1,
        padding: 12,
        borderRadius: 8,
        borderWidth: 1,
        borderColor: "#d1d5db",
        backgroundColor: "#fff",
        alignItems: "center",
    },
    toggleButtonActiveSolana: {
        backgroundColor: "#16a34a",
        borderColor: "#16a34a",
    },
    toggleButtonActiveBase: {
        backgroundColor: "#2563eb",
        borderColor: "#2563eb",
    },
    toggleButtonActiveStellar: {
        backgroundColor: "#9333ea",
        borderColor: "#9333ea",
    },
    toggleText: {
        fontSize: 14,
        fontWeight: "500",
        color: "#111",
    },
    toggleTextActive: {
        color: "#fff",
    },
    input: {
        borderWidth: 1,
        borderColor: "#d1d5db",
        borderRadius: 8,
        padding: 12,
        fontSize: 14,
        color: "#111",
        backgroundColor: "#fff",
    },
    monoInput: {
        fontFamily: "monospace",
    },
    submitButton: {
        backgroundColor: "#000",
        padding: 16,
        borderRadius: 8,
        alignItems: "center",
        marginTop: 8,
    },
    submitButtonDisabled: {
        opacity: 0.5,
    },
    submitButtonText: {
        color: "#fff",
        fontSize: 16,
        fontWeight: "500",
    },
});
```

## 4. Add the Screen to Your App

Import and render the `OnrampScreen` in your app:

```tsx App.tsx theme={null}
import { SafeAreaView, StyleSheet } from "react-native";
import OnrampScreen from "./screens/OnrampScreen";

export default function App() {
    return (
        <SafeAreaView style={styles.container}>
            <OnrampScreen />
        </SafeAreaView>
    );
}

const styles = StyleSheet.create({
    container: {
        flex: 1,
        backgroundColor: "#fff",
    },
});
```

That's it! When users fill in their details and tap "Continue to Checkout", the API creates an order and the embedded checkout component handles KYC, payment, and delivery automatically.

<Tip>
  **Testing:** Use the test credit card number `4242 4242 4242 4242` with any future expiration date and any 3-digit CVC.
</Tip>

## 5. Transaction Completion

<Snippet />

## 6. Next Steps

<Snippet />


# Swift
Source: https://docs.crossmint.com/stablecoin-orchestration/onramp/quickstarts/swift

Allow your iOS users to buy stablecoins with credit cards and Apple Pay

<Note>
  The Swift SDK is currently in **Beta**.
</Note>

In this guide, you'll learn how to:

* Install the Swift SDK
* Create an Onramp order for your authenticated users
* Use the embedded checkout component to handle KYC, payment, and delivery

<Frame type="simple">
  <img alt="Crossmint Onramp Embedded Checkout Demo" />
</Frame>

<CardGroup>
  <Snippet />

  <Card title="Swift SDK on GitHub" icon="github" href="https://github.com/Crossmint/crossmint-checkout-swift">
    View the open source Swift Checkout SDK repository.
  </Card>
</CardGroup>

<Snippet />

## Requirements

* **iOS 14.0+**
* **SwiftUI** framework
* Xcode 13.0 or later

## 1. Installation

Install the Crossmint Swift SDK using Swift Package Manager.

<Steps>
  <Step title="Add Package Dependency">
    In Xcode, go to **File > Add Package Dependencies** and add:

    ```
    https://github.com/Crossmint/crossmint-checkout-swift
    ```

    Select the `CrossmintCheckout` product for your target.
  </Step>

  <Step title="Create API key">
    Create a [server-side API key](https://docs.crossmint.com/introduction/platform/api-keys/server-side) with the
    `orders.create` and `orders.read` scopes enabled. In staging, all scopes are included in your API key.
  </Step>
</Steps>

## 2. Create Order

<Note>
  If you want to enable onramp orders to external wallets (EOAs or third-party smart wallets) instead of Crossmint wallets, see the [Onramp to External Wallets](/stablecoin-orchestration/onramp/guides/onramp-to-external-wallets) guide before proceeding.
</Note>

Use the [Create Order API](/api-reference/headless/create-order) to initiate the purchase process from your backend.

<Snippet />

## 3. Use Component

Once you have the order response with `orderId` and `clientSecret`, use Crossmint's embedded checkout component in your SwiftUI view.

The component supports **native Apple Pay** for a seamless iOS payment experience.

```swift theme={null}
import SwiftUI
import CrossmintCheckout

struct ContentView: View {
    var body: some View {
        CrossmintEmbeddedCheckout(
            orderId: <your_order_id>,
            clientSecret: <your_client_secret>,
            payment: CheckoutPayment(
                crypto: CheckoutCryptoPayment(enabled: false),
                fiat: CheckoutFiatPayment(
                    enabled: true,
                    allowedMethods: CheckoutAllowedMethods(
                        googlePay: false,
                        applePay: true,  // Native Apple Pay support
                        card: true
                    )
                )
            ),
            appearance: CheckoutAppearance(
                rules: CheckoutAppearanceRules(
                    destinationInput: CheckoutDestinationInputRule(display: "hidden"),
                    receiptEmailInput: CheckoutReceiptEmailInputRule(display: "hidden")
                )
            )
        )
    }
}
```

### Key Features

* **Native Apple Pay**: Smooth integration with iOS payment system
* **SwiftUI Components**: Modern declarative UI framework
* **Automatic KYC**: Handles verification flow automatically
* **Customizable Appearance**: Control visibility of UI elements

## 4. Track Order

<Snippet />

## 5. Transaction Completion

<Snippet />

## 6. Next Steps

<Snippet />

* View the <a href="https://github.com/Crossmint/crossmint-checkout-swift">Swift Checkout SDK source code</a> on GitHub


# Overview
Source: https://docs.crossmint.com/stablecoin-orchestration/overview

Introduction to Stablecoin Orchestration

Stablecoin Orchestration is Crossmint's unified infrastructure to fund, convert, and move stablecoins globally - instantly and compliantly.

With it, you can design complete money-movement flows end to end: from on-ramping users or treasuries, to managing your stablecoin treasury with programmable controls, to enabling regulated transfers with built-in compliance.

## Core Products

| Product                                                                       | Description                                                                                                                                                                                   | Recommended For                                                                                                           |
| :---------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------ |
| [Onramp](/stablecoin-orchestration/onramp/overview)                           | Enable users to buy stablecoins with credit cards or personal bank accounts. Crossmint handles payment processing, chargeback protection, and KYC compliance.                                 | Companies building consumer-facing products (wallets, fintech apps, marketplaces) where users need to fund their wallets. |
| [Treasury Wallet](/stablecoin-orchestration/treasury-wallet/overview)         | Programmable wallets with enterprise-grade security for managing your stablecoin holdings. Features include multi-sig controls and cross-chain liquidity management.                          | Businesses managing significant stablecoin reserves who need secure, automated treasury operations.                       |
| [Regulated Transfers](/stablecoin-orchestration/regulated-transfers/overview) | APIs to send and receive stablecoins globally with built-in compliance, AML screening, sanctions checks, and travel-rule compliance. Crossmint manages licensing and regulatory requirements. | Fintechs, payroll platforms, and remittance companies requiring compliant money movement.                                 |

## Learn More

<CardGroup>
  <Card title="Onramp" icon="arrow-up-right" href="/stablecoin-orchestration/onramp/overview">
    Fully managed on-ramp for wallet funding
  </Card>

  <Card title="Treasury Wallet" icon="vault" href="/stablecoin-orchestration/treasury-wallet/overview">
    Programmable wallets for managing stablecoin reserves
  </Card>

  <Card title="Regulated Transfers" icon="shield-check" href="/stablecoin-orchestration/regulated-transfers/overview">
    Compliant global money movement with built-in compliance
  </Card>
</CardGroup>


# Register User Data
Source: https://docs.crossmint.com/stablecoin-orchestration/regulated-transfers/guides/register-user-data

Provide personal information about recipients in order to comply with regulation

Register the transfer recipient as a user in your Crossmint project, then attach the recipient data required for regulated transfers.
Crossmint uses this data to screen recipients against Office of Foreign Assets Control (OFAC) sanctions lists.

## Requirements

* An API key
* A stable user identifier in your system (used as `userLocator`)
* A Crossmint wallet address for the recipient (or the ability to create one)

## Step 1: Create a User

Register the transfer recipient as a user in your Crossmint project and associate the user with a Crossmint wallet address.

There are two ways to create a user:

### Choose a Method

* Use Method 1 if you create the wallet and user in one API call
* Use Method 2 if you register the user first and create the wallet later

<AccordionGroup>
  <Accordion title="Method 1: On Wallet Creation" icon="wallet">
    Create a wallet for a user and associate it to a `userLocator` by setting the `owner` property. This method creates in a
    single API call both the wallet, and the user associated with it.

    The `owner` property accepts a `userLocator`. This associates the wallet with the user identifier in your system.

    <Snippet />

    <Tabs>
      <Tab title="REST">
        ```javascript theme={null}
        const userLocator = "userId:johnd-123";

        const options = {
            method: 'POST',
            headers: {'X-API-KEY': '<x-api-key>', 'Content-Type': 'application/json'},
            body: JSON.stringify({
                chainType: "evm",
                config: {
                    adminSigner: {
                        type: "email",
                        email: "johnd@example.com"
                    }
                },
                owner: userLocator
            })
        };

        fetch('https://staging.crossmint.com/api/2025-06-09/wallets', options)
            .then(response => response.json())
            .then(response => console.log(response))
            .catch(err => console.error(err));
        ```
      </Tab>

      <Tab title="React">
        ```javascript theme={null}
        import { useWallet } from '@crossmint/client-sdk-react-ui';

        const { getOrCreateWallet } = useWallet();

        // The "owner" property is inferred by the JWT token, no need to specify it
        const wallet = await getOrCreateWallet({
            chain: "evm",
            signer: {
                type: "email",
                email: "johnd@example.com"
            }
        });
        ```
      </Tab>
    </Tabs>
  </Accordion>

  <Accordion title="Method 2: Register User First, Create Wallet Later" icon="user-plus">
    Register a user with Crossmint without creating a wallet yet. Later, when you create a wallet for that registered user,
    you can link the wallet's `owner` property to that user's registered `userLocator` value. This will associate the wallet with the user identifier in your system.

    <Snippet />

    **Step 1: Register the user**

    ```javascript theme={null}
    const userLocator = "userId:johnd-123";

    const options = {
        method: 'PUT',
        headers: {'X-API-KEY': '<x-api-key>', 'Content-Type': 'application/json'}
    };

    fetch(`https://staging.crossmint.com/api/2025-06-09/users/${userLocator}`, options)
        .then(response => response.json())
        .then(response => console.log(response))
        .catch(err => console.error(err));
    ```

    **Step 2: Create wallet and link to registered user**

    When you are ready to create a wallet for the registered user, use the same `userLocator` in the `owner` field:

    <Tabs>
      <Tab title="REST">
        ```javascript theme={null}
        const userLocator = "userId:johnd-123";

        const options = {
            method: 'POST',
            headers: {'X-API-KEY': '<x-api-key>', 'Content-Type': 'application/json'},
            body: JSON.stringify({
                chainType: "evm",
                config: {
                    adminSigner: {
                        type: "email",
                        email: "johnd@example.com"
                    }
                },
                owner: userLocator
            })
        };

        fetch('https://staging.crossmint.com/api/2025-06-09/wallets', options)
            .then(response => response.json())
            .then(response => console.log(response))
            .catch(err => console.error(err));
        ```
      </Tab>

      <Tab title="React">
        ```javascript theme={null}
        import { useWallet } from '@crossmint/client-sdk-react-ui';

        const { getOrCreateWallet } = useWallet(); 

        // The "owner" property is inferred by the JWT token, no need to specify it
        const wallet = await getOrCreateWallet({
            chain: "evm",
            signer: {
                type: "email",
                email: "johnd@example.com"
            }
        });
        ```
      </Tab>
    </Tabs>
  </Accordion>
</AccordionGroup>

## Step 2: Register User Data

Use the [Create User API](/api-reference/users/upsert-user) to attach `userDetails` to the user.
To see data requirements by activity and region, see [Data Requirements](/stablecoin-orchestration/users-compliance/data-requirements).
For regulated transfers, the only information needed is `userDetails`.

<CodeGroup>
  ```javascript REST theme={null}

  const userLocator = "userId:johnd-123";

  const options = {
     method: 'PUT',
     headers: {'X-API-KEY': '<x-api-key>', 'Content-Type': 'application/json'},
     body: JSON.stringify({
         userDetails: {
             firstName: "John",
             lastName: "Doe",
             dateOfBirth: "2007-01-01",
             countryOfResidence: "DE"
         }
     })
  };

  fetch(`https://staging.crossmint.com/api/2025-06-09/users/${userLocator}/`, options)
     .then(response => response.json())
     .then(response => console.log(response))
     .catch(err => console.error(err));
  ```
</CodeGroup>

## Next Steps

<CardGroup>
  <Card title="Execute Transfers" icon="arrow-right-arrow-left" href="/stablecoin-orchestration/regulated-transfers/guides/transfers">
    Learn how to execute regulated transfers and handle compliance errors
  </Card>

  <Card title="Quickstart" icon="bolt" href="/stablecoin-orchestration/regulated-transfers/quickstart">
    Get started with regulated transfers in minutes
  </Card>
</CardGroup>


# Making a Transfer
Source: https://docs.crossmint.com/stablecoin-orchestration/regulated-transfers/guides/transfers

Execute compliant regulated transfers and handle compliance errors

The [Transfer Token API](/api-reference/wallets/transfer-token) enables you to trigger regulated transfers from your treasury wallet to user wallets. The API automatically performs compliance checks and will return specific errors if the recipient has not provided the appropriate information or didn't pass the necessary compliance checks.

<CodeGroup>
  ```typescript Node.js theme={null}
  import { CrossmintWallets, createCrossmint } from "@crossmint/wallets-sdk";

  const crossmint = createCrossmint({
     apiKey: "<your-server-api-key>",
  });

  const crossmintWallets = CrossmintWallets.from(crossmint);

  const treasuryLocator = "<your-treasury-wallet-locator>" 

  const treasuryWallet = await crossmintWallets.getWallet(treasuryLocator, {
     chain: "base-sepolia",
     signer: {type: "api-key"},
  });

  try {
     const { hash, explorerLink } = await treasuryWallet.send(
         "<recipient-wallet-address>",
         "usdc",
         "100",
         { transactionType: "regulated-transfer" }
     );
     
     console.log(`Transfer successful: ${hash}`);
     console.log(`Explorer: ${explorerLink}`);
  } catch (error) {
     console.error("Transfer failed:", error.message);
     // Handle compliance errors - see error codes below
  }
  ```

  ```js REST theme={null}
  const treasuryLocator = "<your-treasury-wallet-locator>";
  const tokenLocator = "base-sepolia:usdc";

  const options = {
      method: 'POST',
      headers: {'X-API-KEY': '<x-api-key>', 'Content-Type': 'application/json'},
      body: JSON.stringify({
          recipient: "<recipient-wallet-address>",
          amount: "100"
      })
  };

  try {
      const response = await fetch(`https://staging.crossmint.com/api/2025-06-09/wallets/${treasuryLocator}/token/${tokenLocator}/transfers`, options);
      const data = await response.json();
      console.log(data);
  } catch (error) {
      console.error(error);
  }
  ```

  ```bash cURL theme={null}
  curl --request POST \
      --url 'https://staging.crossmint.com/api/2025-06-09/wallets/evm:smart:alias:treasury/tokens/base-sepolia:usdc/transfers' \
      --header 'X-API-KEY: <x-api-key>' \
      --header 'Content-Type: application/json' \
      --data '{
          "recipient": "recipient-wallet-address",
          "amount": "100"
      }'
  ```
</CodeGroup>

Wallet locator options for a treasury wallet:

* `<walletAddress>` (e.g., `0x1234...5678`)
* `chainType[:<walletType>]:alias:<alias>` (e.g., `evm:smart:alias:treasury`)

## Compliance Errors

If a transfer fails compliance checks, the API will return an error with a specific reason code. Here are the potential compliance-related errors:

<AccordionGroup>
  <Accordion title="recipient_personal_data_missing" icon="user-xmark">
    **Error Message:** "Required personal data is missing to complete regulated transfer"

    **Description:** The recipient wallet has not provided all personal data required for compliance screening. The recipient must complete their profile with first name, last name, date of birth, and country of residence.

    **Resolution:** Ensure the recipient has attached their personal data using the [user onboarding API](/stablecoin-orchestration/regulated-transfers/guides/register-user-data#step-2-register-user-data).

    <Expandable title="How to test">
      In staging, send a transfer to any user wallet that has not had [personal data registered](/stablecoin-orchestration/regulated-transfers/guides/register-user-data#step-2-register-user-data).
    </Expandable>

    ```javascript theme={null}
    // Example error response
    {
        "error": {
            "reason": "recipient_personal_data_missing",
            "message": "Required personal data is missing to complete regulated transfer"
        }
    }
    ```
  </Accordion>

  <Accordion title="recipient_wallet_sanctioned" icon="shield-xmark">
    **Error Message:** "Recipient wallet address is sanctioned and can't receive assets"

    **Description:** The recipient's wallet address failed Elliptic sanctions screening. This indicates the address has been flagged in sanctions lists or is associated with prohibited activities.

    **Resolution:** The transfer cannot proceed. The recipient's wallet address has been identified as high-risk and is blocked from receiving regulated transfers.

    <Expandable title="How to test">
      In staging, you can trigger a sanctions error by using the following special addresses across different chains as the recipient:

      * EVM: `0xc9b888e8f2c9c60f72f84e97e4416c3aca3e1f7c`
      * Solana: `7H7Dph61J9W9WzvRUQbM1tsPJpEQhaQ3GVxPSj1EnSuw`
      * Stellar: `G5CLUPQPRWQXKHASBYSYMIPHE2ZMIFLMEH3ROBTOQMR24YWQIFQW2RY5`
    </Expandable>

    ```javascript theme={null}
    // Example error response
    {
        "error": {
            "reason": "recipient_wallet_sanctioned",
            "message": "Recipient wallet address is sanctioned and can't receive assets"
        }
    }
    ```
  </Accordion>

  <Accordion title="recipient_person_sanctioned" icon="user-shield">
    **Error Message:** "Recipient user is sanctioned and can't receive assets"

    **Description:** The recipient's personal information failed sanctions and PEP (Politically Exposed Person) screening. This indicates the individual is on a sanctions list or is a politically exposed person subject to enhanced due diligence.

    **Resolution:** The transfer cannot proceed. The recipient has been identified as high-risk based on their personal information and is blocked from receiving regulated transfers.

    <Expandable title="How to test">
      In staging, if you create a user profile with the name "Sanctioned User Name", Crossmint will consider them sanctioned. You can use this for testing.

      To trigger this error, [create a user](/stablecoin-orchestration/regulated-transfers/guides/register-user-data#step-2-register-user-data) with the following data:

      ```json theme={null}
      {
          "personalData": {
              "firstName": "Sanctioned User Name",
              // ... any value for other required fields
          }
      }
      ```

      Then attempt a regulated transfer to that user's wallet.
    </Expandable>

    ```javascript theme={null}
    // Example error response
    {
        "error": {
            "reason": "recipient_person_sanctioned",
            "message": "Recipient user is sanctioned and can't receive assets"
        }
    }
    ```
  </Accordion>

  <Accordion title="recipient_type_unsupported" icon="circle-xmark">
    **Error Message:** "Currently, regulated transfers can only be sent to Crossmint-managed wallets."

    **Description:** The destination address is an external wallet, not a Crossmint-managed wallet. Regulated transfers currently only support transfers between Crossmint treasury wallets and Crossmint user wallets.

    **Resolution:** Ensure the recipient has a Crossmint wallet. External wallet addresses are not supported for regulated transfers.

    <Info>
      External wallet recipients are not currently supported. Contact [support](https://www.crossmint.com/contact/sales) for more information.
    </Info>

    ```javascript theme={null}
    // Example error response
    {
        "error": {
            "reason": "recipient_type_unsupported",
            "message": "Currently, regulated transfers can only be sent to Crossmint-managed wallets."
        }
    }
    ```
  </Accordion>
</AccordionGroup>

## Error Handling Best Practices

When implementing regulated transfers, follow these best practices for error handling:

<Steps>
  <Step title="Validate recipient before transfer">
    Before initiating a transfer, verify that the recipient has completed their onboarding and provided all required personal data. This can help prevent `recipient_personal_data_missing` errors.
  </Step>

  <Step title="Implement retry logic for transient errors">
    Some errors may be transient (e.g., temporary API issues). Implement appropriate retry logic with exponential backoff for non-compliance errors.
  </Step>

  <Step title="Log compliance failures">
    Log all compliance-related errors for audit purposes. These logs are important for regulatory reporting and investigating failed transfers.
  </Step>

  <Step title="Notify users of compliance issues">
    When a transfer fails due to compliance issues, notify the affected users with clear instructions on how to resolve the issue (e.g., completing their profile, contacting support).
  </Step>
</Steps>

## Supported Transfer Types

<Note>
  Compliant regulated transfers currently work for transfers between **Crossmint treasury wallets** and **Crossmint user wallets**. Transfers to external wallets are not supported.
</Note>

## Additional Resources

<CardGroup>
  <Card title="API Reference" icon="terminal" href="/api-reference/wallets/transfer-token">
    Deep dive into the transfer API reference
  </Card>

  <Card title="Talk to an expert" icon="message" href="https://www.crossmint.com/contact/sales">
    Contact the Crossmint sales team for support
  </Card>
</CardGroup>


# Overview
Source: https://docs.crossmint.com/stablecoin-orchestration/regulated-transfers/overview

Compliant global money movement with built-in regulatory compliance

Crossmint's Regulated Transfers enable compliant movement of stablecoins without requiring you to get a license or
deal with regulatory hurdles. Simply call a single API to make transfers, and Crossmint takes care of licensing, AML
screening, sanctions checks, and travel-rule compliance automatically, so you can focus on your core operations.

**Key Features**

* **Built-in Compliance**: Automated AML screening, sanctions checks, and KYC verification for every transaction.
* **Travel Rule Compliance**: Automatic IVMS101 data exchange with counterparties.
* **Real-time Screening**: Instant verification against global sanctions lists and PEP databases.
* **Audit Trail**: Complete transaction records for regulatory reporting and audits.

## When Do You Need Regulated Transfers?

Not all payments require regulated transfers. Understanding when compliance is required helps you choose the right approach:

<AccordionGroup>
  <Accordion title="Unregulated Transfers (Standard Wallet Transfers)" icon="arrow-right-arrow-left">
    Transfers between your own treasury wallets are **unregulated** and work like standard crypto transfers.

    **Use cases:**

    * Moving funds between treasury wallets on different chains
    * Rebalancing liquidity across your treasury positions
    * Internal fund management and allocation

    **Compliance requirements:**

    * **No compliance checks required**

    These transfers can be made using standard [wallet transfer APIs](/wallets/guides/transfer-tokens).
  </Accordion>

  <Accordion title="Regulated Transfers: Payouts to Customers" icon="users">
    Payouts to your customers require **full compliance** with travel rule requirements and comprehensive compliance checks.

    **Use cases:**

    * Customer refunds
    * Reward payouts
    * Loyalty program disbursements
    * Customer-facing payment operations

    **Compliance requirements:**

    * **Travel Rule Compliance**: Automatic IVMS101 data exchange with counterparties
    * **Sanctions Checks**: Real-time screening against global sanctions lists
    * **AML Screening**: Automated anti-money laundering checks
    * **KYC Verification**: Identity verification for both parties
  </Accordion>

  <Accordion title="Regulated Transfers: Payouts to External Third Parties (Vendors)" icon="building">
    Payouts to external third parties such as vendors, suppliers, or service providers require **sanctions checks** with lighter compliance requirements compared to customer payouts.

    **Use cases:**

    * Vendor payments
    * Supplier disbursements
    * Service provider payments
    * B2B transactions

    **Compliance requirements:**

    * **Sanctions Checks**: Real-time screening against global sanctions lists
  </Accordion>
</AccordionGroup>

For more details on payment types, see the [Making Payments guide](/stablecoin-orchestration/treasury-wallet/guides/making-payments).

## Use Cases

<AccordionGroup>
  <Accordion title="Cross-Border Remittances" icon="money-bill-transfer">
    Enable instant, compliant remittance flows across borders with automated regulatory compliance.

    * **Instant settlement**: Send cross-border payments in seconds, not days.
    * **Automatic compliance**: KYC, AML, and travel rule requirements handled automatically.
    * **Cost effective**: Significantly lower fees compared to traditional remittance corridors.
  </Accordion>

  <Accordion title="Business Payments" icon="building">
    Send payments to suppliers, partners, and service providers globally with full compliance.

    * **B2B transactions**: High-value business payments with appropriate compliance controls.
    * **Invoice matching**: Link payments to invoices for reconciliation and audit trails.
    * **Multi-currency**: Support for payments in multiple fiat and stablecoin currencies.
    * **Batch processing**: Execute multiple compliant payments efficiently.
  </Accordion>

  <Accordion title="Payroll & Contractor Payments" icon="wallet">
    Pay employees and contractors worldwide while maintaining compliance with local regulations.

    * **Global payroll**: Distribute salaries to team members across borders.
    * **Contractor payments**: Pay freelancers and contractors in their preferred currency.
    * **Tax compliance**: Integration points for tax reporting and withholding.
    * **Recurring payments**: Set up automated, compliant recurring disbursements.
  </Accordion>

  <Accordion title="Marketplace Settlements" icon="store">
    Enable compliant seller payouts and marketplace settlements with automatic compliance checks.

    * **Seller verification**: Automated KYB checks for marketplace vendors.
    * **Payout automation**: Schedule or trigger compliant payouts based on business rules.
    * **Split payments**: Distribute proceeds to multiple parties with compliance coverage.
    * **Dispute handling**: Full transaction history for dispute resolution.
  </Accordion>
</AccordionGroup>

## Why Crossmint Regulated Transfers

<CardGroup>
  <Card title="Compliance Automated" icon="shield-check">
    AML, sanctions, KYC, and travel rule compliance handled automatically.
  </Card>

  <Card title="Licensed Infrastructure" icon="scale-balanced">
    Operate under Crossmint's regulatory licenses across multiple jurisdictions.
  </Card>

  <Card title="Instant Settlement" icon="bolt">
    Stablecoin transfers settle in seconds with full compliance coverage.
  </Card>

  <Card title="Audit Ready" icon="clipboard-list">
    Complete audit trails and regulatory reporting built-in.
  </Card>
</CardGroup>

## How It Works

### 1. Initiate Transfer

Create a transfer request with sender and recipient details. Crossmint validates all required information.

### 2. Compliance Screening

Automated compliance checks run in real-time:

* **Identity Verification**: Confirm KYC/KYB status of both parties
* **AML Screening**: Check against global watchlists and sanctions lists
* **Risk Assessment**: Evaluate transaction risk based on multiple factors
* **Travel Rule**: Exchange IVMS101 data with counterparty VASPs if required

### 3. Approval & Execution

Once compliance clears, the transfer is approved and executed:

* Stablecoin transfer settles on-chain instantly
* All compliance data is recorded and stored
* If compliance checks fail, the transaction doesn't go through

## Get Started

<CardGroup>
  <Card title="Quickstart ⚡" icon="bolt" href="/stablecoin-orchestration/regulated-transfers/quickstart">
    Get started with regulated transfers in minutes
  </Card>
</CardGroup>


# Quickstart ⚡
Source: https://docs.crossmint.com/stablecoin-orchestration/regulated-transfers/quickstart

Send regulated transfers from your treasury wallet

<CardGroup>
  <Snippet />
</CardGroup>

<Snippet />

Crossmint's Regulated Transfers enable you to send compliant stablecoin transfers from your treasury wallet, using the [Transfer Token API](/api-reference/wallets/transfer-token). Crossmint automatically handles compliance so if the transfer doesn't meet regulatory requirements, the call will fail.

<Steps>
  <Step title="Install the SDK">
    Run the following command to install the SDK:

    <Snippet />
  </Step>

  <Step title="Get your treasury wallet">
    Retrieve your treasury wallet using the alias:

    ```tsx index.ts theme={null}
    import { CrossmintWallets, createCrossmint } from "@crossmint/wallets-sdk";

    const crossmint = createCrossmint({
        apiKey: "<your-server-api-key>",
    });

    const crossmintWallets = CrossmintWallets.from(crossmint);

    const treasuryLocator = "evm:smart:alias:treasury" // your treasury wallet alias

    const treasuryWallet = await crossmintWallets.getWallet(treasuryLocator, {
        chain: "base-sepolia",
        signer: {type: "api-key"},
    });
    ```

    <Note> Create a treasury wallet if you don't have one already [here](/stablecoin-orchestration/treasury-wallet/quickstart). </Note>
  </Step>

  <Step title="Create recipient wallet">
    Create a wallet for the recipient to receive funds in:

    ```tsx index.ts theme={null}
    const userLocator = "userId:johnd-123";

    const wallet = await crossmintWallets.createWallet({
        chainType: "evm",
        signer: {
            type: "email",
            email: "johnd@example.com"
        },
        owner: userLocator
    });

    console.log(wallet.address);
    ```
  </Step>

  <Step title="Register recipient as user">
    Register the recipient as a user with Crossmint and provide the required user details to facilitate a compliant money transfer:

    ```javascript theme={null}
    const userLocator = "userId:johnd-123";

    const options = {
       method: 'PUT',
       headers: {'X-API-KEY': '<x-api-key>', 'Content-Type': 'application/json'},
       body: JSON.stringify({
           userDetails: {
               firstName: "John",
               lastName: "Doe",
               dateOfBirth: "1995-01-01",
               countryOfResidence: "DE"
           }
       })
    };

    fetch(`https://staging.crossmint.com/api/2025-06-09/users/${userLocator}/`, options)
       .then(response => response.json())
       .then(response => console.log(response))
       .catch(err => console.error(err));
    ```
  </Step>

  <Step title="Send regulated transfer">
    Send a transfer from your treasury wallet. The API will automatically check compliance requirements. If the transfer doesn't meet regulatory requirements (e.g., missing KYC/KYB, sanctions issues, travel rule violations), the call will fail with an error.

    ```tsx index.ts theme={null}
    try {
        const { hash, explorerLink } = await treasuryWallet.send(
            userLocator,
            "usdc",
            "100"
        );
        
        console.log(`Transfer successful: ${hash}`);
        console.log(`Explorer: ${explorerLink}`);
    } catch (error) {
        // The transfer will fail if compliance requirements aren't met
        // Common reasons: missing KYC/KYB, sanctions checks, travel rule violations
        console.error("Transfer failed:", error.message);
    }
    ```

    <Note> The transfer API automatically performs compliance checks. If the transfer fails due to compliance issues, you'll receive an error message indicating what requirements weren't met.</Note>
  </Step>
</Steps>

## Compliance Requirements

Transfers will fail if they don't meet regulatory requirements:

* **AML Screening**: Automatic screening against sanctions lists and watchlists
* **Travel Rule Compliance**: Required data exchange for cross-border transfers
* **Transaction Limits**: Adherence to regulatory thresholds and limits

If a transfer fails, check the error message for specific compliance requirements that need to be addressed.

## Launching in Production

For production, the steps are almost identical, but some changes are required:

1. Create a developer account on the [production console](https://www.crossmint.com/console)
2. Create a production server API key on the [API Keys](https://www.crossmint.com/console/projects/apiKeys) page with the API scopes `wallets.read`, `wallets:transactions.create`, `wallets:transactions.sign`
3. Replace your test API key with the production key
4. Ensure all compliance requirements are configured for your production environment

## Learn More

<CardGroup>
  <Card title="Regulated Transfers Overview" icon="shield-check" href="/stablecoin-orchestration/regulated-transfers/overview">
    Learn more about regulated transfers and compliance features.
  </Card>

  <Card title="Transfer Tokens Guide" icon="coins" href="/wallets/guides/transfer-tokens">
    Detailed guide on transferring tokens between wallets.
  </Card>

  <Card title="Treasury Wallet" icon="vault" href="/stablecoin-orchestration/treasury-wallet/overview">
    Learn about managing your treasury wallet.
  </Card>
</CardGroup>

## Other Links

<CardGroup>
  <Card title="API Reference" icon="terminal" href="/api-reference/wallets/transfer-token">
    Deep dive into API reference docs.
  </Card>

  <Card title="Talk to an expert" icon="message" href="https://www.crossmint.com/contact/sales">
    Contact the Crossmint sales team for support.
  </Card>
</CardGroup>


# Funding
Source: https://docs.crossmint.com/stablecoin-orchestration/treasury-wallet/guides/funding-the-wallet

Learn how to fund your treasury wallet in staging and production

There are different ways to fund your treasury wallet depending on whether you're working in staging/development or
production.

## Staging / Development

In staging and development environments, you have two options for funding your treasury wallet:

### Using a Faucet

You can use a faucet like [Circle's USDC faucet](https://faucet.circle.com/) to get test tokens for your wallet. Simply
send the tokens directly to your wallet address.

### Using the Fund Wallet API

<Note>This endpoint is only available in **staging** and only supports USDXM.</Note>

You can use the Fund Wallet API to automatically fund your wallet with test tokens:

<CodeGroup>
  ```js Node.js theme={null}
  const url = `https://staging.crossmint.com/api/v1-alpha2/wallets/${walletLocator}/balances`;
  const options = {
      method: 'POST',
      headers: {
          'X-API-KEY': '<x-api-key>',
          'Content-Type': 'application/json'
      },
      body: JSON.stringify({
          amount: 10,
          token: 'usdxm',
          chain: 'base-sepolia'
      })
  };

  try {
      const response = await fetch(url, options);
      const data = await response.json();
      console.log(data);
  } catch (error) {
      console.error(error);
  }
  ```

  ```python Python theme={null}
  import requests

  url = f"https://staging.crossmint.com/api/v1-alpha2/wallets/{walletLocator}/balances"

  payload = {
      "amount": 10,
      "token": "usdxm",
      "chain": "base-sepolia"
  }
  headers = {
      "X-API-KEY": "<x-api-key>",
      "Content-Type": "application/json"
  }

  response = requests.post(url, json=payload, headers=headers)

  print(response.json())
  ```

  ```bash cURL theme={null}
  curl --request POST \
      --url 'https://staging.crossmint.com/api/v1-alpha2/wallets/{walletLocator}/balances' \
      --header 'X-API-KEY: <x-api-key>' \
      --header 'Content-Type: application/json' \
      --data '{
          "amount": 10,
          "token": "usdxm",
          "chain": "base-sepolia"
      }'
  ```
</CodeGroup>

See the [API reference](/api-reference/wallets/fund-wallet) for more details.

## Production

In production, you have two methods for funding your treasury wallet:

### Making a Stablecoin Transfer

Treasury wallets work like any other wallet and can receive funds through standard blockchain transfers.

<Warning>
  **Important:** Treasury wallets are like any other wallet and can receive funds normally. However, please:

  * **Double-check the address**, especially the address casing (some chains are case-sensitive)
  * **Recommend sending a small test transfer first** to verify the address is correct before sending larger amounts
</Warning>

**Verify the balance** using the Get Balance endpoint:

<Tabs>
  <Tab title="Node.js">
    ```typescript theme={null}
    const treasuryWallet = await wallets.getWallet(walletLocator, {
    	chain: "base-sepolia",
    	signer: {type: "api-key"},
    });

    const balances = await treasuryWallet.balances(["usdc"]);
    ```
  </Tab>

  <Tab title="REST">
    <CodeGroup>
      ```bash cURL theme={null}
      curl --request GET \
          --url 'https://www.crossmint.com/api/2025-06-09/wallets/{walletLocator}/balances?tokens=usdc' \
          --header 'X-API-KEY: <x-api-key>'
      ```

      ```js Node.js theme={null}
      const url = 'https://www.crossmint.com/api/2025-06-09/wallets/{walletLocator}/balances?tokens=usdc';
      const options = {
          method: 'GET',
          headers: {'X-API-KEY': '<x-api-key>'}
      };

      try {
          const response = await fetch(url, options);
          const data = await response.json();
          console.log(data);
      } catch (error) {
          console.error(error);
      }
      ```

      ```python Python theme={null}
      import requests

      url = "https://www.crossmint.com/api/2025-06-09/wallets/{walletLocator}/balances"

      querystring = {"tokens": "usdc"}

      headers = {"X-API-KEY": "<x-api-key>"}

      response = requests.get(url, params=querystring, headers=headers)

      print(response.json())
      ```
    </CodeGroup>

    See the [API reference](/api-reference/wallets/get-wallet-balance) for more details.
  </Tab>
</Tabs>

### Making a Bank Transfer

<Note>Bank transfer funding is an **enterprise-only** feature. Contact our Customer Success Engineering (CSE) team to set up and verify your banking details.</Note>

Bank transfers allow you to fund your treasury wallet directly from your bank account. Here's how it works:

1. **Contact our CSE team** to share and verify your banking details. We will provide you with a bank account that accepts the fastest and lowest cost transfers from your bank.

2. **Send a bank transfer** using a specific memo format. The memo is critical for routing funds to your treasury wallet.

#### Memo Format

The memo must follow this format:

```
<projectCode>-<walletCode>-<nonce>
```

Where:

* **`<projectCode>`**: A 3-digit number assigned by the Crossmint Customer Success Engineering (CSE) team to identify your project (e.g., `001`).
* **`<walletCode>`**: A unique 5-character uppercase code that identifies your wallet, chain, and token. This code is provided by Crossmint's CSE team (e.g., `XFRWE`).
* **`<nonce>`**: A 6-character alphanumeric code that you generate to identify each transaction (e.g., `123ABD`). Each transaction must use a different nonce. You can use nonces with shared characters to group transactions associated with a specific entity.

<Info>
  Currently, only USDC is supported for B2B onramp. Support for additional tokens is coming soon.
</Info>

**Example memo:**

* `001-XFRWE-123ABD`

<Info>
  If you misplace a transfer (wrong memo, incorrect details, etc.), you can [contact our support team](https://help.crossmint.com/hc/en-us/requests/new) for assistance in recovering your funds.
</Info>

#### Wallet Settlement

Once your bank transfer clears, USDC will be automatically deposited into your treasury wallet on the specified chain.

To receive **real-time notifications** of successful transfers from your bank account to your treasury wallet use wallet transfer webhooks:

* [Configure a webhook endpoint](/introduction/platform/webhooks/add-endpoint) to receive messages for incoming transfers by selecting the `wallets.transfer.in` event type
* Make sure to [verify](/introduction/platform/webhooks/verify-webhooks) the webhook's signature to ensure it comes from Crossmint
* Look for the fields you care about (i.e. `data.status`) in the event's [response schema](/wallets/guides/webhooks#common-fields)

## Next Steps

<CardGroup>
  <Card title="Withdrawals" icon="building-columns" href="/stablecoin-orchestration/treasury-wallet/guides/withdrawals">
    Learn how to withdraw stablecoins to your bank account
  </Card>

  <Card title="Making Payments" icon="coins" href="/stablecoin-orchestration/treasury-wallet/guides/making-payments">
    Make payments from your treasury
  </Card>
</CardGroup>


# Making Payments
Source: https://docs.crossmint.com/stablecoin-orchestration/treasury-wallet/guides/making-payments

Learn about the different types of payments you can make from your treasury wallet

Treasury wallets support three types of payments, each with different compliance requirements and use cases.

## Payment Types

### 1. Between Treasury Wallets

Transfers between your own treasury wallets are **unregulated** and work like standard crypto transfers. These are simple, fast transfers that don't require any compliance checks.

**Use cases:**

* Moving funds between treasury wallets on different chains
* Rebalancing liquidity across your treasury positions
* Internal fund management and allocation

**How to make transfers:**

* Use the standard wallet transfer APIs
* No compliance checks required
* Instant settlement

For detailed instructions on making transfers, see the [Transfer Tokens guide](/wallets/guides/transfer-tokens).

### 2. Payouts to Customers

Payouts to your customers are **regulated transfers** that must comply with travel rule requirements and run comprehensive compliance checks, including sanctions screening.

**Use cases:**

* Customer refunds
* Reward payouts
* Loyalty program disbursements
* Customer-facing payment operations

**Compliance requirements:**

* **Travel Rule Compliance**: Automatic IVMS101 data exchange with counterparties
* **Sanctions Checks**: Real-time screening against global sanctions lists
* **AML Screening**: Automated anti-money laundering checks
* **KYC Verification**: Identity verification for both parties

For more information about regulated transfers and how to set them up, see the [Regulated Transfers overview](/stablecoin-orchestration/regulated-transfers/overview).

### 3. Payouts to External Third Parties (Vendors)

Payouts to external third parties such as vendors, suppliers, or service providers require **sanctions checks** but have lighter compliance requirements compared to customer payouts.

**Use cases:**

* Vendor payments
* Supplier disbursements
* Service provider payments
* B2B transactions

**Compliance requirements:**

* **Sanctions Checks**: Real-time screening against global sanctions lists

For more information about setting up regulated transfers for third-party payouts, see the [Regulated Transfers overview](/stablecoin-orchestration/regulated-transfers/overview).

## Next Steps

* For simple transfers between your own wallets: [Transfer Tokens Guide](/wallets/guides/transfer-tokens)
* For regulated customer or third-party payouts: [Regulated Transfers Overview](/stablecoin-orchestration/regulated-transfers/overview)


# Withdrawing
Source: https://docs.crossmint.com/stablecoin-orchestration/treasury-wallet/guides/withdrawals

Learn how to withdraw stablecoins from your treasury wallet to your bank account

Withdrawals allow you to offramp stablecoins from your treasury wallet directly to your bank account. This is the reverse of the [funding process](/stablecoin-orchestration/treasury-wallet/guides/funding-the-wallet#making-a-bank-transfer).

## Via the Console

Authorized users can initiate withdrawals directly from the Crossmint Console:

1. Navigate to [crossmint.com/console](https://crossmint.com/console)
2. Go to **Wallets** > **Company Wallets**
3. Click the **Withdraw** button on your treasury wallet
4. Follow the on-screen instructions to complete the withdrawal

<Info>
  To enroll additional authorized users for withdrawals, contact your Crossmint CSE.
</Info>

## Via API

1. Contact Crossmint's [Customer Success Engineering](https://www.crossmint.com/contact) (CSE) team to obtain the `bankAccountId` for your registered bank account.
2. Initiate a stablecoin transfer from your treasury wallet to a bank account using the [Create Order API](/api-reference/headless/create-order).

<CodeGroup>
  ```js JavaScript theme={null}
  const serverApiKey = process.env.CROSSMINT_SERVER_SIDE_API_KEY;
  const payerAddress = "<your-treasury-wallet-address>";
  const bankAccountId = "<bank-account-id-from-cse>";
  const amount = "100"; // Amount of USDC to offramp

  const response = await fetch("https://www.crossmint.com/api/2022-06-09/orders", {
      method: "POST",
      headers: {
          "Content-Type": "application/json",
          "x-api-key": serverApiKey,
      },
      body: JSON.stringify({
          payment: {
              method: "base",
              currency: "usdc",
              payerAddress: payerAddress
          },
          recipient: {
              bankAccountId: bankAccountId
          },
          lineItems: [
              {
                  currencyLocator: "fiat:usd",
                  executionParameters: {
                      mode: "exact-in",
                      amount: amount
                  }
              }
          ]
      }),
  });

  const data = await response.json();
  console.log(data);
  ```

  ```python Python theme={null}
  import os
  import requests

  server_api_key = os.getenv("CROSSMINT_SERVER_SIDE_API_KEY")
  payer_address = "<your-treasury-wallet-address>"
  bank_account_id = "<bank-account-id-from-cse>"
  amount = "100"  # Amount of USDC to offramp

  url = "https://www.crossmint.com/api/2022-06-09/orders"
  headers = {
      "Content-Type": "application/json",
      "x-api-key": server_api_key
  }
  payload = {
      "payment": {
          "method": "base",
          "currency": "usdc",
          "payerAddress": payer_address
      },
      "recipient": {
          "bankAccountId": bank_account_id
      },
      "lineItems": [
          {
              "currencyLocator": "fiat:usd",
              "executionParameters": {
                  "mode": "exact-in",
                  "amount": amount
              }
          }
      ]
  }

  response = requests.post(url, headers=headers, json=payload)
  data = response.json()
  print(data)
  ```

  ```bash cURL theme={null}
  curl --request POST \
    --url 'https://www.crossmint.com/api/2022-06-09/orders' \
    --header 'Content-Type: application/json' \
    --header 'x-api-key: <your-server-side-api-key>' \
    --data '{
      "payment": {
        "method": "base",
        "currency": "usdc",
        "payerAddress": "<your-treasury-wallet-address>"
      },
      "recipient": {
        "bankAccountId": "<bank-account-id-from-cse>"
      },
      "lineItems": [
        {
          "currencyLocator": "fiat:usd",
          "executionParameters": {
            "mode": "exact-in",
            "amount": "100"
          }
        }
      ]
    }'
  ```
</CodeGroup>

Once the offramp is initiated:

* The specified amount of USDC is debited from your treasury wallet
* Crossmint converts the USDC to fiat currency
* The fiat amount (minus fees) is transferred to your registered bank account
* You can monitor the transaction status by polling the order's status, or via the Crossmint console

<Note>
  Settlement times may vary depending on your bank and region.
</Note>

### Monitor Withdrawal Status

You can track the status of your withdrawal by polling the order status endpoint to check progress:

<CodeGroup>
  ```js JavaScript theme={null}
  const API_KEY = "<your-server-side-api-key>";
  const orderId = "<order-id>";

  const response = await fetch(`https://www.crossmint.com/api/2022-06-09/orders/${orderId}`, {
      method: "GET",
      headers: {
          "Content-Type": "application/json",
          "x-api-key": API_KEY,
      }
  });

  if (!response.ok) {
      throw new Error(`Failed to get order: ${response.status} ${response.statusText}`);
  }
  }

  const data = await response.json();
  console.log(data);
  ```

  ```python Python theme={null}
  import requests

  API_KEY = "<your-server-side-api-key>"
  order_id = "<order-id>"

  url = f"https://www.crossmint.com/api/2022-06-09/orders/{order_id}"
  headers = {
      "Content-Type": "application/json",
      "x-api-key": API_KEY
  }

  response = requests.get(url, headers=headers)

  if not response.ok:
      raise Exception(f"Failed to get order: {response.status_code} {response.reason}")

  print(response.json())
  ```

  ```bash cURL theme={null}
  API_KEY="<your-server-side-api-key>"
  ORDER_ID="<order-id>"

  curl --request GET \
    --url "https://www.crossmint.com/api/2022-06-09/orders/${ORDER_ID}" \
    --header "Content-Type: application/json" \
    --header "x-api-key: ${API_KEY}"
  ```
</CodeGroup>

## Troubleshooting

<Info>
  If you encounter issues with a withdrawal (incorrect amount, failed transfer, etc.), [contact our support team](https://help.crossmint.com/hc/en-us/requests/new) for assistance.
</Info>


# Overview
Source: https://docs.crossmint.com/stablecoin-orchestration/treasury-wallet/overview

Programmable wallets for managing your stablecoin treasury

Crossmint's Treasury Wallets provide businesses with secure, programmable wallets designed specifically for managing
stablecoin holdings at scale. Built for financial operations teams, Treasury Wallets offer enterprise-grade security,
programmable automations, and controls and auditability, for efficient treasury management.

**Key Features**

* **Programmable Controls**: Set spending limits, role-based access, multi-signature requirements, and automated workflows.
* **Multi-Chain Support**: Manage assets across Solana, 20+ EVM chains (Ethereum, Polygon, Base), Stellar, and more.
* **Security & Compliance**: SOC-2 compliance, flexible signing policies, multi-sig support, and audit trails.
* **Liquidity Management**: Fund wallets via Bank Transfers, Credit Card, or crypto transfers.
* **Advanced Observability**: Monitor all treasury operations via dashboards, APIs, and webhooks.

## Use Cases

<AccordionGroup>
  <Accordion title="Corporate Treasury Management" icon="building-columns">
    Manage your company's stablecoin reserves with enterprise-grade controls and automation.

    * **Multi-currency reserves**: Hold USDC, USDT, and other stablecoins across multiple chains.
    * **Automated workflows**: Set up rules for rebalancing and disbursements.
    * **Access controls**: Configure role-based permissions and multi-signature requirements.
    * **Audit trails**: Complete transaction history and compliance reporting.
  </Accordion>

  <Accordion title="Payment Operations" icon="money-bill-transfer">
    Power your payment flows with programmable treasury wallets.

    * **Automated disbursements**: Schedule or trigger payments based on business logic.
    * **Batch processing**: Execute multiple payments efficiently in a single transaction.
    * **Compliance integration**: Built-in AML screening and transaction monitoring.
    * **Reconciliation**: Automatic matching of payments to invoices and records.
  </Accordion>

  <Accordion title="Liquidity Management" icon="chart-line">
    Optimize treasury operations by automatically managing liquidity across chains and protocols.

    * **Cross-chain rebalancing**: Move funds between chains based on preset rules or triggers.
    * **Liquidity aggregation**: Consolidate funds from multiple sources into your treasury.
    * **Automated conversion**: Set rules to maintain target balances across different stablecoins.
    * **Gas optimization**: Intelligent gas management to minimize transaction costs.
  </Accordion>
</AccordionGroup>

## How It Works

### 1. Create Treasury Wallets

You can create one or more treasury wallets per project, and chain, using the Create Wallet API or the
console (coming soon).

### 2. Configure Access & Controls

Define who can access the treasury and what actions they can perform. Configure secure recovery options.

### 3. Fund Wallets

Deposit stablecoins via multiple methods:

* **Direct transfer (crypto)**: Send assets to your treasury wallet address.
* **Bank transfer**: Convert fiat to stablecoins via Crossmint's onramp.

### 4. Make Payments

Transfer money between your own treasury wallets, make regulated disbursements to your customers, and payouts to your
suppliers, using APIs or the console (coming soon).

## Security Features

<CardGroup>
  <Card title="Smart Contract Wallets" icon="key">
    Each treasury wallet is backed by its own Smart Contract, which provides them enhanced security and programmability vs
    a traditional MPC or TEE based custody wallet.
  </Card>

  <Card title="SOC-2 Compliance" icon="certificate">
    Independently audited security controls and processes.
  </Card>

  <Card title="Transaction Monitoring" icon="radar">
    Real-time monitoring for suspicious activity and compliance violations.
  </Card>

  <Card title="Audit Trails" icon="list-timeline">
    Immutable logs of all treasury operations for compliance and auditing.
  </Card>
</CardGroup>

## Get Started

<Snippet />

<CardGroup>
  <Card title="Quickstart ⚡" icon="bolt" href="/stablecoin-orchestration/treasury-wallet/quickstart">
    Create a treasury wallet and check balances in minutes
  </Card>

  <Card title="Funding the Wallet" icon="money-bill-transfer" href="/stablecoin-orchestration/treasury-wallet/guides/funding-the-wallet">
    Learn how to fund your treasury wallet in staging and production
  </Card>

  <Card title="Withdrawals" icon="building-columns" href="/stablecoin-orchestration/treasury-wallet/guides/withdrawals">
    Withdraw stablecoins to your bank account
  </Card>

  <Card title="Making Payments" icon="coins" href="/stablecoin-orchestration/treasury-wallet/guides/making-payments">
    Make payments from your treasury
  </Card>
</CardGroup>


# Quickstart ⚡
Source: https://docs.crossmint.com/stablecoin-orchestration/treasury-wallet/quickstart

Create a treasury wallet and check balances using the server SDK

<CardGroup>
  <Snippet />
</CardGroup>

<Steps>
  <Step title="Install the SDK">
    Run the following command to install the SDK:

    <Snippet />
  </Step>

  <Step title="Create a treasury wallet">
    See all supported chains [here](/introduction/supported-chains).

    ```tsx index.ts theme={null}

    import { CrossmintWallets, createCrossmint } from "@crossmint/wallets-sdk";

    const crossmint = createCrossmint({
        apiKey: "<your-server-api-key>",
    });

    const crossmintWallets = CrossmintWallets.from(crossmint);

    const wallet = await crossmintWallets.createWallet({
        chain: "base-sepolia",
        signer: {
            type: "external-wallet",
            address: "<your-eoa-address>",
        },
        owner: "COMPANY",
        alias: "treasury",
    });

    console.log(wallet.address);
    ```

    **Key Points:**

    * The `owner` field must be set to `"COMPANY"` for treasury wallets to ensure the wallet appears under Company in the console
    * The `signer` must be a non-custodial type (`external-wallet` or `passkey`)
    * The `alias` field is set to `"treasury"` to identify this as your treasury wallet
  </Step>

  <Step title="Check treasury wallet balance">
    <Note>
      For newly created or unfunded wallets, the balance will be `"0"`. This is expected behavior - you will need to [fund the wallet](/stablecoin-orchestration/treasury-wallet/guides/funding-the-wallet) before seeing a non-zero balance.
    </Note>

    Retrieve the stablecoin balance of your treasury wallet:

    ```tsx index.ts theme={null}

    import { CrossmintWallets, createCrossmint } from "@crossmint/wallets-sdk";

    const crossmint = createCrossmint({
        apiKey: "<your-server-api-key>",
    });

    const crossmintWallets = CrossmintWallets.from(crossmint);

    const treasuryWallet = await crossmintWallets.getWallet("<your-wallet-address>", {
        chain: "base-sepolia",
        signer: {
            type: "external-wallet",
            address: "<your-eoa-address>",
        },
    });

    const balances = await treasuryWallet.balances(["usdc"]);
    console.log(balances.usdc.amount);
    ```
  </Step>

  <Step title="Run the code">
    Execute your `index.ts` file using one of the following methods:

    **Using ts-node:**

    ```bash theme={null}
    npx ts-node index.ts
    ```

    **Or compile and run with Node.js:**

    ```bash theme={null}
    npx tsc index.ts && node index.js
    ```

    You should see the wallet address printed to the console after successful execution.
  </Step>

  <Step title="Verify in the console">
    After creating your treasury wallet, you can verify it was created correctly in the [Crossmint Console](https://staging.crossmint.com/console):

    1. Navigate to **Wallets** in the left sidebar
    2. Click on the **Company** tab
    3. Your treasury wallet should appear in the list with the alias "treasury"
  </Step>
</Steps>

## Launching in Production

<Snippet />

For production, the steps are almost identical, but some changes are required:

1. Create a developer account on the [production console](https://www.crossmint.com/console)
2. Create a production client API key on the [API Keys](https://www.crossmint.com/console/projects/apiKeys) page with the API scopes `wallets.read`, `wallets.create`, `wallets:transactions.create`, `wallets:transactions.sign`, `wallets:balance.read`, `wallets.fund`
3. Replace your test API key with the production key
4. Discuss with your Crossmint Customer Success Engineering (CSE) team the best signer configuration for your expected usage, and recovery mechanisms

## Learn More

<CardGroup>
  <Card title="Check Balances" icon="money-bill-transfer" href="/wallets/guides/check-balances">
    Check the balance of a wallet.
  </Card>

  <Card title="Funding the Wallet" icon="money-bill-transfer" href="/stablecoin-orchestration/treasury-wallet/guides/funding-the-wallet">
    Learn how to fund your treasury wallet.
  </Card>

  <Card title="Withdrawals" icon="building-columns" href="/stablecoin-orchestration/treasury-wallet/guides/withdrawals">
    Withdraw stablecoins to your bank account.
  </Card>

  <Card title="Making Payments" icon="coins" href="/stablecoin-orchestration/treasury-wallet/guides/making-payments">
    Make payments from your treasury.
  </Card>
</CardGroup>

## Other Links

<CardGroup>
  <Card title="API Reference" icon="terminal" href="/api-reference/wallets/create-wallet">
    Deep dive into API reference docs.
  </Card>

  <Card title="Talk to an expert" icon="message" href="https://www.crossmint.com/contact/sales">
    Contact our sales team for support.
  </Card>
</CardGroup>


# Data Requirements
Source: https://docs.crossmint.com/stablecoin-orchestration/users-compliance/data-requirements

Required data fields by activity type and region.

The data required for each user depends on the type of regulated activity they want to perform and the user's residency.

## Requirements for non-US residents

The following tables show what information is required for each activity type for users residing outside the United States. To see the specific fields required for each object follow the [Create User API](/api-reference/users/upsert-user) documentation.

### Data Requirements

| Object              | Regulated Transfers | On/offramp |
| ------------------- | :-----------------: | :--------: |
| userDetails         |          ✅          |      ✅     |
| kycData             |                     |      ✅     |
| dueDiligence        |                     |      ✅     |
| verificationHistory |                     |      ✅     |

### Document Requirements

Specific documents may be required depending on the activity. Use the [Upload Document API](/api-reference/users/upload-document) to upload the necessary materials.

| Document Type     | Regulated Transfers | On/offramp | On/offramp with EDD\* |
| ----------------- | :-----------------: | :--------: | :-------------------: |
| Identity document |                     |      ✅     |           ✅           |
| Proof of address  |                     |            |           ✅           |
| Proof of income   |                     |            |           ✅           |

\*Enhanced Due Diligence (EDD) is required for high-risk individuals or regions.

<Note>
  **Identity document types for non-US residents:**

  * For residents of countries outside of EU/EEA, only passport (`id-passport`) is accepted. Driving licenses or local ID cards are not accepted.
  * For residents of EU/EEA countries, ID cards (`id-idcard-front`, `id-idcard-back`) or passports (`id-passport`) are accepted.
</Note>

## Requirements for US residents

The same data and document requirements apply for users residing in the United States, with the following exceptions:

* In the `dueDiligence` object, the `yearly_estimated_income` field is **required** for US residents, although it is optional for non-US residents

<Note>
  **Identity document types for US residents:**

  * For US residents who are also US citizens, only SSN (`id-ssn`) is accepted.
  * For US residents who are not US citizens, only passport (`id-passport`) is accepted.
</Note>

## Next Steps

<CardGroup>
  <Card title="Quickstart" icon="bolt" href="/stablecoin-orchestration/users-compliance/quickstart">
    Register your first user and upload documents in minutes.
  </Card>

  <Card title="Talk to an expert" icon="message" href="https://www.crossmint.com/contact/sales">
    Contact the Crossmint sales team for support.
  </Card>
</CardGroup>


# Overview
Source: https://docs.crossmint.com/stablecoin-orchestration/users-compliance/overview

Register user data to enable access to regulated Crossmint products.

Crossmint's regulated products for stablecoin orchestration, including [onramp](/stablecoin-orchestration/onramp/overview), offramp, and [regulated transfers](/stablecoin-orchestration/regulated-transfers/overview)—require user data registration to comply with financial regulations. Compliance checks are performed by Crossmint when a registered user attempts a regulated action.

## How it works

* **Run initial verification**: Your company runs or identifies existing KYC, ID verification, and liveness checks with your own IDV provider (such as Persona or Sumsub)
* **Pass KYC data to Crossmint**: Share that KYC data with Crossmint via API so that regulated actions (onramp, offramp, regulated transfers) can leverage that existing KYC data
* **Crossmint handles additional screening**: Crossmint runs sanction and PEP (Politically Exposed Persons) screens, and performs ongoing monitoring to ensure compliance

<Note> If your company has not provided all required information, users will be prompted to provide it client-side when initiating a regulated activity, as it's done with [Crossmint Onramp](/stablecoin-orchestration/onramp/overview). </Note>

## Data Requirements Vary

The information required for each user depends on the country and the activity type:

* **Regulated Transfers**: Basic user details for regulated transfers
* **Onramp/Offramp**: Additional user information

See the [Data Requirements](/stablecoin-orchestration/users-compliance/data-requirements) page for a detailed breakdown of required fields.

## Getting Started

<CardGroup>
  <Card title="Quickstart" icon="bolt" href="/stablecoin-orchestration/users-compliance/quickstart">
    Register your first user and upload documents in minutes.
  </Card>

  <Card title="Data Requirements" icon="table" href="/stablecoin-orchestration/users-compliance/data-requirements">
    See what data is required for each activity and region.
  </Card>
</CardGroup>


# Prohibited Geographies
Source: https://docs.crossmint.com/stablecoin-orchestration/users-compliance/prohibited-geographies

List of geographies where Crossmint does not provide services.

Crossmint cannot provide regulated services in the following jurisdictions due to sanctions/prohibitions under the sanctions lists we comply with.

## Prohibited Countries and Territories

| Country/Territory                      |
| -------------------------------------- |
| Afghanistan                            |
| Belarus                                |
| Bolivia                                |
| Bosnia and Herzegovina                 |
| Burundi                                |
| Central African Republic               |
| China                                  |
| Crimea                                 |
| Cuba                                   |
| Democratic Republic of the Congo       |
| Donetsk and Luhansk Regions of Ukraine |
| Guatemala                              |
| Guinea                                 |
| Guinea-Bissau                          |
| Haiti                                  |
| Iran                                   |
| Iraq                                   |
| Lebanon                                |
| Libya                                  |
| Mali                                   |
| Moldova                                |
| Montenegro                             |
| Morocco                                |
| Myanmar (Burma)                        |
| Nicaragua                              |
| Niger                                  |
| North Korea                            |
| Palestine                              |
| Russia                                 |
| Serbia                                 |
| Somalia                                |
| South Sudan                            |
| Sudan                                  |
| Syria                                  |
| Tunisia                                |
| Venezuela                              |
| Yemen                                  |
| Zimbabwe                               |

## Questions About Prohibited Geographies

If you have questions about any of these geographies or need to discuss specific use cases, reach out to [Crossmint's support team](https://www.crossmint.com/contact/sales).

## Next Steps

<CardGroup>
  <Card title="Data Requirements" icon="table" href="/stablecoin-orchestration/users-compliance/data-requirements">
    See what data is required for each activity and region.
  </Card>

  <Card title="Talk to an expert" icon="message" href="https://www.crossmint.com/contact/sales">
    Contact the Crossmint sales team for support.
  </Card>
</CardGroup>


# Quickstart ⚡
Source: https://docs.crossmint.com/stablecoin-orchestration/users-compliance/quickstart

Register users and upload documents to enable regulated product access.

<CardGroup>
  <Snippet />
</CardGroup>

<Snippet />

This quickstart guide walks you through registering a user, uploading documents, and fetching document details using Crossmint's APIs. These steps enable your users to access regulated products like onramp, offramp, and regulated transfers.

<Steps>
  <Step title="User accepts Crossmint's Privacy Policy">
    Before sharing any user KYC data with Crossmint, you must ensure your users have accepted Crossmint's [Privacy Policy](https://www.crossmint.com/legal/privacy-policy). This is a prerequisite for companies sharing their customer's KYC data with Crossmint.

    <Accordion title="Requirements for collecting consent">
      Consent must be obtained following the guidelines below:

      1. The user must have the ability to see the terms they must accept
      2. The user must grant consent with a checkbox, unchecked by default
      3. The user doesn't need to open the hyperlink to the privacy policy to view the terms
      4. The user needs to see Crossmint's logo in the flow
      5. The specific text that you must present to your end user is: **"I consent to my KYC data being processed by Crossmint in accordance with its [Privacy Policy](https://www.crossmint.com/legal/privacy-policy)"**
      6. The text can be localized but must link to the same privacy policy link provided above
      7. If the privacy policy is updated, you must ask the user to agree to the above terms again
    </Accordion>

    Once the user has accepted the privacy policy, record their acceptance using the following API call:

    ```javascript theme={null}
    const userLocator = "userId:johnd-123";

    const options = {
        method: 'PUT',
        headers: {'X-API-KEY': '<x-api-key>', 'Content-Type': 'application/json'},
        body: JSON.stringify({
            type: "crossmint-privacy-policy",
            acceptedAt: "2025-10-05T14:48:00" // ISO 8601 date string
        })
    };

    fetch(`https://staging.crossmint.com/api/2025-06-09/users/${userLocator}/legal-documents`, options)
        .then(response => response.json())
        .then(response => console.log(response))
        .catch(err => console.error(err));
    ```

    <Note>This call also creates a user with the specified `userLocator` if one does not already exist.</Note>
  </Step>

  <Step title="Register user information">
    Register a user with Crossmint by specifying their `userLocator`, their personal details, and KYC data using the [Create User](/api-reference/users/upsert-user) endpoint

    ```javascript theme={null}
    const userLocator = "userId:johnd-123"; 

    const options = {
        method: 'PUT',
        headers: {'X-API-KEY': '<x-api-key>', 'Content-Type': 'application/json'},
        body: JSON.stringify({
            userDetails: {
                firstName: "John",
                lastName: "Doe",
                dateOfBirth: "1995-01-01",
                countryOfResidence: "DE"
            }
        })
    };

    fetch(`https://staging.crossmint.com/api/2025-06-09/users/${userLocator}`, options)
        .then(response => response.json())
        .then(response => console.log(response))
        .catch(err => console.error(err));
    ```
  </Step>

  <Step title="Run identity verification">
    Once you have registered relevant user information you can trigger checks via the [Trigger Identity Verification](/api-reference/users/trigger-identity-verification) endpoint.

    ```javascript theme={null}
    const userLocator = "userId:johnd-123";

    const options = {
        method: 'PUT',
        headers: {
            'X-API-KEY': '<x-api-key>'
        }
    };

    fetch(`https://staging.crossmint.com/api/2025-06-09/users/${userLocator}/identity-verification`, options)
        .then(response => response.json())
        .then(response => console.log(response))
        .catch(err => console.error(err));
    ```

    The response will include the eligibility status for each verification type (`regulated-transfer`, `onramp`, `offramp`):

    * `not-started`: Verification has not been initiated
    * `pending-privacy-policy`: User has not yet accepted Crossmint's Privacy Policy
    * `requires-data`: Additional user data or documents are needed
    * `pending-review`: Verification is in progress
    * `verified`: User has passed verification
    * `rejected`: User has failed verification

    If any of them return `requires-data`, you must aggregate the `missingData` and `missingDocuments` arrays from those specific eligibility objects. Then, update the user's information using the [Update User](/api-reference/users/upsert-user) endpoint and/or upload additional documents using the [Upload Document](/api-reference/users/upload-document) endpoint, and finally re-trigger the verification.

    ```json theme={null}
    {
        "eligibility": [
            {
                "type": "regulated-transfer",
                "status": "pending-review" // or "verified"
            },
            {
                "type": "onramp",
                "status": "requires-data",
                "missingData": ["kyc-data", "due-diligence", "verification-history"],
                "missingDocuments": ["id"] // "proof-of-address" and "proof-of-income" requested in case of additional due diligence required 
            },
            {
                "type": "offramp",
                "status": "requires-data",
                "missingData": ["kyc-data", "due-diligence", "verification-history"],
                "missingDocuments": ["id"] // "proof-of-address" and "proof-of-income" requested in case of additional due diligence required 
            }
        ]
    }
    ```
  </Step>

  <Step title="Update user information">
    Register additional user information with Crossmint so the user can access onramp and offramp services.

    <Note> Calling this endpoint again with the same `userLocator` will update the existing user's information. The endpoint is not additive so specify all relevant user information when updating the user.</Note>

    ```javascript theme={null}
    const userLocator = "userId:johnd-123"; 

    const options = {
        method: 'PUT',
        headers: {'X-API-KEY': '<x-api-key>', 'Content-Type': 'application/json'},
        body: JSON.stringify({
            userDetails: {
                firstName: "John",
                lastName: "Doe",
                dateOfBirth: "1995-01-01",
                countryOfResidence: "DE"
            },
            kycData: {
                addressOfResidence: {
                    line1: "123 Hauptstrasse",
                    line2: "Apt 5",
                    city: "Berlin",
                    stateOrRegion: "Brandenburg",
                    postalCode: "10115"
                },
                email: "johnd@example.com",
                identityDocument: {
                    type: "passport",
                    number: "AS12321",
                    issuingCountryCode: "GR"
                }
            },
            dueDiligence: {
                employmentStatus: "full-time",
                sourceOfFunds: "employment-income",
                industry: "finance-insurance"
            },
            verificationHistory: {
                idVerificationTimestamp: "2024-01-15T10:30:00Z",
                livenessVerificationTimestamp: "2024-01-15T10:32:00Z"
            }
        })
    };

    fetch(`https://staging.crossmint.com/api/2025-06-09/users/${userLocator}`, options)
        .then(response => response.json())
        .then(response => console.log(response))
        .catch(err => console.error(err));
    ```
  </Step>

  <Step title="Upload a document">
    Upload identity or supporting documents for the user using the [Upload Document](/api-reference/users/upload-document) endpoint. Documents are associated with the user via their `userLocator`.

    ```javascript theme={null}
    const options = {
        method: 'POST',
        headers: {'X-API-KEY': '<x-api-key>', 'Content-Type': 'application/json'},
        body: JSON.stringify({
            reference: {
                userLocator: "userId:johnd-123"
            },
            documentType: "id-passport",
            data: "<base64-encoded-image>",
            expiresAt: "2030-12-31"
        })
    };

    fetch('https://staging.crossmint.com/api/2025-06-09/documents', options)
        .then(response => response.json())
        .then(response => console.log(response))
        .catch(err => console.error(err));
    ```

    **Supported document types:**

    * Identity documents: `id-ssn`, `id-passport`, `id-idcard-front`, `id-idcard-back`
    * Supporting documents: `proof-of-address`, `proof-of-income`

    <Note>Calling this endpoint again with the same `userLocator` and `documentType` will update the existing document's registered information.</Note>
  </Step>

  <Step title="Run identity verification">
    Once you have registered the user's information and uploaded the required documents, trigger the KYC verification process using the [Trigger Identity Verification](/api-reference/users/trigger-identity-verification) endpoint.

    ```javascript theme={null}
    const userLocator = "userId:johnd-123";

    const options = {
        method: 'PUT',
        headers: {
            'X-API-KEY': '<x-api-key>'
        }
    };

    fetch(`https://staging.crossmint.com/api/2025-06-09/users/${userLocator}/identity-verification`, options)
        .then(response => response.json())
        .then(response => console.log(response))
        .catch(err => console.error(err));
    ```

    The response will include the eligibility status for each verification type (`regulated-transfer`, `onramp`, `offramp`):

    ```json theme={null}
    {
        "eligibility": [
            {
                "type": "regulated-transfer",
                "status": "verified"
            },
            {
                "type": "onramp",
                "status": "pending-review"
            },
            {
                "type": "offramp",
                "status": "pending-review"
            }
        ]
    }
    ```
  </Step>

  <Step title="Check verification status">
    After triggering the identity verification, the process usually completes within a few seconds. You can check the current status using the [Get Identity Verification Status](/api-reference/users/get-identity-verification) endpoint.

    ```javascript theme={null}
    const userLocator = "userId:johnd-123";

    const options = {
        method: 'GET',
        headers: {
            'X-API-KEY': '<x-api-key>'
        }
    };

    fetch(`https://staging.crossmint.com/api/2025-06-09/users/${userLocator}/identity-verification`, options)
        .then(response => response.json())
        .then(response => console.log(response))
        .catch(err => console.error(err));
    ```
  </Step>

  <Step title="Fetch user information">
    You can fetch a user's information at any time to see their current status, including when they last accepted valid legal documents. Use the Get User endpoint to retrieve this information:

    ```javascript theme={null}
    const userLocator = "userId:johnd-123";

    const options = {
        method: 'GET',
        headers: {
            'X-API-KEY': '<x-api-key>'
        }
    };

    fetch(`https://staging.crossmint.com/api/2025-06-09/users/${userLocator}`, options)
        .then(response => response.json())
        .then(response => console.log(response))
        .catch(err => console.error(err));
    ```

    The response includes the `legalDocuments` array, which shows the status of legal document acceptances:

    ```json theme={null}
    {
        "email": "john.doe@example.com",
        "phoneNumber": "+1234567890",
        "userId": "usr_1234567890",
        "userDetails": true,
        "kycData": false,
        "dueDiligence": false,
        "verificationHistory": false,
        "legalDocuments": [
            {
                "type": "crossmint-privacy-policy",
                "acceptedAt": "2024-01-15T10:30:00Z",
                "validVersion": true
            }
        ]
    }
    ```

    The `validVersion` field indicates whether the user has accepted the current version of the legal document. If `validVersion` is `false`, you should prompt the user to accept the updated terms.
  </Step>
</Steps>

## Launching in Production

For production, the steps are almost identical, but some changes are required:

1. Create a developer account on the [production console](https://www.crossmint.com/console)
2. Create a production server API key on the [API Keys](https://www.crossmint.com/console/projects/apiKeys) page with the API scopes `users.create`, `users.read`
3. Replace your test API key with the production key
4. Replace `staging.crossmint.com` with `www.crossmint.com` in the API URLs

## Learn More

<CardGroup>
  <Card title="Data Requirements" icon="table" href="/stablecoin-orchestration/users-compliance/data-requirements">
    See what data is required for each activity and region.
  </Card>

  <Card title="Talk to an expert" icon="message" href="https://www.crossmint.com/contact/sales">
    Contact the Crossmint sales team for support.
  </Card>
</CardGroup>


# Architecture
Source: https://docs.crossmint.com/wallets/architecture

Crossmint Wallets Architecture

Crossmint wallets are designed to provide:

1. **Flexibility**: A single wallet primitive that supports many use cases — end-user wallets, treasury management, disbursements, and more.
2. **High throughput and availability**: Wallets scale to the maximum throughput available per chain, at the fastest speeds possible.
3. **True ownership**: You and your users fully own every wallet. Even if Crossmint were to disappear, wallets continue to function — no vendor lock-in, no dependency on Crossmint infrastructure.

All while abstracting out all blockchain complexity — operate with them via simple REST APIs and SDKs.

## Dual Layer Architecture

Crossmint achieves this by separating two concerns: **the wallet itself** and **the signers that control it**.

<img alt="Crossmint Wallet Dual Layer Architecture" />

### The Core: Smart Contract Wallets

On EVM chains, Crossmint wallets are **smart contract wallets** implementing <a href="https://eips.ethereum.org/EIPS/eip-4337">ERC-4337</a> with <a href="https://eips.ethereum.org/EIPS/eip-7579">ERC-7579</a> modular extensions. Because the wallet is a smart contract, it lives natively on the blockchain — not in a private third-party server that you cannot audit or control.

On Solana, wallets use <a href="https://solana.com/docs/core/pda">program-derived addresses (PDAs)</a> with equivalent programmatic control.

On Stellar, wallets use Soroban smart contracts, with equivalent functionality and additional cost and developer experience improvements around the use of trustlines.

This smart contract foundation enables:

* **Seamless provider migration**: If you wish to migrate, you can update the wallet's recovery signers without changing the wallet address. Your users keep their address, balances, and transaction history regardless of infrastructure changes.
* **Programmable authorization logic**: Add multiple operational and recovery signers, with optional scoped permissions, with logic fully auditable onchain.
* **Flexible gas sponsorship**: Wallets can pay gas in USDC, native token, or billed to your Crossmint account.
* **Easier post-quantum migration**: Unlike wallets that couple wallet address with the underlying signer, Crossmint wallets will continue to operate with the same address once keys are upgraded to post-quantum cryptography.

All permissions are enforced **onchain and fully auditable**, removing the need to trust opaque infrastructure or Crossmint's backend. The wallet logic stays visible, enforceable, and portable.

<Info>
  Because the wallet is a smart contract on a public blockchain, it does not depend on Crossmint's servers to function. If Crossmint were to stop operating, you can interact with the wallet's smart contract directly — adding new signers, transferring assets, or migrating to another provider — using standard blockchain tools.
</Info>

### The Control Layer: Signers

A **[signer](/introduction/glossary)** is a digital identity — such as a passkey, external wallet, or cloud key — authorized to approve actions on the wallet's behalf. By decoupling signers from the wallet, Crossmint obtains higher performance signing with equivalent security, while reducing cost and lock-in significantly compared with cloud-TEE based systems.

**For end-user wallets**, Crossmint uses the native key enclaves already present on your users' devices: the Secure Enclave on iOS and the Keystore on Android. Signatures happen directly on user hardware with no network round-trip to Crossmint or any third-party server. This means signing adds zero latency compared to a direct blockchain transaction — unlike MPC-based architectures that require key reconstruction across distributed infrastructure before every signature, or cloud TEEs which require a network round trip.

**For company and treasury wallets**, Crossmint integrates with your existing cloud infrastructure — AWS KMS, Azure Key Vault, or GCP Cloud HSM. These are the same signing services trusted across tens of thousands of companies outside of crypto, supporting up to 1,000 cryptographic signing operations per second per key.

**For recovery**, Crossmint provides additional signers based on email, phone number, or social login. These recovery signers are added to the wallet's onchain signer set, meaning recovery is enforced by the smart contract itself — not by Crossmint's backend. See [Wallet Signers](/wallets/concepts/wallet-signers#recovery-signers) for recovery signer types and [Custody modalities](/wallets/concepts/custody-modalities) for the custody implications.

## What This Means in Practice

**For end-user wallets**, this architecture enables completely invisible, self-custodial wallets. Users sign transactions on their own device hardware without knowing a blockchain is involved. Gas is fully sponsored. There is no dependency on a third-party server to sign in or transact. And because the wallet is a smart contract, you have a clear migration path away from any provider — update the recovery signer and move on, keeping the same wallet address and all its assets.

**For company and treasury wallets**, you get bank-grade signing infrastructure at a fraction of the cost of specialized custody providers. An AWS KMS signer costs pennies per signing operation and supports throughput that exceeds what most chains can settle. Compare this to custody providers that charge thousands per month for equivalent functionality.

<Card title="Why smart contract wallets?" icon="lightbulb" href="/wallets/why-smart-wallets">
  Learn why Crossmint chose smart contract wallets over MPC and off-chain key storage.
</Card>


# Common Signer Configurations
Source: https://docs.crossmint.com/wallets/concepts/common-signer-configurations

Recommended operational and recovery signer setups for common wallet architectures.

This guide provides practical, opinionated signer configurations for common wallet architectures. Use it as a starting point, then adapt based on your threat model, regulatory constraints, and product requirements.

## Non-custodial user wallets

This is the most common configuration. Users are the custodians of their wallets, and your company is not.

| Slot                | Recommended signers                                                                                                                                                                                                           |
| ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Operational signers | [Device key](/wallets/concepts/wallet-signers#device-key)<br />[Passkey](/wallets/concepts/wallet-signers#passkey)                                                                                                            |
| Recovery signers    | [Email OTP](/wallets/concepts/wallet-signers#email-otp)<br />[SMS OTP](/wallets/concepts/wallet-signers#sms-otp) (optional)<br />[Managed support center](/wallets/concepts/wallet-signers#managed-support-center) (optional) |

## Custodial user wallets

If you want to take custody over user wallets, two common approaches are: (1) you act as custodian, or (2) a licensed third-party custodian acts as custodian.

### You are the custodian

You hold the operational signer in your infrastructure and sign operations on behalf of users.

| Slot                | Recommended signers                                                                                                                                                                                                                                                                                                       |
| ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Operational signers | [Server key](/wallets/concepts/wallet-signers#server-key) (lower risk / early stage)<br />[Cloud KMS](/wallets/concepts/wallet-signers#cloud-kms) (recommended for production)                                                                                                                                            |
| Recovery signers    | [Cloud KMS (recovery)](/wallets/concepts/wallet-signers#cloud-kms-recovery) (separate account/region recommended)<br />[Externally custodied key](/wallets/concepts/wallet-signers#externally-custodied-key) (optional)<br />[Managed support center](/wallets/concepts/wallet-signers#managed-support-center) (optional) |

### Licensed third-party custodian

A licensed custodian holds the keys and operates the wallet. This can provide custodial features without your company taking custody directly.

Each custodian has specific integration requirements and signer configurations that depend on their infrastructure and compliance model.

<Note>
  Crossmint can help you set up a third-party custodian integration. <a href="https://www.crossmint.com/contact/sales">Contact our team</a> to get started.
</Note>

## Treasury wallets

Treasury wallets typically prioritize strong controls, auditability, and operational safety.

| Slot                | Recommended signers                                                                                                                                                                                                                                                                                                       |
| ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Operational signers | [Cloud KMS](/wallets/concepts/wallet-signers#cloud-kms)                                                                                                                                                                                                                                                                   |
| Recovery signers    | [Cloud KMS (recovery)](/wallets/concepts/wallet-signers#cloud-kms-recovery) (separate account/region recommended)<br />[Externally custodied key](/wallets/concepts/wallet-signers#externally-custodied-key) (optional)<br />[Managed support center](/wallets/concepts/wallet-signers#managed-support-center) (optional) |

## Agent wallets

Custody for AI agents depends on where the agent runs and who can access its runtime environment.

### User-hosted agents

When an agent runs in a user-controlled environment (for example, self-hosted), the user should remain the custodian.

| Slot                | Recommended signers                                                                                                                                           |
| ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Operational signers | [Server key](/wallets/concepts/wallet-signers#server-key) (user-managed)<br />[Cloud KMS](/wallets/concepts/wallet-signers#cloud-kms) (user-managed)          |
| Recovery signers    | [Email OTP](/wallets/concepts/wallet-signers#email-otp) (optional)<br />[Externally custodied key](/wallets/concepts/wallet-signers#externally-custodied-key) |

### Platform-hosted agents

When you host agents on behalf of users, the key principle is to avoid a configuration where the platform host can unilaterally control agent wallets.

A common pattern is to use narrowly-scoped operational signers and require explicit user authorization for higher-risk actions.

| Slot                | Recommended signers                                                                                                                                                                                 |
| ------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Operational signers | [Passkey](/wallets/concepts/wallet-signers#passkey) (user confirmation for sensitive actions)<br />[Server key](/wallets/concepts/wallet-signers#server-key) (customer-managed, scoped permissions) |
| Recovery signers    | [Email OTP](/wallets/concepts/wallet-signers#email-otp)<br />[Managed support center](/wallets/concepts/wallet-signers#managed-support-center) (optional)                                           |

## Scoped custody

Some products need a self-custodial user wallet *plus* a limited, revocable company signer (for example, for repayments, subscriptions, or card settlement).

| Slot                | Recommended signers                                                                                                                                                                                                                                                           |
| ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Operational signers | User: [Device key](/wallets/concepts/wallet-signers#device-key) or [Passkey](/wallets/concepts/wallet-signers#passkey)<br />Company (scoped, revocable): [Server key](/wallets/concepts/wallet-signers#server-key) or [Cloud KMS](/wallets/concepts/wallet-signers#cloud-kms) |
| Recovery signers    | User recovery: [Email OTP](/wallets/concepts/wallet-signers#email-otp) (recommended)<br />Optional hard fallback: [Externally custodied key](/wallets/concepts/wallet-signers#externally-custodied-key)                                                                       |

<Note>
  Whether a scoped company signer makes your company a custodian depends on whether you can unilaterally execute or block transactions and whether the user can revoke your access. See [Custody modalities](/wallets/concepts/custody-modalities) for the definition.
</Note>


# Custody Modalities
Source: https://docs.crossmint.com/wallets/concepts/custody-modalities

Understand custodial, non-custodial, and hybrid custody models in Crossmint wallets.

This guide explains what custody means in the context of wallets, why it matters, and how Crossmint lets you choose (and evolve) the right custody modality for your use case.

<Info>
  If you have not yet read it, start with the [Architecture overview](/wallets/architecture). This guide builds on the concepts introduced there.
</Info>

Crossmint wallets support **flexible custody**. You can deploy custodial, non-custodial, or hybrid configurations using the same wallet primitive and APIs. Because wallets are smart contracts, you can migrate between custody modalities over time without changing wallet addresses.

## What Is Custody?

A **[custodian](/introduction/glossary)** of a wallet is any entity for which **either** of the following is true:

1. The entity can **unilaterally execute transactions** on the wallet (for example, transferring funds out).
2. The entity can **unilaterally block transactions** on the wallet (for example, preventing a transfer from going through).

If an entity has either of these powers, it is a custodian of that wallet.

**Non-custodial** means your company is *not* a custodian. Your company cannot unilaterally move funds and cannot unilaterally prevent them from moving.

<Note>
  A wallet can have multiple custodians. Custody is not exclusive — it applies independently to every entity that meets either of the two criteria above.
</Note>

## Why Custody Matters

### Regulation and compliance

In many jurisdictions, if you are a custodian of wallets holding user funds, you must comply with additional regulatory obligations (for example, AML programs, money transmitter registration, and relevant licensing).

Some companies choose to take on these obligations. Others prefer to avoid custodial responsibilities. Either path can be valid, but it is important to understand the operational overhead and compliance costs that come with custody.

A third option is to use a **licensed third-party custodian** to hold custody on your behalf. This can be a good middle ground when you need custodial features without obtaining licenses yourself.

### Business control

There are scenarios where you want the ability to move funds from a backend (for example, for company treasury wallets, automated flows, or delegated workflows). In these cases, a custodial architecture may be the right choice.

Hybrid approaches are also common. For example, you can keep a user as the primary custodian while adding a scoped company signer with revocable permissions. See [Common Signer Configurations](/wallets/concepts/common-signer-configurations#scoped-custody) for a concrete example.

### User perception

In many applications — especially fintech products and savings platforms — users may prefer to be the ultimate custodians of their funds. A non-custodial architecture can be a competitive differentiator because it guarantees that no company can unilaterally access or freeze funds.

### Security

Custodial and non-custodial architectures have different threat models:

* In a **custodial** architecture where your company holds keys, a compromise of your infrastructure can impact many wallets at once. The benefit is that security investment can be centralized.
* In a **non-custodial** architecture where users control their own keys, large-scale compromise is harder because each user is an independent endpoint. The tradeoff is that individual users may be targeted through phishing, social engineering, or device compromise.

Neither model is inherently more secure. The right choice depends on your threat model, your users, and your operational capabilities.

### User experience

Custody is not a reliable proxy for user experience.

Modern smart contract wallets and signing mechanisms (passkeys, device keys, user-friendly recovery, and gas sponsorship) make non-custodial architectures capable of a fully seamless UX.

### Cost

Non-custodial architectures are often cheaper to operate. Using user-controlled signers reduces the need for key management infrastructure, custodial insurance, and custody licensing.

## Custody in Crossmint

Crossmint wallets implement custody through **signers**. The custody modality of a wallet is determined by the signer configuration, not by the wallet itself.

<Info>
  Crossmint never takes custody of your or your users' funds. Custody is held by your users, your company, or a third-party custodian you choose.
</Info>

This means you can:

* Deploy **non-custodial wallets** using user-controlled operational signers (for example, [device keys](/wallets/concepts/wallet-signers#device-key) or [passkeys](/wallets/concepts/wallet-signers#passkey)).
* Deploy **custodial wallets** using server-side operational signers (for example, [server keys](/wallets/concepts/wallet-signers#server-key) or [Cloud KMS](/wallets/concepts/wallet-signers#cloud-kms)).
* Integrate a **licensed third-party custodian** to operate signers on your behalf.
* Deploy **hybrid configurations** (for example, user custody plus a scoped operational company signer).
* Mix custody modalities across geographies while keeping one implementation.
* Migrate between modalities over time by rotating signers without changing wallet addresses.

<Info>
  A wallet is only non-custodial (from your company’s perspective) if your company cannot unilaterally execute or block transactions.
</Info>

## Next steps

<CardGroup>
  <Card title="Wallet Signers" icon="key" href="/wallets/concepts/wallet-signers">
    Learn the available operational and recovery signer types.
  </Card>

  <Card title="Common Signer Configurations" icon="sitemap" href="/wallets/concepts/common-signer-configurations">
    See recommended signer setups for common wallet architectures.
  </Card>
</CardGroup>


# Signer Decision Tree
Source: https://docs.crossmint.com/wallets/concepts/decision-tree

A step-by-step guide to picking the right operational and recovery signers for your wallet architecture.

Use this decision tree to identify the right signer configuration for your use case. If you are not yet familiar with the different signer types, start with [Wallet Signers](/wallets/concepts/wallet-signers) first.

## Step 1: Who is the wallet for?

| Controller                                         | Go to           |
| -------------------------------------------------- | --------------- |
| End users (consumers, retail)                      | Step 2a (below) |
| Your company (treasury, operations, disbursements) | Step 2b (below) |
| AI agents                                          | Step 2c (below) |

## Step 2a: User wallets — does the user need self-custody?

| Answer                                               | Operational signer                                                                                                                                                                                  | Recovery signer                                                                                                        | Configuration                                                                                          |
| ---------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
| Yes — user must be sole custodian                    | [Device key](/wallets/concepts/wallet-signers#device-key) or [Passkey](/wallets/concepts/wallet-signers#passkey)                                                                                    | [Email OTP](/wallets/concepts/wallet-signers#email-otp) + optional [SMS OTP](/wallets/concepts/wallet-signers#sms-otp) | [Non-custodial user wallet](/wallets/concepts/common-signer-configurations#non-custodial-user-wallets) |
| No — your company manages wallets on behalf of users | [Cloud KMS](/wallets/concepts/wallet-signers#cloud-kms) or [Server key](/wallets/concepts/wallet-signers#server-key)                                                                                | [Cloud KMS (recovery)](/wallets/concepts/wallet-signers#cloud-kms-recovery)                                            | [Custodial user wallet](/wallets/concepts/common-signer-configurations#custodial-user-wallets)         |
| Hybrid — user custody with limited company access    | User: [Device key](/wallets/concepts/wallet-signers#device-key) / [Passkey](/wallets/concepts/wallet-signers#passkey) + Company: [Server key](/wallets/concepts/wallet-signers#server-key) (scoped) | [Email OTP](/wallets/concepts/wallet-signers#email-otp)                                                                | [Scoped custody](/wallets/concepts/common-signer-configurations#scoped-custody)                        |

<Accordion title="Choosing between device key and passkey">
  | Criterion                              | Device key                           | Passkey                                  |
  | -------------------------------------- | ------------------------------------ | ---------------------------------------- |
  | Silent signing (no user prompt per tx) | ✓ (default)                          | ✗ (always requires biometric)            |
  | Cross-device sync                      | ✗ (single device)                    | ✓ (via iCloud, Google, 1Password)        |
  | Best for                               | High-frequency actions, invisible UX | Explicit user confirmation, multi-device |
</Accordion>

## Step 2b: Company wallets — what level of key security do you need?

| Scenario                                     | Operational signer                                        | Recovery signer                                                                                                                                                      | Configuration                                                                      |
| -------------------------------------------- | --------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------- |
| Production treasury or high-value operations | [Cloud KMS](/wallets/concepts/wallet-signers#cloud-kms)   | [Cloud KMS (recovery)](/wallets/concepts/wallet-signers#cloud-kms-recovery) in a separate account/region                                                             | [Treasury wallet](/wallets/concepts/common-signer-configurations#treasury-wallets) |
| Development, staging, or low-risk operations | [Server key](/wallets/concepts/wallet-signers#server-key) | [Cloud KMS (recovery)](/wallets/concepts/wallet-signers#cloud-kms-recovery) or [Externally custodied key](/wallets/concepts/wallet-signers#externally-custodied-key) | [Treasury wallet](/wallets/concepts/common-signer-configurations#treasury-wallets) |

## Step 2c: Agent wallets — who hosts the agent?

| Host                                                | Operational signer                                                                                                                    | Recovery signer                                                                       | Configuration                                                                                  |
| --------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- |
| User-hosted (self-managed infrastructure)           | [Server key](/wallets/concepts/wallet-signers#server-key) or [Cloud KMS](/wallets/concepts/wallet-signers#cloud-kms)                  | [Externally custodied key](/wallets/concepts/wallet-signers#externally-custodied-key) | [User-hosted agent](/wallets/concepts/common-signer-configurations#user-hosted-agents)         |
| Platform-hosted (you run agents on behalf of users) | User: [Passkey](/wallets/concepts/wallet-signers#passkey) + Agent: [Server key](/wallets/concepts/wallet-signers#server-key) (scoped) | [Email OTP](/wallets/concepts/wallet-signers#email-otp)                               | [Platform-hosted agent](/wallets/concepts/common-signer-configurations#platform-hosted-agents) |

## Step 3: Do you need account recovery?

Almost always **yes**. The only exception is server-side wallets where you control all key material and have your own backup procedures.

| Wallet type     | Minimum recommended recovery                                                                                                                     | Enhanced recovery                                                                                                                                   |
| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------- |
| User wallets    | [Email OTP](/wallets/concepts/wallet-signers#email-otp)                                                                                          | Email OTP + [SMS OTP](/wallets/concepts/wallet-signers#sms-otp) + [Managed support center](/wallets/concepts/wallet-signers#managed-support-center) |
| Company wallets | [Cloud KMS (recovery)](/wallets/concepts/wallet-signers#cloud-kms-recovery)                                                                      | Cloud KMS + [Externally custodied key](/wallets/concepts/wallet-signers#externally-custodied-key)                                                   |
| Agent wallets   | [Email OTP](/wallets/concepts/wallet-signers#email-otp) or [Externally custodied key](/wallets/concepts/wallet-signers#externally-custodied-key) | Depends on hosting model                                                                                                                            |

<Note>
  For enterprise clients, the Crossmint team is happy to provide architectural guidance and review your setup before you go to production. <a href="https://www.crossmint.com/contact/sales">Get in touch</a> to schedule a session with the solutions team.
</Note>

## Next Steps

<CardGroup>
  <Card title="Registering a Signer" icon="plus" href="/wallets/guides/signers/registering-a-signer">
    Learn how to add operational signers to a wallet.
  </Card>

  <Card title="Common Signer Configurations" icon="sitemap" href="/wallets/concepts/common-signer-configurations">
    Blueprints for common configurations we see amongst our clients.
  </Card>
</CardGroup>


# Yield
Source: https://docs.crossmint.com/wallets/concepts/wallet-extensions/yield-introduction

Earn money from wallet balances

This section introduces the main mechanisms to generate yield, how they differ, and how they can be combined to maximize returns while keeping funds accessible and secure within the same wallet.

## Yield Strategies

There are two primary ways to earn yield from stablecoins:

* **Yield from reserves** — earned from the interest generated by the stablecoin's underlying reserves, which are typically invested in U.S. Treasury bills or equivalent cash instruments.
* **Yield from staking** — earned by locking or delegating tokens to validators or protocols that generate onchain returns.

These mechanisms are not mutually exclusive — the same asset can simultaneously generate passive income from its reserves while being staked to earn additional yield.

### 1. Yield from reserves

The table below compares different ways to access stablecoin-based yield, their setup requirements, and key trade-offs.

| Option                    | Description                                                                      | Notes                                                                                                                                                                                                                                                    |
| ------------------------- | -------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| USDC, USDT                | Negotiate a direct revenue-sharing agreement with the stablecoin issuer.         | Typically limited to large partners; smaller revenue share; allows direct staking.                                                                                                                                                                       |
| USDG                      | Use a stablecoin that automatically accrues interest to holders or distributors. | Easier to get started; usually requires swapping to USDC/USDT before staking or transferring out, if the recipient prefers another stable. By end of Q4 / beginning of Q1, this will be achievable via the transfer API without requiring a manual swap. |
| Issue your own stablecoin | Create your proprietary stablecoin backed by your own reserves.                  | Around 10-20 bps more yield and control vs a non-standard token; higher setup costs, complexity, and slower go-to-market. Similar swapping requirements vs USDG.                                                                                         |

### 2. Yield from staking

In addition to stablecoin yield, wallets can also earn yield through staking — by delegating tokens to validators or liquidity pools.

Protocols such as **Aave** and **Morpho** offer staking opportunities, and Crossmint wallets are compatible with any of them. [Yield.xyz](https://yield.xyz) provides integrations with all top DeFi protocols, making it easy to connect your Crossmint wallets to yield-generating strategies. See our [Generate Yield guide](/wallets/guides/wallet-extensions/generate-yield) for a step-by-step integration walkthrough.

## Get Started

<CardGroup>
  <Card title="Offer Yield" icon="chart-line-up" href="/wallets/guides/wallet-extensions/generate-yield">
    Follow the step-by-step guide to start earning yield from your wallet balances
  </Card>

  <Card title="Try the Demo" icon="building-columns" href="https://fintech-starter-app.demos-crossmint.com/">
    Explore a live fintech app demo showcasing yield and wallet features
  </Card>
</CardGroup>


# Wallet Signers
Source: https://docs.crossmint.com/wallets/concepts/wallet-signers

Understand the different signer types available for Crossmint wallets and how they work.

This guide covers the different signer types Crossmint supports — what they are, how they work, and when to use each one. For a step-by-step decision guide, see [Signer Decision Tree](/wallets/concepts/decision-tree).

Once you have chosen your signers, head to [Registering a Signer](/wallets/guides/signers/registering-a-signer) to learn how to add them to a wallet.

<Warning>
  **Terminology update:** In previous versions of the Crossmint documentation and SDKs, the terms **"admin signer"** and **"delegated signer"** were used. These have been renamed:

  * **Admin signer** is now called **recovery signer**.
  * **Delegated signer** is now called **operational signer**.

  Current SDK method names (such as `addDelegatedSigner` and `delegatedSigners`) still use the old terminology. These will be updated in the next breaking API/SDK release. See the [Glossary](/introduction/glossary) for full definitions.
</Warning>

## What Is a Signer?

As a quick refresher from the [Architecture overview](/wallets/architecture): signers are keys and other mechanisms that authorize operations on a wallet. They go beyond what most blockchains natively support. Rather than being limited to raw secp256k1 or ed25519 keypairs, Crossmint wallets support a wide range of signing mechanisms — including P-256 keys native to device secure enclaves, passkeys backed by biometrics, cloud key management services, email- and phone-based credentials, and more.

This flexibility is intentional. A wallet may need to be controlled by a user on a mobile app, an enterprise treasury team using HSMs, an AI agent running in the cloud, or all three at different times. The signer model is designed to make wallets securely controllable regardless of the operating environment.

## Signer Slots in a Wallet

<img alt="Crossmint wallet signer architecture — operational signers and recovery signers" />

Every Crossmint wallet supports two categories of signers, each serving a different purpose:

### Operational Signers

Operational signers handle the day-to-day operations of a wallet — authorizing transactions, signing messages, and interacting with protocols.

The right operational signer depends on who or what controls the wallet:

* **User wallets** — A key stored on the user's own device. For example, a passkey backed by Face ID or fingerprint, or a credential derived inside the device's secure enclave. The user signs each time they transact.
* **Server-side or treasury wallets** — A key stored in your cloud infrastructure, such as an environment variable (for lower-stakes use cases) or a cloud key management service like AWS KMS, Azure Key Vault, or GCP Cloud HSM. No user interaction required.
* **AI agent wallets** — A key available to the agent at runtime. For example, a securely injected secret that the agent uses to autonomously sign transactions on its own behalf.

When choosing an operational signer, optimize for:

<CardGroup>
  <Card title="Performance and cost" icon="gauge-high">
    Operational signers are used for every transaction. They should add minimal latency and not become a throughput bottleneck.
  </Card>

  <Card title="Native fit for the controlling entity" icon="bullseye">
    The signer should live where decisions are made. For a user, that is their device. For a server, that is your cloud. For an agent, that is its runtime environment.
  </Card>
</CardGroup>

### Recovery Signers

Recovery signers are used to regain access to a wallet when the operational signer is no longer available — for example, when a user gets a new phone and loses access to their old device key, or when a company rotates an infrastructure key.

Recovery signers allow you to enroll a new operational signer on a new device or environment — in a secure and self-custodial way — without changing the smart wallet's address or losing any of its assets and history.

Some examples of recovery signers:

* **Email-based recovery** — The user proves ownership of their email address to authorize the enrollment of a new device. A common pattern is to email the user a one-time code when they log in on a new phone.
* **Phone number-based recovery** — Similar to email, but via SMS.
* **Managed recovery (contact center)** — For enterprise clients or high-value wallets, Crossmint can support recovery flows that involve identity verification through a contact center — for cases where users may need human-assisted recovery if they have lost all credentials.

When choosing recovery signers, optimize for:

<CardGroup>
  <Card title="Identity guarantees" icon="shield-check">
    The most critical property is that only the true wallet owner can trigger a recovery. Choose a mechanism with strong authentication — ideally one that is hard to social-engineer or SIM-swap.
  </Card>

  <Card title="Acceptable friction" icon="clock">
    Recovery is an infrequent operation. A small amount of added friction is acceptable and often desirable, since it raises the bar for attackers.
  </Card>
</CardGroup>

## Designing Your Wallet Architecture

<Note>
  Crossmint abstracts away the complexity of implementing any of these signers. You do not need to understand the cryptographic internals or manage key derivation, storage, or rotation yourself — you just pick the signer types that make sense for your use case, and Crossmint handles the rest.
</Note>

When setting up your wallet architecture, the two key decisions are:

1. **What are my operational signers?** Pick something that lives where the controlling entity — user, server, or agent — naturally operates.
2. **How will the wallet be recovered?** Pick recovery signers that give you strong guarantees that only the legitimate owner can regain access.

Most wallet architectures use one operational signer and at least one recovery signer. For high-security use cases, you may want multiple recovery options (e.g., both email and phone) to reduce the chance of permanent lockout.

<Card title="Not sure which signers to pick?" icon="map" href="/wallets/concepts/decision-tree">
  Use the decision tree to find the right signer configuration for your use case.
</Card>

## Signer Types

### Operational Signers

| Signer                              |   User wallets   |   Company / server wallets   | Agent wallets | Cost per signature                | Performance                         |
| ----------------------------------- | :--------------: | :--------------------------: | :-----------: | --------------------------------- | ----------------------------------- |
| [Device key](#device-key)           |         ✓        |                              |       ✓       | Free                              | Highest — no network round-trip     |
| [Passkey](#passkey)                 |         ✓        |     ✓ (human dashboards)     |               | Free                              | Highest — no network round-trip     |
| [Server key](#server-key)           |                  | ✓ (programmatic, lower-risk) |       ✓       | Free                              | Highest — no network round-trip     |
| [Cloud KMS](#cloud-kms)             |                  |       ✓ (programmatic)       |       ✓       | Low (\~\$30 / million ops on AWS) | High — \~10 ms latency, \~1,000 TPS |
| [API key (deprecated)](#api-key)    |                  |          ✓ (legacy)          |   ✓ (legacy)  | Deprecated                        | Deprecated                          |
| [External wallet](#external-wallet) | ✓ (crypto users) |               ✓              |       ✓       | Free                              | Highest — no network round-trip     |

***

#### Device key

P-256 keys that are non-extractable and generated securely inside the secure storage of the user's phone, computer, or browser (e.g., iOS Secure Enclave, Android Keystore, or the browser's built-in credential store).

<AccordionGroup>
  <Accordion title="Additional notes">
    * By default, signing is silent — transactions can be authorized without requiring the user to actively confirm each one. However, device keys can optionally be configured to require biometric authentication on every use, or after a configurable idle period.
    * If a device does not have a dedicated secure enclave, Crossmint automatically falls back to the most secure storage mechanism available on that platform.
  </Accordion>
</AccordionGroup>

<Card title="Device key implementation guide" icon="arrow-right" href="/wallets/guides/signers/device-key" />

***

#### Passkey

Passkeys are <a href="https://www.w3.org/TR/webauthn-3/">WebAuthn</a> credentials stored on-device and synchronized across devices by platform providers such as Apple Keychain, Google Password Manager, or third-party password managers like 1Password and Dashlane.

Every transaction signed with a passkey requires the user to authenticate using their device's biometric sensor — Face ID, Touch ID, fingerprint reader, or Windows Hello — or their password manager's unlock mechanism. This makes passkeys one of the most secure operational signer options because each signature is explicitly authorized by the user.

Passkeys are available across the user's ecosystem of devices rather than being tied to a single one. For example, a passkey created on an iPhone and synced through iCloud Keychain is immediately available on the user's iPad and Mac. Similarly, passkeys stored in 1Password or Google Password Manager are accessible on any device where that password manager is installed.

<AccordionGroup>
  <Accordion title="Additional notes">
    * The cross-device synchronization is convenient but introduces some UX edge cases. A user who changes ecosystems (for example, switching from Apple to Android) may not have immediate access to their passkeys unless they use a cross-platform password manager like 1Password. Using passkeys in conjunction with a recovery signer is recommended to handle these scenarios.
    * Passkeys require a user interaction (biometric or password manager unlock) for every signing operation. This is a security feature, not a limitation — but it means passkeys are best suited for workflows where explicit user confirmation per transaction is acceptable.
    * On devices without a biometric sensor, the passkey provider falls back to a PIN or device password for confirmation.
  </Accordion>
</AccordionGroup>

<Card title="Passkey implementation guide" icon="arrow-right" href="/wallets/guides/signers/passkey" />

***

#### Server key

A P-256 or native blockchain keypair injected as an environment variable (or equivalent secret) into a server-side application. Signing happens entirely in-process with no external network call, making this the lowest-latency option available.

<AccordionGroup>
  <Accordion title="Additional notes">
    Because this key lives as a secret in your infrastructure, enforcing regular rotations is recommended — for example, quarterly — to limit exposure in the event of a compromised environment, a departed employee, or an infrastructure incident.
  </Accordion>
</AccordionGroup>

<Card title="Server key implementation guide" icon="arrow-right" href="/wallets/guides/signers/server-key" />

***

#### Cloud KMS

A signing key generated and stored inside a cloud key management service — AWS KMS, Azure Key Vault, or GCP Cloud HSM. The key is non-extractable by design: no employee at your company (or at the cloud provider) can ever retrieve the raw key material.

Cloud KMS signers support advanced enterprise security controls natively, including IP allowlisting, cloud IAM-based access policies, rate limiting, circuit breakers, and detailed audit logs and alerting.

This is the most secure option for server-side signing: bank-grade key security without the key ever leaving your cloud.

<AccordionGroup>
  <Accordion title="Performance and cost details">
    **Performance:** Up to \~1,000 signing operations per second per key, with latency as low as \~10 ms. Slightly higher latency than a plain server key due to the network call to the KMS endpoint, but well within acceptable range for most production workloads.

    **Cost:** Not free, but low. On AWS KMS, signing operations start at approximately $0.03 per 10,000 requests (~$30 per million).
  </Accordion>
</AccordionGroup>

<Card title="Cloud KMS implementation guide" icon="arrow-right" href="/wallets/guides/signers/cloud-kms" />

***

#### API key

<Warning>
  API key signers are deprecated and will be removed in a future release. All signer types require an API key for authentication, but an API key is not a valid standalone signer.

  If you use API key signers today for server-side or agent operations, migrate to [server keys](#server-key) instead.
</Warning>

In earlier versions of the Crossmint Wallets API, an API key could be used directly as an operational signer. This model is deprecated in favor of dedicated signer types that separate authentication (API key) from transaction authorization (signer key).

<Card title="API key migration guide" icon="arrow-right" href="/wallets/guides/signers/api-key" />

***

#### External wallet

An existing blockchain wallet or keypair — such as a MetaMask wallet, a Phantom wallet, or a raw keypair — used as an operational signer on a Crossmint smart wallet. The external wallet signs transactions on behalf of the smart wallet, and the user retains full control of the signing key.

This signer type is designed for **crypto-native users who already have a wallet** and want to use it to control a Crossmint smart wallet. It is not intended for general consumer onboarding.

**Best used for**: Users, companies, or agents that already hold blockchain keypairs and want to connect them to Crossmint wallets without adopting a new key management approach.

<AccordionGroup>
  <Accordion title="Additional notes">
    * Custody depends on who controls the external wallet. If the user holds the private key, the wallet is non-custodial. If a server or third party holds it, the wallet is custodial.
    * Every transaction requires a signature from the external wallet. For user-facing wallets, this means the user must confirm each operation in their wallet application (for example, MetaMask or Phantom).
    * External wallets do not benefit from Crossmint's built-in recovery mechanisms. If the user loses access to the external wallet's private key, wallet recovery depends on whatever backup the user has for that key.
  </Accordion>
</AccordionGroup>

<Card title="External wallet implementation guide" icon="arrow-right" href="/wallets/guides/signers/external-wallet" />

### Recovery Signers

| Signer                                                | User wallets | Company / server wallets | Agent wallets | Cost    | Recoverability                                   | Security |
| ----------------------------------------------------- | :----------: | :----------------------: | :-----------: | ------- | ------------------------------------------------ | -------- |
| [Email OTP](#email-otp)                               |       ✓      |        ✓ (admins)        |       ✓       | Low     | High                                             | Medium   |
| [SMS OTP](#sms-otp)                                   |       ✓      |                          |       ✓       | Medium  | Medium                                           | Medium   |
| [Social recovery](#social-recovery)                   |       ✓      |                          |               | Low     | Low alone / High when paired                     | Medium   |
| [Managed support center](#managed-support-center)     |       ✓      |             ✓            |               | Highest | Highest                                          | Highest  |
| [Externally custodied key](#externally-custodied-key) |       ✓      |             ✓            |       ✓       | Lowest  | High (sophisticated users) / Low (general users) | High     |
| [Cloud KMS (recovery)](#cloud-kms-recovery)           |              |             ✓            |       ✓       | Low     | High                                             | Highest  |

***

#### Email OTP

The user receives a one-time code to their email address to authenticate and authorize the enrollment of a new operational signer. Simple to set up, works across devices and platforms, and most users already have a stable email address.

**Best used for**: User wallets, agent wallets, and company wallets where admins need a fallback recovery path.

|                    |                                                                                                                                    |
| ------------------ | ---------------------------------------------------------------------------------------------------------------------------------- |
| **Cost**           | Low                                                                                                                                |
| **Recoverability** | High — email addresses tend to be stable and long-lived                                                                            |
| **Security**       | Medium — protected by the security of the user's email account; pairing with a second factor is recommended for high-value wallets |

<AccordionGroup>
  <Accordion title="How does it work?">
    Email OTP recovery uses a master secret that is deterministically derived inside a Trusted Execution Environment (TEE) running open-source, verifiable code. The master secret is never stored anywhere — it only exists ephemerally during derivation and is immediately encrypted for secure distribution.

    **Key components:**

    * **TEE (Trusted Execution Environment)**: A hardware-attested secure enclave (Intel TDX) that derives master secrets using HKDF from a TEE-protected root key combined with the user's identifier and email address. The TEE's authenticity is cryptographically verifiable via Intel TDX attestation.
    * **Device identity keys**: Each user device generates a P-256 ECDH keypair stored securely in the browser's IndexedDB. These keys are non-extractable and used to decrypt the encrypted master secret. The device identity keys never leave the device.
    * **Encrypted master secret**: After authentication, the TEE encrypts the master secret directly to the device's public key using HPKE (Hybrid Public Key Encryption). This encrypted master secret is stored by Crossmint's relay service but can only be decrypted by the device holding the corresponding private key.

    **Authentication flow:**

    When a user needs to recover on a new device, they authenticate via email using a one-time password (OTP):

    1. The device generates identity keys and requests onboarding from the TEE.
    2. The TEE generates a 9-digit OTP and encrypts it using Format Preserving Encryption (FPE) to the device's public key.
    3. The encrypted OTP is sent to the user's email — neither Crossmint nor the host application can read it.
    4. The user enters the encrypted OTP, which the device decrypts locally.
    5. The device sends the decrypted OTP to the TEE via an HPKE-encrypted channel.
    6. The TEE verifies the OTP, confirming the user controls the email.
    7. The TEE derives the master secret and encrypts it to the device's public key using HPKE authenticated encryption.
    8. The encrypted master secret is stored by Crossmint's relay for future access.

    At no point do the host application or Crossmint have access to the unencrypted master secret or private keys.
  </Accordion>

  <Accordion title="Why is this non-custodial?">
    Neither the host application nor Crossmint can unilaterally access or control the user's keys.

    * **Master secret derivation**: The master secret is cryptographically bound to the user's email through HKDF derivation. Only someone who can authenticate with that email can trigger the TEE to derive and distribute the master secret.
    * **Device-only decryption**: Crossmint stores only the encrypted master secret, which is encrypted using HPKE directly to the device's public key. Without the device's private identity key (which never leaves the device and is non-extractable), the encrypted master secret cannot be decrypted.
    * **TEE attestation**: The TEE code is open-source and its execution is verifiable through Intel TDX hardware attestation. Anyone can verify that the deployed TEE code matches the audited source code and that it only derives master secrets after proper authentication.
    * **Authentication requirement**: Every device must complete TEE-attested authentication (OTP verification) before receiving an encrypted master secret. The OTP is encrypted to the device and cannot be intercepted by Crossmint or the host application.

    **What Crossmint cannot do:**

    * Decrypt the encrypted master secret without the device's private key.
    * Derive the master secret without the TEE's protected root key.
    * Bypass the OTP authentication flow enforced by the TEE.
    * Sign transactions on behalf of users without their device and authentication.
  </Accordion>
</AccordionGroup>

<Card title="Email OTP implementation guide" icon="arrow-right" href="/wallets/guides/signers/email-otp" />

***

#### SMS OTP

Similar to email OTP, but delivered via SMS — or optionally via WhatsApp, for markets where it is the preferred channel.

**Best used for**: Consumer user wallets and agent wallets, particularly in markets where SMS or WhatsApp is more accessible than email.

|                    |                                                                                                                    |
| ------------------ | ------------------------------------------------------------------------------------------------------------------ |
| **Cost**           | Medium — SMS delivery has per-message costs                                                                        |
| **Recoverability** | Medium — phone numbers change more often than email addresses, and porting a number to a new carrier can take time |
| **Security**       | Medium — vulnerable to SIM-swap attacks; not recommended as the sole recovery mechanism for high-value wallets     |

<AccordionGroup>
  <Accordion title="How does it work?">
    SMS OTP recovery uses the same TEE-based architecture as email OTP. The master secret is deterministically derived inside a hardware-attested Trusted Execution Environment (Intel TDX) and is never stored in the clear.

    The flow is identical to email OTP, except that the one-time password is delivered via SMS (or optionally WhatsApp) instead of email:

    1. The device generates identity keys and requests onboarding from the TEE.
    2. The TEE generates a 9-digit OTP and encrypts it to the device's public key.
    3. The encrypted OTP is sent to the user's phone number via SMS or WhatsApp — neither Crossmint nor the host application can read it.
    4. The user enters the OTP, which the device decrypts locally.
    5. The device sends the decrypted OTP to the TEE via an HPKE-encrypted channel.
    6. The TEE verifies the OTP, derives the master secret, and encrypts it to the device's public key.

    All cryptographic operations are performed locally on the user's device. The master secret and derived private keys are immediately wiped from memory after use.
  </Accordion>

  <Accordion title="Why is this non-custodial?">
    The same non-custodial guarantees as email OTP apply. The phone number is used only to prove identity — it is not used to derive or store keys.

    * **TEE-enforced authentication**: The master secret can only be derived after the user proves control of their phone number through the TEE-attested OTP flow.
    * **Device-only decryption**: The encrypted master secret can only be decrypted by the device's non-extractable private identity key.
    * **Verifiable execution**: The TEE code is open-source and its integrity is verifiable via Intel TDX attestation.

    Crossmint cannot decrypt the master secret, bypass the OTP flow, or sign transactions without the user's device and authentication.
  </Accordion>
</AccordionGroup>

<Card title="SMS OTP implementation guide" icon="arrow-right" href="/wallets/guides/signers/sms-otp" />

***

#### Social recovery

Designate a trusted contact — a friend, family member, or colleague — who can authorize wallet recovery on the owner's behalf via their own email or phone OTP. The trusted contact does not have access to the wallet itself; they can only co-authorize a recovery event.

**Best used for**: Consumer user wallets, ideally paired with another recovery mechanism rather than used in isolation.

|                    |                                                                                        |
| ------------------ | -------------------------------------------------------------------------------------- |
| **Cost**           | Low — same as email or SMS OTP                                                         |
| **Recoverability** | Low on its own; High when paired with another recovery signer                          |
| **Security**       | Medium — depends on the trustworthiness and security hygiene of the designated contact |

<Note>
  Social recovery is coming in Q2 2026.
</Note>

<Card title="Social recovery details" icon="arrow-right" href="/wallets/guides/signers/social-recovery" />

***

#### Managed support center

A white-glove recovery option: the wallet owner contacts a specialized support center, completes identity verification (KYC), and a trained agent facilitates the enrollment of a new operational signer. This is the most robust recovery option available and is best reserved as a last resort for situations where all other recovery methods have been exhausted.

**Best used for**: High-value user wallets and company wallets. Best deployed in tandem with another recovery mechanism as a safety net.

|                    |                                                                                                                      |
| ------------------ | -------------------------------------------------------------------------------------------------------------------- |
| **Cost**           | Highest                                                                                                              |
| **Recoverability** | Highest — human-in-the-loop with identity verification means recovery is possible even when all credentials are lost |
| **Security**       | Highest — KYC-based verification provides the strongest identity guarantees                                          |

<Card title="Managed support center details" icon="arrow-right" href="/wallets/guides/signers/managed-support-center" />

***

#### Externally custodied key

The wallet owner generates and stores a cryptographic key or passphrase in cold storage — for example, a hardware wallet, an encrypted offline backup, or a printed seed phrase kept in a secure location. When recovery is needed, they present this credential to authorize enrollment of a new operational signer.

**Best used for**: All wallet types, but the practical effectiveness depends heavily on the owner's level of technical sophistication. Crypto-native users and enterprises with proper key management procedures find this highly reliable. General consumers often struggle with cold storage and are at risk of losing the backup itself.

|                    |                                                                                                |
| ------------------ | ---------------------------------------------------------------------------------------------- |
| **Cost**           | Lowest — no ongoing infrastructure cost                                                        |
| **Recoverability** | High for sophisticated users; Low for general consumers who may lose or mismanage cold storage |
| **Security**       | High — the key is entirely offline and outside of any third-party infrastructure               |

<Card title="External wallet implementation guide" icon="arrow-right" href="/wallets/guides/signers/external-wallet" />

***

#### Cloud KMS (recovery)

A non-extractable key stored in a cloud key management service — AWS KMS, Azure Key Vault, or GCP Cloud HSM — configured with the most restrictive access settings available. When an operational signer needs to be rotated (for example, after a suspected compromise or a scheduled key rotation), the Cloud KMS recovery key authorizes the enrollment of the new operational signer.

Because the recovery key never leaves the KMS and access is governed by your cloud IAM policies, this approach provides the strongest possible security guarantees for server-side recovery. No individual employee can trigger a recovery unilaterally — access can be scoped to require multi-party approval, specific IP ranges, or other controls enforced at the cloud infrastructure level.

**Best used for**: Company and server wallets that need to rotate operational server keys on a regular or incident-driven basis. Also appropriate for custodial architectures where the operator manages keys on behalf of users and needs a secure, auditable path to rotate those keys.

|                    |                                                                                                          |
| ------------------ | -------------------------------------------------------------------------------------------------------- |
| **Cost**           | Low — same per-operation pricing as Cloud KMS operational signers (\~\$30 / million ops on AWS)          |
| **Recoverability** | High — always available as long as your cloud infrastructure is operational                              |
| **Security**       | Highest — non-extractable key, full cloud IAM controls, audit logging, and optional multi-party approval |

<Card title="Cloud KMS implementation guide" icon="arrow-right" href="/wallets/guides/signers/cloud-kms" />

## Related guides

<CardGroup>
  <Card title="Decision Tree" icon="map" href="/wallets/concepts/decision-tree">
    Step-by-step guide to picking the right signers for your use case.
  </Card>

  <Card title="Common Signer Configurations" icon="sitemap" href="/wallets/concepts/common-signer-configurations">
    Pre-built signer configurations for common wallet architectures.
  </Card>

  <Card title="Registering a Signer" icon="key" href="/wallets/guides/signers/registering-a-signer">
    Learn how to add operational signers to a wallet.
  </Card>
</CardGroup>


# Bring Your Own Auth
Source: https://docs.crossmint.com/wallets/guides/bring-your-own-auth

Bring your own auth provider

Crossmint provides turn-key connectors for the most popular auth providers, including Auth0, Firebase, Supabase, Stytch, Cognito, and Kinde.

When you bring your own auth, Crossmint automatically extracts the user ID from your provider's JWT and assigns it to the wallet's `owner` property. Wallet creation, transaction signing, and balance reads all work the same way regardless of which auth provider you use.

If you're just getting started or prototyping, [Crossmint Auth](/authentication/introduction) is a great way to move fast in staging before connecting your own provider.

## Prerequisites

* **API Key**: Ensure you have an API key with the scopes: `wallets.create`.

## Using your own auth provider

<Tabs>
  <Tab title="React">
    <Steps>
      <Step title="Configure JWT Authentication in the Crossmint Console">
        1. Navigate to your project in the Crossmint Console.
        2. Go to the API Keys section from the sidebar.
        3. Scroll down to the JWT authentication section.
        4. Choose your preferred authentication method:

        * **3P Auth providers**: Select from supported providers such as Auth0, Stytch, Cognito, Firebase, Kinde, or Supabase. Enter any required environment IDs or configuration details.
        * **Custom tokens**: Opt to issue and manage your own JWTs.

        5. After making your selection and providing any necessary details, click **Save JWT auth settings** to apply your configuration.

        <img alt="JWT Authentication Settings" />
      </Step>

      <Step title="Add the Crossmint providers to your app">
        Add the necessary Crossmint providers to your app together with your own auth provider.
        With the current setup, a wallet will be created automatically on login.

        <CodeGroup>
          ```tsx next.js theme={null}
          "use client";

          import {
              CrossmintProvider,
              CrossmintWalletProvider,
              useCrossmint,
          } from "@crossmint/client-sdk-react-ui";

          import { YourAuthProvider } from "@your-auth-provider";

          // Get the JWT from your auth provider and pass it to the Crossmint provider
          const { jwt } = useYourAuthProviderHook();
          const { setJwt } = useCrossmint();

          useEffect(() => {
              setJwt(jwt);
          }, [jwt]);

          export function Providers({ children }: { children: React.ReactNode }) {
              return (
                  <YourAuthProvider>
                      <CrossmintProvider apiKey="<crossmint-client-api-key>">
                          <CrossmintWalletProvider>
                              {children}
                          </CrossmintWalletProvider>
                      </CrossmintProvider>
                  </YourAuthProvider>
              );
          }
          ```

          ```tsx create-react-app theme={null}
          import ReactDOM from 'react-dom/client';

          import './index.css';

          import App from './App';

          import {
              CrossmintProvider,
              CrossmintWalletProvider,
              useCrossmint,
          } from "@crossmint/client-sdk-react-ui";

          import { AuthProvider } from "@your-auth-provider";

          // Get the JWT from your auth provider and pass it to the Crossmint provider
          const { jwt } = useYourAuthProviderHook();
          const { setJwt } = useCrossmint();

          useEffect(() => {
              setJwt(jwt);
          }, [jwt]);

          const root = ReactDOM.createRoot(document.getElementById('root'));

          root.render(
              <React.StrictMode>
                  <AuthProvider>
                      <CrossmintProvider apiKey="<crossmint-client-api-key>">
                          <CrossmintWalletProvider>
                              <App />
                          </CrossmintWalletProvider>
                      </CrossmintProvider>
                  </AuthProvider>
              </React.StrictMode>
          );
          ```
        </CodeGroup>
      </Step>

      <Step title="Passthrough the jwt information to the Crossmint provider">
        Create the wallet on login once the jwt and the email are available.

        <CodeGroup>
          ```tsx next.js theme={null}
          "use client";

          import { useYourAuthProviderHook } from "@your-auth-provider";
          import { useEffect } from "react";
          import { useCrossmint, useWallet } from "@crossmint/client-sdk-react-ui";

          export function YourComponent() {
              const { email } = useYourAuthProviderHook();
              const { jwt } = useCrossmint();
              const { getOrCreateWallet } = useWallet();

              useEffect(() => {
                  if (email != null && jwt != null) {
                      getOrCreateWallet({ signer: { type: "email", email: email } });
                  }
              }, [email, jwt]);

              // your component logic here
              return (
                  <div>
                      <h1>Your Component</h1>
                  </div>
              );
          }
          ```

          ```tsx create-react-app theme={null}
          import { useYourAuthProviderHook } from "@your-auth-provider";
          import { useEffect } from "react";
          import { useCrossmint, useWallet } from "@crossmint/client-sdk-react-ui";

          export function YourAuthComponent() {
              const { email } = useYourAuthProviderHook();
              const { jwt } = useCrossmint();
              const { getOrCreateWallet } = useWallet();

              useEffect(() => {
                  if (jwt != null && email != null) {
                      getOrCreateWallet({ signer: { type: "email", email: email } });
                  }
              }, [jwt, email]);

              // your component logic here
              return (
                  <div>
                      <h1>Your Component</h1>
                  </div>
              );
          }
          ```
        </CodeGroup>
      </Step>

      See the [React SDK reference](/sdk-reference/wallets/react/get-started) for more details on providers and hooks.
    </Steps>
  </Tab>

  <Tab title="React Native">
    <Steps>
      <Step title="Configure JWT Authentication in the Crossmint Console">
        1. Navigate to your project in the Crossmint Console.
        2. Go to the API Keys section from the sidebar.
        3. Scroll down to the JWT authentication section.
        4. Choose your preferred authentication method:

        * **3P Auth providers**: Select from supported providers such as Auth0, Stytch, Cognito, Firebase, Kinde, or Supabase. Enter any required environment IDs or configuration details.
        * **Custom tokens**: Opt to issue and manage your own JWTs.

        5. After making your selection and providing any necessary details, click **Save JWT auth settings** to apply your configuration.

        <img alt="JWT Authentication Settings" />
      </Step>

      <Step title="Add the Crossmint providers to your app">
        Add the necessary Crossmint providers to your app together with your own auth provider.
        With the current setup, a wallet will be created automatically on login.

        ```tsx theme={null}
        import {
            CrossmintProvider,
            CrossmintWalletProvider,
            useCrossmint,
        } from "@crossmint/client-sdk-react-native-ui";

        import { YourAuthProvider, useYourAuthProviderHook } from "@your-auth-provider";

        // Get the JWT from your auth provider and pass it to the Crossmint provider
        const { jwt } = useYourAuthProviderHook();
        const { setJwt } = useCrossmint();

        useEffect(() => {
            setJwt(jwt);
        }, [jwt]);

        type ProvidersProps = {
            children: React.ReactNode;
        };

        export default function Providers({ children }: ProvidersProps) {
            return (
                <CrossmintProvider apiKey="<crossmint-client-api-key>">
                    <YourAuthProvider>
                        <CrossmintWalletProvider>
                            {children}
                        </CrossmintWalletProvider>
                    </YourAuthProvider>
                </CrossmintProvider>
            );
        }
        ```
      </Step>

      <Step title="Passthrough the jwt information to the Crossmint provider">
        Create the wallet on login once the jwt and the email are available.

        ```tsx theme={null}
        import { useYourAuthProviderHook } from "@your-auth-provider";
        import { useEffect } from "react";
        import { View, Text } from "react-native";
        import { useCrossmint, useWallet } from "@crossmint/client-sdk-react-native-ui";

        export function YourAuthComponent() {
            const { email } = useYourAuthProviderHook();
            const { jwt } = useCrossmint();
            const { getOrCreateWallet } = useWallet();

            useEffect(() => {
                if (jwt != null && email != null) {
                    getOrCreateWallet({ signer: { type: "email", email: email } });
                }
            }, [jwt, email]);

            // your component logic here
            return (
                <View>
                    <Text>Your Auth Component</Text>
                </View>
            );
        }
        ```
      </Step>

      See the [React Native SDK reference](/sdk-reference/wallets/react-native/get-started) for more details on providers and hooks.
    </Steps>
  </Tab>
</Tabs>


# Check Balances
Source: https://docs.crossmint.com/wallets/guides/check-balances

Retrieve and manage wallet balances using Crossmint's APIs

<Tabs>
  <Tab title="Token Balances">
    ## Prerequisites

    * Ensure you have a wallet created.
    * **API Key**: Ensure you have an API key with the scopes: `wallets.read` and `wallets:balance.read`.

    ## Retrieving Wallet Balances

    <Tabs>
      <Tab title="React">
        ```typescript theme={null}
        import { useWallet } from '@crossmint/client-sdk-react-ui';

        const { wallet } = useWallet();

        const { nativeToken, usdc, tokens } = await wallet.balances(["usdc"]);
        ```

        See the [React SDK reference](/sdk-reference/wallets/react/hooks#wallet-methods) for more details.
      </Tab>

      <Tab title="Node.js">
        ```typescript theme={null}
        import { CrossmintWallets, createCrossmint } from "@crossmint/wallets-sdk";

        const crossmint = createCrossmint({
            apiKey: "<your-server-api-key>",
        });

        const crossmintWallets = CrossmintWallets.from(crossmint);

        const wallet = await crossmintWallets.getWallet(
            "email:user@example.com:evm",
            { chain: "base-sepolia", signer: { type: "email" } }
        );

        const { nativeToken, usdc, tokens } = await wallet.balances(["usdc"]);
        ```

        ### Parameters

        <ResponseField name="tokens" type="string[]">
          The tokens to get the balances for. This can be a token symbol or a token address.
        </ResponseField>

        ### Returns

        <ResponseField name="balances" type="Balances">
          The balances of the wallet.

          <Expandable title="properties">
            <ResponseField name="nativeToken" type="TokenBalance">
              The native token balance.

              <Snippet />
            </ResponseField>

            <ResponseField name="usdc" type="TokenBalance">
              The USDC balance.

              <Snippet />
            </ResponseField>

            <ResponseField name="tokens" type="TokenBalance[]">
              The tokens balances.

              <Snippet />
            </ResponseField>
          </Expandable>
        </ResponseField>
      </Tab>

      <Tab title="React Native">
        ```typescript theme={null}
        import { useWallet } from '@crossmint/client-sdk-react-native-ui';

        const { wallet } = useWallet();

        const { nativeToken, usdc, tokens } = await wallet.balances(["usdc"]);
        ```

        See the [React Native SDK reference](/sdk-reference/wallets/react-native/hooks#wallet-methods) for more details.
      </Tab>

      <Tab title="Swift">
        ```swift theme={null}
        import CrossmintClient
        import Wallet

        let sdk = CrossmintSDK.shared

        let wallet = try await sdk.crossmintWallets.getOrCreateWallet(
            chain: .baseSepolia,
            signer: .email("user@example.com")
        )

        let balances = try await wallet.balances(["usdc"])
        ```

        ### Parameters

        <ResponseField name="tokens" type="string[]">
          The tokens to get the balances for. This can be a token symbol or a token address.
        </ResponseField>

        ### Returns

        <ResponseField name="balances" type="Balances">
          The balances of the wallet.

          <Expandable title="properties">
            <ResponseField name="nativeToken" type="TokenBalance">
              The native token balance.

              <Snippet />
            </ResponseField>

            <ResponseField name="usdc" type="TokenBalance">
              The USDC balance.

              <Snippet />
            </ResponseField>

            <ResponseField name="tokens" type="TokenBalance[]">
              The tokens balances.

              <Snippet />
            </ResponseField>
          </Expandable>
        </ResponseField>
      </Tab>

      <Tab title="REST">
        <CodeGroup>
          ```bash cURL theme={null}
          curl --request GET \
              --url 'https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:evm/balances?tokens=usdc&chains=base-sepolia' \
              --header 'X-API-KEY: <x-api-key>'
          ```

          ```js Node.js theme={null}
          const url = 'https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:evm/balances?tokens=usdc&chains=base-sepolia';

          const options = {
              method: 'GET',
              headers: {
                  'X-API-KEY': '<x-api-key>'
              }
          };

          try {
              const response = await fetch(url, options);
              const data = await response.json();
              console.log(data);
          } catch (error) {
              console.error(error);
          }
          ```

          ```python Python theme={null}
          import requests

          url = "https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:evm/balances"

          querystring = {"tokens":"usdc","chains":"base-sepolia"}

          headers = {"X-API-KEY": "<x-api-key>"}

          response = requests.get(url, params=querystring, headers=headers)

          print(response.json())
          ```
        </CodeGroup>

        See the [API reference](/api-reference/wallets/get-wallet-balance) for more details.
      </Tab>
    </Tabs>
  </Tab>

  <Tab title="NFT Balances">
    ## Prerequisites

    * Ensure you have a wallet created.
    * **API Key**: Ensure you have an API key with the scopes: `wallets.read`, `wallets.nfts.read`.

    ## Retrieving NFTs

    <Tabs>
      <Tab title="React">
        ```typescript theme={null}
        import { useWallet } from '@crossmint/client-sdk-react-ui';

        const { wallet } = useWallet();

        const nfts = await wallet.experimental_nfts({ page: 1, perPage: 10 });
        ```

        See the [React SDK reference](/sdk-reference/wallets/react/hooks#wallet-methods) for more details.
      </Tab>

      <Tab title="Node.js">
        ```typescript theme={null}
        import { CrossmintWallets, createCrossmint } from "@crossmint/wallets-sdk";

        const crossmint = createCrossmint({
            apiKey: "<your-server-api-key>",
        });

        const crossmintWallets = CrossmintWallets.from(crossmint);

        const wallet = await crossmintWallets.getWallet(
            "email:user@example.com:evm",
            { chain: "base-sepolia", signer: { type: "email" } }
        );

        const nfts = await wallet.experimental_nfts({ page: 1, perPage: 10 });
        ```

        ### Parameters

        <ParamField type="number">
          The number of NFTs to return per page.
        </ParamField>

        <ParamField type="number">
          The page number to return.
        </ParamField>

        ### Returns

        <ParamField type="Promise<GetNftsResponse>">
          The NFTs.
        </ParamField>
      </Tab>

      <Tab title="React Native">
        ```typescript theme={null}
        import { useWallet } from '@crossmint/client-sdk-react-native-ui';

        const { wallet } = useWallet();

        const nfts = await wallet.experimental_nfts({ page: 1, perPage: 10 });
        ```

        See the [React Native SDK reference](/sdk-reference/wallets/react-native/hooks#wallet-methods) for more details.
      </Tab>

      <Tab title="Swift">
        ```swift theme={null}
        import CrossmintClient
        import Wallet

        let sdk = CrossmintSDK.shared

        let wallet = try await sdk.crossmintWallets.getOrCreateWallet(
            chain: .baseSepolia,
            signer: .email("user@example.com")
        )

        let nfts = try await wallet.nfts(page: 1, nftsPerPage: 10)
        ```

        ### Parameters

        <ParamField type="number">
          The number of NFTs to return per page.
        </ParamField>

        <ParamField type="number">
          The page number to return.
        </ParamField>

        ### Returns

        <ParamField type="Promise<GetNftsResponse>">
          The NFTs.
        </ParamField>
      </Tab>

      <Tab title="REST">
        <CodeGroup>
          ```bash cURL theme={null}
          curl --request GET \
              --url 'https://staging.crossmint.com/api/2022-06-09/wallets/email:user@example.com:base/nfts?page=1&perPage=20' \
              --header 'X-API-KEY: <x-api-key>'
          ```

          ```js Node.js theme={null}
          const url = 'https://staging.crossmint.com/api/2022-06-09/wallets/email:user@example.com:base/nfts?page=1&perPage=20';

          const options = {
              method: 'GET',
              headers: {
                  'X-API-KEY': '<x-api-key>'
              }
          };

          try {
              const response = await fetch(url, options);
              const data = await response.json();
              console.log(data);
          } catch (error) {
              console.error(error);
          }
          ```

          ```python Python theme={null}
          import requests

          url = "https://staging.crossmint.com/api/2022-06-09/wallets/email:user@example.com:base/nfts"

          querystring = {"page":"1","perPage":"20"}

          headers = {"X-API-KEY": "<x-api-key>"}

          response = requests.get(url, params=querystring, headers=headers)

          print(response.json())
          ```
        </CodeGroup>

        See the [API reference](/api-reference/wallets/get-nfts-from-wallet) for more details.
      </Tab>
    </Tabs>
  </Tab>
</Tabs>


# Create Wallet
Source: https://docs.crossmint.com/wallets/guides/create-wallet

Create a wallet using Crossmint's APIs

## Prerequisites

* **API Key**: Ensure you have an API key with the scopes: `wallets.create`.

## Try it Live

Experience wallet creation in action with this interactive demo. Create a Solana testnet wallet using just your email address:

<WalletCreationDemo />

## Create a Wallet

<Tabs>
  <Tab title="React">
    ```typescript theme={null}
    import { useWallet } from '@crossmint/client-sdk-react-ui';

    const { getOrCreateWallet } = useWallet();

    const wallet = await getOrCreateWallet({
        chain: "base-sepolia",
        signer: {
            type: "email",
            email: "user@example.com"
        },
    });
    ```

    See the [React SDK reference](/sdk-reference/wallets/react/hooks#usewallet) for all parameters.
  </Tab>

  <Tab title="Node.js">
    ```typescript theme={null}
    import { CrossmintWallets, createCrossmint } from "@crossmint/wallets-sdk";

    const crossmint = createCrossmint({
        apiKey: "<your-server-api-key>",
    });

    const crossmintWallets = CrossmintWallets.from(crossmint);

    const wallet = await crossmintWallets.createWallet({
        chain: "base-sepolia",
        signer: {
            type: "email",
            email: "user@example.com"
        },
    });
    ```

    ### Parameters

    <ResponseField name="chain" type="string">
      The chain to use the wallet on.

      See all [supported chains](/introduction/supported-chains) for more details. On [staging](/introduction/platform/staging-vs-production) only testnet chains are supported.

      Note: For EVM-compatible chains, wallets are created for all
      chains as part of the shared address space derived from the same private key. However, to
      interact with a specific chain using the SDK, you must instantiate a wallet object per chain.
      This allows the SDK to correctly route interactions to the appropriate network configuration.
    </ResponseField>

    <ResponseField name="signer" type="Signer">
      The [signer](/wallets/concepts/wallet-signers) to use the wallet with.
    </ResponseField>

    <ResponseField name="alias" type="string">
      An optional identifier for the wallet, used to organize multiple wallets on the same chain.

      Aliases are:

      * Unique per wallet type and chain.
      * Must use only lowercase letters, numbers, underscores, or hyphens (`a-z`, `0-9`, `_`, `-`).
      * No spaces or empty strings allowed.

      Examples:
      `trading`, `long-term-holdings`, `treasury`
    </ResponseField>

    <ResponseField name="owner" type="string">
      Use `owner` to tie a wallet to a specific user identity. It must be a string in the form `type:value`:

      * `email:email@example.com`
      * `userId:userId1` - Only used when bringing your own auth
      * `phoneNumber:phoneNumber1`
      * `twitter:handle1`
      * `x:handle1`

      **Using Crossmint Auth**
      If you are using also [Crossmint Auth](/authentication/introduction), you may set owner to any of the `email`, `phoneNumber`, `twitter` or `x`. Once created, Crossmint Auth will automatically resolve to that wallet on login.

      For example, if you set "owner": "x:acme", then whenever the user logs in via X through Crossmint Auth, Crossmint will automatically return the created wallet for that handle.

      **Bring your own auth**
      If you use your own authentication system, you can only set owner to userId:userId. Crossmint will extract that ID automatically from the `sub` claim of the JWT when the user signs in.
    </ResponseField>

    <ResponseField name="options" type="WalletOptions">
      The options to use the wallet with.

      <Expandable title="experimental_callbacks">
        A set of callbacks to be called when the wallet is created or a transaction is initiated.

        <Expandable title="properties">
          <ResponseField name="onWalletCreationStart" type="function">
            A function to be called when the wallet is about to be created.
          </ResponseField>

          <ResponseField name="onTransactionStart" type="function">
            A function to be called when a transaction is initiated.
          </ResponseField>
        </Expandable>
      </Expandable>
    </ResponseField>

    ### Returns

    <ResponseField name="wallet" type="Wallet">
      The created wallet.
    </ResponseField>
  </Tab>

  <Tab title="React Native">
    ```typescript theme={null}
    import { useWallet } from '@crossmint/client-sdk-react-native-ui';

    const { getOrCreateWallet } = useWallet();

    const wallet = await getOrCreateWallet({
        chain: "base-sepolia",
        signer: {
            type: "email",
            email: "user@example.com"
        },
    });
    ```

    See the [React Native SDK reference](/sdk-reference/wallets/react-native/hooks#usewallet) for all parameters.
  </Tab>

  <Tab title="Swift">
    ```swift theme={null}
    import CrossmintClient
    import Wallet

    let sdk = CrossmintSDK.shared

    let wallet = try await sdk.crossmintWallets.getOrCreateWallet(
        chain: .baseSepolia,
        signer: .email(email: "user@example.com")
    )
    ```

    ### Parameters

    <ResponseField name="chain" type="string">
      The chain to use the wallet on.

      See all [supported chains](/introduction/supported-chains) for more details. On [staging](/introduction/platform/staging-vs-production) only testnet chains are supported.

      Note: For EVM-compatible chains, wallets are created for all
      chains as part of the shared address space derived from the same private key. However, to
      interact with a specific chain using the SDK, you must instantiate a wallet object per chain.
      This allows the SDK to correctly route interactions to the appropriate network configuration.
    </ResponseField>

    <ResponseField name="signer" type="Signer">
      The [signer](/wallets/concepts/wallet-signers) to use the wallet with.
    </ResponseField>

    <ResponseField name="alias" type="string">
      An optional identifier for the wallet, used to organize multiple wallets on the same chain.

      Aliases are:

      * Unique per wallet type and chain.
      * Must use only lowercase letters, numbers, underscores, or hyphens (`a-z`, `0-9`, `_`, `-`).
      * No spaces or empty strings allowed.

      Examples:
      `trading`, `long-term-holdings`, `treasury`
    </ResponseField>

    ### Returns

    <ResponseField name="wallet" type="Wallet">
      The created wallet.
    </ResponseField>
  </Tab>

  <Tab title="REST">
    <CodeGroup>
      ```bash cURL theme={null}
      curl --request POST \
          --url https://staging.crossmint.com/api/2025-06-09/wallets \
          --header 'Content-Type: application/json' \
          --header 'X-API-KEY: <x-api-key>' \
          --data '{
              "chainType": "evm",
              "config": {
                  "adminSigner": {
                      "type": "email",
                      "email": "user@example.com"
                  }
              },
              "owner": "email:user@example.com"
          }'
      ```

      ```js Node.js theme={null}
      const url = 'https://staging.crossmint.com/api/2025-06-09/wallets';

      const payload = {
          chainType: "evm",
          config: {
              adminSigner: {
                  type: "email",
                  email: "user@example.com"
              }
          },
          owner: "email:user@example.com"
      };

      const options = {
          method: 'POST',
          headers: {
              'X-API-KEY': '<x-api-key>',
              'Content-Type': 'application/json'
          },
          body: JSON.stringify(payload)
      };

      try {
          const response = await fetch(url, options);
          const data = await response.json();
          console.log(data);
      } catch (error) {
          console.error(error);
      }
      ```

      ```python Python theme={null}
      import requests

      url = "https://staging.crossmint.com/api/2025-06-09/wallets"

      payload = {
          "chainType": "evm",
          "config": {
              "adminSigner": {
                  "type": "email",
                  "email": "user@example.com"
              }
          },
          "owner": "email:user@example.com"
      }
      headers = {
          "X-API-KEY": "<x-api-key>",
          "Content-Type": "application/json"
      }

      response = requests.post(url, json=payload, headers=headers)

      print(response.json())
      ```
    </CodeGroup>

    See the [API reference](/api-reference/wallets/create-wallet) for more details.
  </Tab>
</Tabs>


# Error Handling
Source: https://docs.crossmint.com/wallets/guides/error-handling

Catching and troubleshooting wallet transaction errors

Sometimes transactions fail. This guide outlines common failure reasons and provides tools to help you identify the underlying causes.

<Note>
  Reverted transactions are marked as "failed" and won't be executed. There is no auto-retry mechanism for failed
  transactions; you must manually resubmit them if needed.
</Note>

## Common Error Types

Transaction errors typically fall into two categories: validation failures and execution failures.

### Validation Errors

Validation errors occur when the provided transaction data is invalid. These errors commonly relate to invalid data (e.g., `signature`) during transaction approval. Common issues include:

* Malformed signatures
* Invalid signatures (e.g., from an unauthorized wallet)
* Insufficient signer permissions for transaction approval

An example of a validation error:

```json theme={null}
"error": {
  "reason": "execution_reverted",
  "message": "Execution reverted, see 'revert' for details",
  "revert": {
    "type": "wallet_authorization",
    "reason": "Invalid signature",
    "reasonData": "AA24",
    "simulationLink": "https://www.tdly.co/shared/simulation/e61be684-5359-48a6-9173-349cd44c6e6c"
  }
}
```

Troubleshooting steps:

* Verify the transaction signer is valid
* Confirm you're signing the correct `message` data
* Verify the signing private key matches the `signer` wallet

### Execution Errors

Execution errors occur when a transaction is reverted during runtime. These typically relate to the `calls` provided during transaction creation. Common causes include:

* Another transaction with the same call was executed already
* State changes between transaction creation and execution (e.g. asset price updated exceeding slippage allowance)

The Crossmint API typically provides specific revert reasons:

```json theme={null}
"error": {
  "reason": "execution_reverted",
  "message": "Execution reverted, see 'revert' for details",
  "revert": {
    "type": "contract_call",
    "reason": "ERC20: transfer amount exceeds balance",
    "simulationLink": "https://www.tdly.co/shared/simulation/18b810b5-33b6-4091-a3a1-d7318f73bbec"
  }
}
```

Troubleshooting:

* Review the simulation to understand the revert cause
* Check for similar previous transactions
* Attempt to resubmit with the same parameters

### Other Errors

If you encounter transaction failures without error details or receive no error message, there may be an issue with the Crossmint infrastructure. First, check [our status page](https://status.crossmint.com) to verify API availability and try again later. If the problem continues, please contact our support team.

## Debugging

The Crossmint API simulates all transactions before submitting them onchain. Failed simulations prevent onchain execution.

In most cases, the transaction will fail during the simulation. If that's the case, you can use Tenderly to inspect the details. Otherwise, you can use a block explorer to inspect the transaction.

### Tenderly

[Tenderly](https://tenderly.co) is an EVM transaction tracing software. For each transaction that is failed during simulation, Crossmint API includes a link to the Tenderly simulation.

### Block Explorer

If the transaction was included onchain, you can check its status using a block explorer.


# Export Private Key
Source: https://docs.crossmint.com/wallets/guides/export-private-key

Allow users to export private keys using email or phone signers

## Introduction

Exporting a private key allows users to extract the cryptographic key that controls their non-custodial wallet. This key can be imported into other wallet applications, enabling users to access their assets across different platforms.

The `ExportPrivateKeyButton` component provides a secure interface for users to export their private keys from wallets that use email or phone signers. Other signer types (passkey, external wallet, API key) do not expose private keys by design, so export does not apply to them.

<Warning>
  **Security Warning**: Exporting a private key is a sensitive operation that should be handled with extreme care. Anyone who obtains the private key has full control over the wallet and all its assets. Users should:

  * Never share their private key with anyone
  * Store exported keys securely in password managers or hardware wallets
  * Consider the security implications before exporting
</Warning>

### When to Export Private Keys

Users might need to export their private key in scenarios such as:

* Creating a backup of their wallet credentials
* Migrating to a different wallet provider
* Accessing their wallet through alternative interfaces

## Prerequisites

Before using the `ExportPrivateKeyButton` component, ensure:

* The wallet is using an **email or phone signer type**
* The wallet has been successfully created and is accessible

## Implementation Examples

<Tabs>
  <Tab title="React">
    ```typescript theme={null}
    import { ExportPrivateKeyButton, useWallet } from '@crossmint/client-sdk-react-ui';

    function WalletSettings() {
        const { wallet } = useWallet();

        return (
            <div>
                <h2>Wallet Settings</h2>
                <p>Address: {wallet?.address}</p>
                
                <ExportPrivateKeyButton />
            </div>
        );
    }
    ```

    See the [React SDK reference](/sdk-reference/wallets/react/components#exportprivatekeybutton) for more details.
  </Tab>

  <Tab title="React Native">
    ```typescript theme={null}
    import { ExportPrivateKeyButton, useWallet } from '@crossmint/client-sdk-react-native-ui';
    import { View, Text } from 'react-native';

    function WalletSettings() {
        const { wallet } = useWallet();

        return (
            <View>
                <Text>Wallet Settings</Text>
                <Text>Address: {wallet?.address}</Text>
                
                <ExportPrivateKeyButton />
            </View>
        );
    }
    ```

    See the [React Native SDK reference](/sdk-reference/wallets/react-native/components#exportprivatekeybutton) for more details.
  </Tab>
</Tabs>

## Security Considerations

When exporting private keys, users should store them securely using password managers or hardware wallets. Anyone with access to a private key has full control over the associated wallet.

As a developer integrating this component, it is important to communicate these security implications clearly to your users. Consider displaying warnings or educational content before allowing users to export their private keys, ensuring they understand the risks and best practices for secure key storage.

## How It Works

The `ExportPrivateKeyButton` component uses a secure multi-step process to export private keys:

### 1. Signer Validation

The component first checks if the wallet uses an exportable signer type (email or phone). If the wallet uses a different signer type, the component renders nothing.

### 2. Secure Iframe/WebView Loading

The component loads a secure iframe (web) or WebView (mobile) from Crossmint's TEE infrastructure. This isolated environment ensures that the private key is never exposed to the host application.

### 3. TEE Communication Protocol

The component establishes a secure communication channel with the TEE using the handshake protocol:

* The parent application initiates a handshake with the secure iframe/WebView
* Authentication credentials (JWT and API key) are passed through the secure channel
* The TEE verifies the user's identity and authorization

### 4. Private Key Derivation

Inside the TEE, the private key is derived from the master secret:

* The master secret is reconstructed from the device share and auth share
* The private key is derived using HKDF (HMAC-based Key Derivation Function)
* Supported cryptographic schemes: **ed25519** (Solana, Stellar) and **secp256k1** (EVM chains)
* Supported encoding formats: **base58**, **hex**, and **strkey**

### 5. Clipboard Copy

When the user clicks the export button, the private key is:

* Formatted in the appropriate encoding for the blockchain
* Copied directly to the user's clipboard
* Never exposed to the host application or stored in memory outside the TEE

For more details on the TEE architecture, see the [Email OTP](/wallets/concepts/wallet-signers#email-otp) section in the Wallet Signers guide.

## Related Documentation

* [Wallet Signers](/wallets/concepts/wallet-signers) - Learn about different signer types and custody models
* [Create Wallet](/wallets/guides/create-wallet) - Create wallets with email or phone signers
* [Bring Your Own Auth](/wallets/guides/bring-your-own-auth) - Integrate custom authentication systems
* [Wallets Quickstart](/wallets/quickstarts/react) - Get started with Crossmint Wallets


# Sponsor Gas Fees
Source: https://docs.crossmint.com/wallets/guides/gas-sponsorship

Cover transaction fees for your users to deliver a gasless experience

Gas sponsorship lets you cover the transaction fees (gas) for your users' blockchain interactions. By removing the need for users to hold native tokens for gas, you can reduce friction and improve conversion rates for both human users and AI agents interacting with your application.

By default, gas sponsorship is **enabled** for all wallets without writing any code.

Crossmint handles:

* Sponsoring the transaction fees on your behalf
* Maintaining a treasury to cover the gas costs
* Securely verifying and rate-limiting each transaction to prevent abuse
* Protecting against common attack vectors when sponsoring gas on chains like Solana
* Calculating optimal fees to ensure transactions land without overpaying

## Prerequisites

* A Crossmint project with wallets enabled
* Access to the <a href="https://staging.crossmint.com/console">Crossmint Console</a>

## Enable or Disable Gas Sponsorship

You can disable or re-enable gas sponsorship in the Console.

<Steps>
  <Step title="Navigate to Wallets Settings">
    Open the <a href="https://staging.crossmint.com/console">Crossmint Console</a> and go to **Wallets → Settings**.
  </Step>

  <Step title="Toggle gas sponsorship">
    Use the toggle to enable or disable gas sponsorship for your project.

    <img alt="Gas Sponsorship Settings" />
  </Step>
</Steps>

<Note>
  When using Solana as a chain, if you disable sponsorship, you can configure whether users pay gas in SOL or USDC.

  <img alt="Gas Sponsorship Solana Options" />
</Note>

## Set Spending Limits

<Note>
  Configuring per-user spending limits for gas sponsorship is available under private access. <a href="https://www.crossmint.com/contact/sales">Contact Crossmint</a> to enable this feature for your project.
</Note>

## Monitor Sponsored Transactions

You can track gas sponsorship usage and costs through the Crossmint Console and webhooks.

### View usage in the Console

The Crossmint Console provides an overview of your gas sponsorship usage, including total gas sponsored, number of transactions, and costs over time. Navigate to **Wallets → Settings** to view your current usage statistics.

### Track transactions with webhooks

For real-time monitoring, set up webhooks to receive notifications when transactions are sponsored. The `wallets.transfer.out` event includes information about the transaction and its gas costs.

```typescript theme={null}
async function processTransferEvent(event) {
    const { type, data } = event;

    if (type === "wallets.transfer.out" && data.status === "succeeded") {
        console.log("Sponsored transaction completed:");
        console.log(`  To: ${data.recipient.address}`);
        console.log(`  Amount: ${data.token.amount} ${data.token.symbol}`);
        console.log(`  Explorer: ${data.onChain.explorerLink}`);
    }
}
```

For complete webhook setup instructions, see the [Transfer Webhooks Setup](/wallets/guides/monitor-transfers-webhooks) guide.

## Best Practices

* **Start with sponsorship enabled**: Gas sponsorship significantly improves user experience and conversion rates, especially for users new to blockchain
* **Monitor usage regularly**: Keep track of your gas sponsorship costs to ensure they align with your budget
* **Set appropriate limits**: Once spending limits are enabled for your project, configure them based on your expected user behavior to prevent abuse
* **Use webhooks for real-time tracking**: Set up webhooks to monitor sponsored transactions and detect any unusual patterns

## Learn More

<CardGroup>
  <Card title="Transfer Webhooks Setup" icon="bell" href="/wallets/guides/monitor-transfers-webhooks">
    Set up real-time notifications for wallet transfers
  </Card>

  <Card title="Transfer Tokens" icon="paper-plane" href="/wallets/guides/transfer-tokens">
    Learn how to send tokens between wallets
  </Card>

  <Card title="Check Balances" icon="wallet" href="/wallets/guides/check-balances">
    Query token balances across your wallets
  </Card>

  <Card title="Webhooks Overview" icon="webhook" href="/introduction/platform/webhooks/overview">
    Learn about Crossmint webhooks
  </Card>
</CardGroup>


# Get Staging Tokens (USDXM)
Source: https://docs.crossmint.com/wallets/guides/get-staging-tokens

Fund your staging wallets with testnet tokens using Crossmint's USDXM stablecoin

## What are testnet tokens?

Testnet tokens are tokens deployed on blockchain testnets for development and testing purposes. These tokens do not have real-world monetary value, allowing you to simulate onchain behavior—such as sending, receiving, and paying gas fees—without financial risk. You can use testnet tokens to validate your integration before moving to production.

## What is USDXM?

USDXM is Crossmint's staging/testnet stablecoin, designed specifically for testing. Think about USDXM as the USDC of testnets. Crossmint has deployed the USDXM contract on all supported testnets making it easier for you to test tokens in staging.

USDXM is only available in staging environments and is not available in production.

# How to fund your wallet?

There are several options to fund your wallets on staging with USDXM

## Option 1: Fund with the SDK

The `stagingFund` method is the easiest way to add USDXM to your wallet programmatically. This method funds the wallet with USDXM only, is only available in staging environments.

<Tabs>
  <Tab title="React">
    ```typescript theme={null}
    import { useWallet } from '@crossmint/client-sdk-react-ui';

    const { wallet } = useWallet();

    const balances = await wallet.stagingFund(10);
    console.log("Wallet funded! New balances:", balances);
    ```

    See the [React SDK reference](/sdk-reference/wallets/react/hooks#wallet-methods) for more details.
  </Tab>

  <Tab title="React Native">
    ```typescript theme={null}
    import { useWallet } from '@crossmint/client-sdk-react-native-ui';

    const { wallet } = useWallet();

    const balances = await wallet.stagingFund(10);
    console.log("Wallet funded! New balances:", balances);
    ```

    See the [React Native SDK reference](/sdk-reference/wallets/react-native/hooks#wallet-methods) for more details.
  </Tab>

  <Tab title="Node.js">
    ```typescript theme={null}
    import { CrossmintWallets, createCrossmint } from "@crossmint/wallets-sdk";

    const crossmint = createCrossmint({
        apiKey: "<your-server-api-key>",
    });

    const crossmintWallets = CrossmintWallets.from(crossmint);

    const wallet = await crossmintWallets.getWallet(
        "email:user@example.com:evm",
        { chain: "base-sepolia", signer: { type: "api-key" } }
    );

    const balances = await wallet.stagingFund(10);
    console.log("Wallet funded! New balances:", balances);
    ```

    ### Parameters

    <ParamField type="number">
      The amount of USDXM to add to the wallet.
    </ParamField>

    <ParamField type="Chain">
      Optional. The chain to fund. If omitted, uses the wallet's default chain.
    </ParamField>

    ### Returns

    <ResponseField name="balances" type="FundWalletResponse">
      A response containing the wallet's updated balances after funding.
    </ResponseField>
  </Tab>
</Tabs>

## Option 2: Fund via API

You can also fund staging wallets directly using the HTTP API. This is useful for server-side integrations or when you need more control over the funding process.

<CodeGroup>
  ```bash cURL theme={null}
  curl --request POST \
      --url https://staging.crossmint.com/api/v1-alpha2/wallets/{walletLocator}/balances \
      --header 'Content-Type: application/json' \
      --header 'X-API-KEY: <x-api-key>' \
      --data '{
          "amount": 10,
          "token": "usdxm",
          "chain": "base-sepolia"
      }'
  ```

  ```js Node.js theme={null}
  const walletLocator = "email:user@example.com:evm";
  const url = `https://staging.crossmint.com/api/v1-alpha2/wallets/${walletLocator}/balances`;

  const payload = {
      amount: 10,
      token: "usdxm",
      chain: "base-sepolia"
  };

  const options = {
      method: 'POST',
      headers: {
          'X-API-KEY': '<x-api-key>',
          'Content-Type': 'application/json'
      },
      body: JSON.stringify(payload)
  };

  try {
      const response = await fetch(url, options);
      const data = await response.json();
      console.log(data);
  } catch (error) {
      console.error(error);
  }
  ```

  ```python Python theme={null}
  import requests

  wallet_locator = "email:user@example.com:evm"
  url = f"https://staging.crossmint.com/api/v1-alpha2/wallets/{wallet_locator}/balances"

  payload = {
      "amount": 10,
      "token": "usdxm",
      "chain": "base-sepolia"
  }
  headers = {
      "X-API-KEY": "<x-api-key>",
      "Content-Type": "application/json"
  }

  response = requests.post(url, json=payload, headers=headers)

  print(response.json())
  ```
</CodeGroup>

### Request parameters

<ParamField type="string">
  The wallet to fund. Can be a wallet address or a locator like `email:user@example.com:evm`.
</ParamField>

<ParamField type="number">
  The amount of USDXM to add.
</ParamField>

<ParamField type="string">
  The token to fund with. Use `usdxm` for staging environments.
</ParamField>

<ParamField type="string">
  The chain to fund on (e.g., `base-sepolia`, `polygon-amoy`).
</ParamField>

### Getting your API key

You can get your staging API key from the [Crossmint Console](https://staging.crossmint.com). Navigate to your project settings and create an API key with the `wallets:balance.create` scope.

See the [API reference](/api-reference/wallets/fund-wallet) for more details.

## Option 3: Use the faucet web app

For quick manual testing without writing code, you can use Crossmint's hosted faucet web app to get staging tokens.

<Card title="USDXM Faucet" icon="faucet" href="https://usdc-faucet.vercel.app/">
  Get testnet USDXM tokens instantly through a simple web interface.
</Card>

To use the faucet:

1. Visit [https://usdc-faucet.vercel.app/](https://usdc-faucet.vercel.app/)
2. Enter your wallet address or connect your wallet
3. Select the chain you want to receive tokens on
4. Request tokens

<Note>The faucet is intended for development use only and may have rate limits to prevent abuse.</Note>

## When should I use which option?

| Option                  | Best for                                                                            |
| ----------------------- | ----------------------------------------------------------------------------------- |
| **SDK (`stagingFund`)** | Automated flows, integration tests, and when you're already using the Crossmint SDK |
| **API**                 | Server-side integrations, custom tooling, or when you need direct HTTP access       |
| **Faucet web app**      | Quick manual testing, getting started quickly, or when you don't want to write code |

## Related guides

<CardGroup>
  <Card title="Transfer Tokens" icon="arrow-right-arrow-left" href="/wallets/guides/transfer-tokens">
    Learn how to transfer tokens between wallets
  </Card>

  <Card title="Check Balances" icon="wallet" href="/wallets/guides/check-balances">
    Retrieve and manage wallet balances
  </Card>
</CardGroup>


# List Wallet Transfers
Source: https://docs.crossmint.com/wallets/guides/list-transfers

Retrieve inbound and outbound transfer history for a wallet

<Warning>
  This is an **unstable API** that may change with time. The `unstable` prefix indicates that breaking changes may occur in future releases. Join our [Telegram developer community](https://t.me/crossmintdevs) for updates.
</Warning>

## Overview

The List Wallet Transfers API allows you to retrieve the transfer history for a wallet, including both inbound and outbound token transfers. This endpoint supports multiple blockchains and provides cursor-based pagination for efficient data retrieval.

## Prerequisites

* You have a wallet created.
* **API Key**: You have an API key with the scope: `wallets.transaction.read`. In staging, all scopes are included.

## Retrieving Wallet Transfers

<Tabs>
  <Tab title="EVM Chains">
    ### Get Ethereum Sepolia USDC Transfers

    <CodeGroup>
      ```bash cURL theme={null}
      curl --request GET \
        --url 'https://staging.crossmint.com/api/unstable/wallets/email:user@example.com:evm-smart-wallet/transfers?chain=ethereum-sepolia&tokens=usdc&status=successful&limit=10' \
        --header 'X-API-KEY: <your-server-api-key>'
      ```

      ```javascript Node.js theme={null}
      const url = "https://staging.crossmint.com/api/unstable/wallets/email:user@example.com:evm-smart-wallet/transfers";
      const params = new URLSearchParams({
          chain: "ethereum-sepolia",
          tokens: "usdc",
          status: "successful",
          limit: "10"
      });

      const response = await fetch(`${url}?${params}`, {
          method: "GET",
          headers: {
              "X-API-KEY": "<your-server-api-key>"
          }
      });

      const data = await response.json();
      console.log(data);
      ```

      ```python Python theme={null}
      import requests

      url = "https://staging.crossmint.com/api/unstable/wallets/email:user@example.com:evm-smart-wallet/transfers"
      params = {
          "chain": "ethereum-sepolia",
          "tokens": "usdc",
          "status": "successful",
          "limit": "10"
      }
      headers = {"X-API-KEY": "<your-server-api-key>"}

      response = requests.get(url, params=params, headers=headers)
      data = response.json()
      print(data)
      ```
    </CodeGroup>

    ### Paginating Through Results

    When your wallet has a lot of transactions, results are split into pages. Use the `nextCursor` value from each response in your next API call to get the next page of results.

    <CodeGroup>
      ```javascript Node.js theme={null}
      async function getAllTransfers(walletLocator, chain, tokens) {
          const baseUrl = `https://staging.crossmint.com/api/unstable/wallets/${walletLocator}/transfers`;
          const allTransfers = [];
          let cursor = null;

          do {
              const params = new URLSearchParams({
                  chain,
                  tokens,
                  status: "successful",
                  limit: "30"
              });

              if (cursor) {
                  params.set("cursor", cursor);
              }

              const response = await fetch(`${baseUrl}?${params}`, {
                  headers: { "X-API-KEY": "<your-server-api-key>" }
              });

              const result = await response.json();
              allTransfers.push(...result.data);
              cursor = result.nextCursor;
          } while (cursor);

          return allTransfers;
      }
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Solana">
    ### Get Solana USDC Transfers

    <CodeGroup>
      ```bash cURL theme={null}
      curl --request GET \
        --url 'https://staging.crossmint.com/api/unstable/wallets/email:user@example.com:solana:smart/transfers?chain=solana&tokens=usdc&status=successful&limit=10' \
        --header 'X-API-KEY: <your-server-api-key>'
      ```

      ```javascript Node.js theme={null}
      const url = "https://staging.crossmint.com/api/unstable/wallets/email:user@example.com:solana:smart/transfers";
      const params = new URLSearchParams({
          chain: "solana",
          tokens: "usdc",
          status: "successful",
          limit: "10"
      });

      const response = await fetch(`${url}?${params}`, {
          method: "GET",
          headers: {
              "X-API-KEY": "<your-server-api-key>"
          }
      });

      const data = await response.json();
      console.log(data);
      ```

      ```python Python theme={null}
      import requests

      url = "https://staging.crossmint.com/api/unstable/wallets/email:user@example.com:solana:smart/transfers"
      params = {
          "chain": "solana",
          "tokens": "usdc",
          "status": "successful",
          "limit": "10"
      }
      headers = {"X-API-KEY": "<your-server-api-key>"}

      response = requests.get(url, params=params, headers=headers)
      data = response.json()
      print(data)
      ```
    </CodeGroup>

    ### Paginating Through Results

    When your wallet has a lot of transactions, results are split into pages. Use the `nextCursor` value from each response in your next API call to get the next page of results.

    <CodeGroup>
      ```javascript Node.js theme={null}
      async function getAllTransfers(walletLocator, chain, tokens) {
          const baseUrl = `https://staging.crossmint.com/api/unstable/wallets/${walletLocator}/transfers`;
          const allTransfers = [];
          let cursor = null;

          do {
              const params = new URLSearchParams({
                  chain,
                  tokens,
                  status: "successful",
                  limit: "30"
              });

              if (cursor) {
                  params.set("cursor", cursor);
              }

              const response = await fetch(`${baseUrl}?${params}`, {
                  headers: { "X-API-KEY": "<your-server-api-key>" }
              });

              const result = await response.json();
              allTransfers.push(...result.data);
              cursor = result.nextCursor;
          } while (cursor);

          return allTransfers;
      }
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Stellar">
    ### Get Stellar USDC Transfers

    <CodeGroup>
      ```bash cURL theme={null}
      curl --request GET \
        --url 'https://staging.crossmint.com/api/unstable/wallets/GABCD1234.../transfers?chain=stellar&tokens=usdc&status=successful' \
        --header 'X-API-KEY: <your-server-api-key>'
      ```

      ```javascript Node.js theme={null}
      const url = "https://staging.crossmint.com/api/unstable/wallets/GABCD1234.../transfers";
      const params = new URLSearchParams({
          chain: "stellar",
          tokens: "usdc",
          status: "successful"
      });

      const response = await fetch(`${url}?${params}`, {
          method: "GET",
          headers: {
              "X-API-KEY": "<your-server-api-key>"
          }
      });

      const data = await response.json();
      console.log(data);
      ```
    </CodeGroup>

    ### Paginating Through Results

    When your wallet has a lot of transactions, results are split into pages. Use the `nextCursor` value from each response in your next API call to get the next page of results.

    <CodeGroup>
      ```javascript Node.js theme={null}
      async function getAllTransfers(walletLocator, chain, tokens) {
          const baseUrl = `https://staging.crossmint.com/api/unstable/wallets/${walletLocator}/transfers`;
          const allTransfers = [];
          let cursor = null;

          do {
              const params = new URLSearchParams({
                  chain,
                  tokens,
                  status: "successful",
                  limit: "30"
              });

              if (cursor) {
                  params.set("cursor", cursor);
              }

              const response = await fetch(`${baseUrl}?${params}`, {
                  headers: { "X-API-KEY": "<your-server-api-key>" }
              });

              const result = await response.json();
              allTransfers.push(...result.data);
              cursor = result.nextCursor;
          } while (cursor);

          return allTransfers;
      }
      ```
    </CodeGroup>
  </Tab>
</Tabs>

## API Reference

Two endpoints are available:

* `GET /unstable/wallets/{walletLocator}/transfers` — Server-side API key authentication
* `GET /unstable/wallets/me:walletLocator/transfers` — JWT authentication for the current user's wallet

See the [API reference](/api-reference/wallets/list-transfers) for full parameter details and to test requests in the playground.

## Important Notes

<AccordionGroup>
  <Accordion title="Chain Support">
    * **EVM chains**: Fully supported. Results are cached for 10 minutes to improve performance.
    * **Solana**: Supported. Includes native SOL and SPL token transfers (e.g., USDC). Results are cached for 10 minutes.
    * **Stellar**: Supported with tokens `usdc`, `usdm0`, `usdm1`, and `usdxm`.
  </Accordion>

  <Accordion title="EVM Limitations">
    Outgoing smart wallet native token transfers (e.g., ETH, MATIC) are not supported on all EVM chains. This limitation affects chains where internal transaction tracing is not available.
  </Accordion>

  <Accordion title="Pagination">
    * Uses cursor-based pagination for efficient data retrieval
    * Supports bidirectional pagination with `nextCursor` and `previousCursor`
    * The cursor encodes the sort order, so you don't need to re-specify it when paginating
    * Activity sessions expire after 10 minutes on EVM and Solana chains; refresh to load the latest data if the cursor expires
  </Accordion>

  <Accordion title="Timestamps">
    All timestamps are returned in ISO 8601 format (e.g., `2025-01-15T10:30:00.000Z`).
  </Accordion>

  <Accordion title="Transfer Types">
    The API returns both inbound (`wallets.transfer.in`) and outbound (`wallets.transfer.out`) transfers. Transfers initiated through Crossmint include a `transferId` that can be used with the [Get Transaction API](/api-reference/wallets/get-transaction).
  </Accordion>
</AccordionGroup>


# Migrate to Wallets SDK v2
Source: https://docs.crossmint.com/wallets/guides/migrate-to-v2

Migrate your wallet to Wallets SDK v2

## Motivation for v2

* Simplify the Wallets SDK and reduce web3-specific jargon
* Unify wallet types and signer configs across chains
* Provide better defaults for common use cases
* Make wallet integration faster and less error-prone
* Enable advanced features via optional parameters when needed

## React and React Native SDKs

### CrossmintWalletProvider and CrossmintAuthProvider

#### Change #1: Wallet config moves from CrossmintAuthProvider to CrossmintWalletProvider

```tsx theme={null}
// Before
<CrossmintAuthProvider
    authModalTitle="Solana Wallets Quickstart"
    embeddedWallets={{
        createOnLogin: "all-users",
        type: "solana-smart-wallet",
        showPasskeyHelpers: true,
    }}
    loginMethods={["web3:solana-only"]}
>
    {children}
</CrossmintAuthProvider>

// Now
<CrossmintAuthProvider
    authModalTitle="Fintech Starter App"
    loginMethods={["email", "google"]}
>
    <CrossmintWalletProvider
        showPasskeyHelpers={true}
        createOnLogin={{
            chain: "base-sepolia",
            signer: { type: "passkey" },
        }}
    >
        {children}
    </CrossmintWalletProvider>
</CrossmintAuthProvider>
```

#### Change #2: Wallet options

Wallet options also change:

* Type is no longer required
* createOnLogin is now an object including the chain, the [signer](/wallets/concepts/wallet-signers) and the owner fields.

## Wallets SDK

### Signer types and locators

Signer types and locators have been consolidated and simplified:

| Before                                                   | Now               |
| :------------------------------------------------------- | :---------------- |
| `evm-keypair` `solana-keypair`                           | `external-wallet` |
| `evm-passkey`                                            | `passkey`         |
| `solana-fireblocks-custodial` `evm-fireblocks-custodial` | `api-key`         |

### getOrCreateWallet updated input arguments

```ts theme={null}
// Before
const wallet = await crossmintWallets.getOrCreateWallet("evm-smart-wallet", {
    chain: "base-sepolia",
    adminSigner: {
        type: "evm-passkey",
    },
});

// Now
const wallet = await crossmintWallets.getOrCreateWallet({
    chain: "base-sepolia",
    signer: {
        type: "passkey",
    },
});
```

#### Change #1: Wallet type

Wallet type is not an argument anymore. All wallets are smart wallets and type is inferred from the chain passed

#### Change #2: Signers configs

Signers configs are now a single argument.

```ts theme={null}
//////////////////////
// Passkey signer
//////////////////////
// Before
{
  type: "evm-passkey";
  name?: string;
  signingCallback?: PasskeySigningCallback;
  creationCallback?: PasskeyCreationCallback;
};

// Now
{
    type: "passkey";
    name?: string;
    onCreatePasskey?: (name: string) => Promise<{ id: string; publicKey: { x: string; y: string } }>;
    onSignWithPasskey?: (message: string) => Promise<PasskeySignResult>;
};

//////////////////////
// Keypair signer
//////////////////////
// Before
{
  type: "evm-keypair";
  address: string;
  signer:
    | {
     type: "provider";
      provider: EIP1193Provider; // From viem
     }
    | {
     type: "viem_v2";
     account: Account; // From viem
   };
}

{
    type: "solana-keypair";
    address: SolanaAddress;
    signer: {
        signMessage: (message: Uint8Array) => Promise<Uint8Array>;
        signTransaction: (transaction: VersionedTransaction) => Promise<VersionedTransaction>;
    };
}
// Now
export type BaseExternalWalletSignerConfig = {
    type: "external-wallet";
    address: string;
};

export type EvmExternalWalletSignerConfig = BaseExternalWalletSignerConfig & {
    provider?: GenericEIP1193Provider | ViemEIP1193Provider;
    viemAccount?: Account;
};

export type SolanaExternalWalletSignerConfig = BaseExternalWalletSignerConfig & {
    onSignTransaction: (transaction: VersionedTransaction) => Promise<VersionedTransaction>;
};

//////////////////////
// Fireblocks
//////////////////////
// Before
{
    type: "solana-fireblocks-custodial";
};

// Now
{ type: "api-key" } // works for both EVM and Solana
```

#### Change #3: LinkedUser is now owner

LinkedUser field is now called owner.

```ts theme={null}
// Before
const wallet = await crossmintWallets.getOrCreateWallet("evm-smart-wallet", {
    chain: "base-sepolia",
    linkedUser: "email:dev@company.com",
    adminSigner: {
        type: "evm-passkey",
    },
});

// Now
const wallet = await crossmintWallets.getOrCreateWallet({
    chain: "base-sepolia",
    owner: "email:dev@company.com",
    signer: {
        type: "passkey",
    },
});
```

### SolanaSmartWallet and EVMSmartWallet get consolidated into Wallet

#### Change #1: getOrCreateWallet just returns a Wallet object

```ts theme={null}
// Before
const wallet: SolanaSmartWallet = await crossmintWallets.getOrCreateWallet("solana-smart-wallet", {
    adminSigner: {
        type: "solana-fireblocks-custodial",
    },
});

const wallet: EVMSmartWallet = await crossmintWallets.getOrCreateWallet("evm-smart-wallet", {
    chain: "base",
    adminSigner: {
        type: "evm-passkey",
    },
});

// Now
const wallet: Wallet = await crossmintWallets.getOrCreateWallet({
    chain: "base", // or "solana"
    signer: {
        type: "passkey",
    },
});
```

The Wallet object has common methods for all chains including checking the balance,
adding delegated signers and sending any kind of token.

#### Change #2: Balances

Balances now return an object with nativeToken, usdc and tokens. USDC and nativeToken balances are always fetched.

```ts theme={null}
// Before
await wallet.getBalances(["sol", "usdc"]);

// Now
await wallet.balances();
```

#### Change #3: Sending transactions and signing messages

To create transactions that are not transferring any kind of token you now need to do the following:

```ts theme={null}
// Before
wallet.sendTransaction({});

// Now
// EVM - use EVMWallet.from() to access EVM-specific methods
const evmWallet = EVMWallet.from(wallet);
evmWallet.sendTransaction({ to: "0x...", data: "0x..." });
evmWallet.signMessage({ message: "Hello" });
evmWallet.signTypedData({ domain, types, value });

// Solana - use SolanaWallet.from() to access Solana-specific methods
const solanaWallet = SolanaWallet.from(wallet);
solanaWallet.sendTransaction({ transaction: serializedTransaction });
```

#### Change #4: Delegated signer type

Delegated signer type is now a method on the Wallet object.

```ts theme={null}
// Before
wallet.getDelegatedSigners();
await wallet.addDelegatedSigner(`solana-keypair:${newSigner}`);
wallet.send("email@gmail.com", "usdc", "1.2");

// Now
wallet.delegatedSigners();
await wallet.addDelegatedSigner({ signer: `external-wallet:${newSigner}` });
```


# Transfer Webhooks Setup
Source: https://docs.crossmint.com/wallets/guides/monitor-transfers-webhooks

Track wallet transfer status and receive real-time notifications when transfers complete

After initiating a token transfer, you can monitor its status and receive real-time notifications using webhooks. This guide shows you how to set up webhook listeners to track when transfers complete or fail.

## Prerequisites

* A Crossmint project with API keys configured
* A wallet with tokens to transfer (see [Get Staging Tokens](/wallets/guides/get-staging-tokens))
* The `svix` package installed for webhook signature verification:

<CodeGroup>
  ```bash npm theme={null}
  npm i svix
  ```

  ```bash yarn theme={null}
  yarn add svix
  ```

  ```bash pnpm theme={null}
  pnpm add svix
  ```

  ```bash bun theme={null}
  bun add svix
  ```
</CodeGroup>

## Choose your setup path

There are two ways to test and integrate webhooks:

* **Option 1: Test using Svix Play** - Quick testing without setting up a local server
* **Option 2: Integrate with your local app** - Full integration with your development environment

***

## Option 1: Test using Svix Play

Use Svix Play to inspect webhook payloads without setting up a local server. This is useful for understanding the event structure before building your integration.

### Step 1: Create a webhook endpoint with Svix Play

1. Navigate to the Webhooks page in the Crossmint Console
2. Click **Add Endpoint**
3. In the dialog that appears, click the **"with Svix Play"** button (instead of entering a custom URL)
4. Select the following event types:
   * `wallets.transfer.in` - Receive notifications when tokens arrive in your wallets
   * `wallets.transfer.out` - Receive notifications when tokens leave your wallets
5. Click **Create**

This automatically configures your endpoint to use Svix Play, which opens with a pre-filled URL like:

```
https://play.svix.com/in/e_0izvs3VwiAo8hvKf6Ygh2tujXre/
```

### Step 2: Trigger a transfer

From your app, call the `wallet.send()` method to create an outgoing transfer. Any transfer made with the same project API key will trigger a webhook event on this endpoint.

```typescript theme={null}
const { hash, explorerLink } = await wallet.send(
    "<RECIPIENT_ADDRESS>",
    "usdc",
    "1.00"
);
```

As soon as the transfer is created, a `wallets.transfer.out` event will appear in Svix Play, where you can inspect the full payload structure.

For the complete transfer setup, see the [Transfer Tokens](/wallets/guides/transfer-tokens) guide.

***

## Option 2: Integrate with your local app

For full integration, set up a local server to receive and process webhook events.

### Step 1: Expose your local server

Before registering a webhook endpoint, you need a publicly accessible URL. If your app runs locally on `http://localhost:3000`, use [ngrok](https://ngrok.com) to create a public URL:

```bash theme={null}
ngrok http 3000
```

This gives you a public URL like `https://abc123.ngrok.io` that forwards to your local server.

Alternatively, if you have a staging or development server with a public URL, you can register that directly.

### Step 2: Register your webhook endpoint

1. Navigate to the Webhooks page in the Crossmint Console
2. Click **Add Endpoint**
3. Enter your public URL with the webhook path (e.g., `https://abc123.ngrok.io/api/webhooks/transfers`)
4. Select the following event types:
   * `wallets.transfer.in` - Receive notifications when tokens arrive in your wallets
   * `wallets.transfer.out` - Receive notifications when tokens leave your wallets
5. Click **Create**
6. Copy the **signing secret** from the endpoint details - you will need this to verify webhook signatures

For detailed setup instructions, see [Add an Endpoint](/introduction/platform/webhooks/add-endpoint).

<Tip>
  Your webhook endpoint must return a 2xx HTTP status code within 15 seconds to acknowledge receipt. This is critical for webhook delivery confirmation.
</Tip>

### Step 3: Handle transfer events

Create an endpoint to receive and process webhook events. The following example shows how to handle both incoming and outgoing transfer events.

<Tabs>
  <Tab title="Node.js (Express)">
    Replace `<YOUR_WEBHOOK_SECRET>` with the signing secret from Step 2.

    ```javascript theme={null}
    import express from "express";
    import { Webhook } from "svix";

    const app = express();

    app.use("/api/webhooks", express.raw({ type: "application/json" }));

    const WEBHOOK_SECRET = <YOUR_WEBHOOK_SECRET>; // String

    app.post("/api/webhooks/transfers", async (req, res) => {
        const wh = new Webhook(WEBHOOK_SECRET);
        let payload;

        try {
            payload = wh.verify(req.body, {
                "svix-id": req.headers["svix-id"],
                "svix-timestamp": req.headers["svix-timestamp"],
                "svix-signature": req.headers["svix-signature"],
            });
        } catch (err) {
            console.error("Webhook verification failed:", err.message);
            return res.status(400).json({ error: "Invalid signature" });
        }

        res.status(200).json({ received: true });

        await processTransferEvent(payload);
    });

    async function processTransferEvent(event) {
        const { type, data } = event;

        if (type === "wallets.transfer.in") {
            console.log("Incoming transfer received:");
            console.log(`  From: ${data.sender.address}`);
            console.log(`  To: ${data.recipient.address}`);
            console.log(`  Amount: ${data.token.amount} ${data.token.symbol}`);
            console.log(`  Explorer: ${data.onChain.explorerLink}`);
        }

        if (type === "wallets.transfer.out") {
            if (data.status === "succeeded") {
                console.log("Outgoing transfer succeeded:");
                console.log(`  To: ${data.recipient.address}`);
                console.log(`  Amount: ${data.token.amount} ${data.token.symbol}`);
                console.log(`  Explorer: ${data.onChain.explorerLink}`);
            } else {
                console.error("Outgoing transfer failed:");
                console.error(`  Error: ${data.error.message}`);
                console.error(`  Reason: ${data.error.reason}`);
            }
        }
    }

    app.listen(3000, () => console.log("Webhook server running on port 3000"));
    ```
  </Tab>

  <Tab title="Next.js (App Router)">
    Replace `<YOUR_WEBHOOK_SECRET>` with the signing secret from Step 2.

    ```typescript theme={null}
    // app/api/webhooks/transfers/route.ts
    import { Webhook } from "svix";
    import { headers } from "next/headers";
    import { NextResponse } from "next/server";

    const WEBHOOK_SECRET = <YOUR_WEBHOOK_SECRET>; // String

    export async function POST(req: Request) {
        const body = await req.text();
        const headerPayload = await headers();

        const svixId = headerPayload.get("svix-id");
        const svixTimestamp = headerPayload.get("svix-timestamp");
        const svixSignature = headerPayload.get("svix-signature");

        if (!svixId || !svixTimestamp || !svixSignature) {
            return NextResponse.json({ error: "Missing headers" }, { status: 400 });
        }

        const wh = new Webhook(WEBHOOK_SECRET);
        let payload: any;

        try {
            payload = wh.verify(body, {
                "svix-id": svixId,
                "svix-timestamp": svixTimestamp,
                "svix-signature": svixSignature,
            });
        } catch (err) {
            console.error("Webhook verification failed:", err);
            return NextResponse.json({ error: "Invalid signature" }, { status: 400 });
        }

        const { type, data } = payload;

        if (type === "wallets.transfer.in") {
            console.log(`Received ${data.token.amount} ${data.token.symbol}`);
            console.log(`From: ${data.sender.address}`);
            console.log(`Explorer: ${data.onChain.explorerLink}`);
        }

        if (type === "wallets.transfer.out") {
            if (data.status === "succeeded") {
                console.log(`Sent ${data.token.amount} ${data.token.symbol}`);
                console.log(`To: ${data.recipient.address}`);
            } else {
                console.error(`Transfer failed: ${data.error.message}`);
            }
        }

        return NextResponse.json({ received: true });
    }
    ```
  </Tab>

  <Tab title="Python (Flask)">
    Replace `<YOUR_WEBHOOK_SECRET>` with the signing secret from Step 2.

    ```python theme={null}
    from flask import Flask, request, jsonify
    from svix.webhooks import Webhook

    app = Flask(__name__)

    WEBHOOK_SECRET = <YOUR_WEBHOOK_SECRET>  # String

    @app.route("/api/webhooks/transfers", methods=["POST"])
    def handle_transfer_webhook():
        headers = {
            "svix-id": request.headers.get("svix-id"),
            "svix-timestamp": request.headers.get("svix-timestamp"),
            "svix-signature": request.headers.get("svix-signature"),
        }

        wh = Webhook(WEBHOOK_SECRET)
        try:
            payload = wh.verify(request.get_data(as_text=True), headers)
        except Exception as e:
            print(f"Webhook verification failed: {e}")
            return jsonify({"error": "Invalid signature"}), 400

        event_type = payload.get("type")
        data = payload.get("data")

        if event_type == "wallets.transfer.in":
            print(f"Received {data['token']['amount']} {data['token']['symbol']}")
            print(f"From: {data['sender']['address']}")
            print(f"Explorer: {data['onChain']['explorerLink']}")

        if event_type == "wallets.transfer.out":
            if data["status"] == "succeeded":
                print(f"Sent {data['token']['amount']} {data['token']['symbol']}")
                print(f"To: {data['recipient']['address']}")
            else:
                print(f"Transfer failed: {data['error']['message']}")

        return jsonify({"received": True})

    if __name__ == "__main__":
        app.run(port=3000)
    ```
  </Tab>
</Tabs>

<Warning>
  Always use the **raw request body** when verifying webhooks. Parsing and re-stringifying JSON will alter the content and cause verification failure.
</Warning>

<Note>
  For more details on securing and verifying webhook requests, see [Verify Webhooks](/introduction/platform/webhooks/verify-webhooks).
</Note>

### Step 4: Test your endpoint

Execute a transfer using the [Transfer Tokens](/wallets/guides/transfer-tokens) guide and observe the webhook event in your server logs. For a successful outgoing transfer, you should see output like:

```
Sent 0.40 USDC
To: 0xdf8b5f9c19e187f1ea00730a1e46180152244315
```

## Best practices

* **Respond quickly**: Return a 2xx status within 15 seconds to prevent retries
* **Verify signatures**: Always verify webhook signatures before processing. For comprehensive guidance, see [Webhook Best Practices](/introduction/platform/webhooks/best-practices)

## Related guides

* [Transfer Webhooks Reference](/wallets/guides/webhooks) - Complete event schema and field reference
* [Transfer Tokens](/wallets/guides/transfer-tokens) - Initiate token transfers
* [Verify Webhooks](/introduction/platform/webhooks/verify-webhooks) - Signature verification details
* [Add an Endpoint](/introduction/platform/webhooks/add-endpoint) - Configure webhook endpoints


# EVM
Source: https://docs.crossmint.com/wallets/guides/send-transaction-evm

Send transactions from your wallet

## Prerequisites

* Ensure you have a wallet created.
* **API Key**: Ensure you have an API key with the scopes: `wallets:transactions.create`.

## What is sending a custom transaction?

Sending a custom transaction lets you interact with any smart contract on the blockchain beyond simple transfers. Common use cases include minting free tokens, claiming rewards, or registering for allowlists—all without needing to manage private keys yourself.

## Sending a Transaction

<Tabs>
  <Tab title="React">
    ```typescript theme={null}
    import { useWallet, EVMWallet } from '@crossmint/client-sdk-react-ui';

    const { wallet } = useWallet();

    const evmWallet = EVMWallet.from(wallet);

    const { hash, explorerLink } = await evmWallet.sendTransaction({
        to: '0x...',
        value: BigInt('0x1234abcd'),
        data: '0x1234abcd...',
    });
    ```

    See the [React SDK reference](/sdk-reference/wallets/react/hooks#wallet-methods) for more details.
  </Tab>

  <Tab title="Node.js">
    ```typescript theme={null}
    import { CrossmintWallets, createCrossmint, EVMWallet } from "@crossmint/wallets-sdk";

    const crossmint = createCrossmint({
        apiKey: "<your-server-api-key>",
    });

    const crossmintWallets = CrossmintWallets.from(crossmint);

    const wallet = await crossmintWallets.getWallet(
        "email:user@example.com:evm",
        { chain: "base-sepolia", signer: { type: "email" } }
    );

    const evmWallet = EVMWallet.from(wallet);

    const { hash, explorerLink } = await evmWallet.sendTransaction({
        to: '0x...',
        value: BigInt('0x1234abcd'),
        data: '0x1234abcd...',
    });
    ```

    ### Parameters

    <ParamField type="EVMTransactionInput">
      The transaction to send.
    </ParamField>

    ### Returns

    <ParamField type="string">
      The hash of the transaction.
    </ParamField>

    <ParamField type="string">
      The explorer link of the transaction.
    </ParamField>
  </Tab>

  <Tab title="React Native">
    ```typescript theme={null}
    import { useWallet, EVMWallet } from '@crossmint/client-sdk-react-native-ui';

    const { wallet } = useWallet();

    const evmWallet = EVMWallet.from(wallet);

    const { hash, explorerLink } = await evmWallet.sendTransaction({
        to: '0x...',
        value: BigInt('0x1234abcd'),
        data: '0x1234abcd...',
    });
    ```

    See the [React Native SDK reference](/sdk-reference/wallets/react-native/hooks#wallet-methods) for more details.
  </Tab>

  <Tab title="Swift">
    ```swift theme={null}
    import CrossmintClient
    import Wallet

    let sdk = CrossmintSDK.shared

    let wallet = try await sdk.crossmintWallets.getOrCreateWallet(
        chain: .baseSepolia,
        signer: .email("user@example.com")
    )

    let evmWallet = try EVMWallet.from(wallet: wallet)

    let result = try await evmWallet.sendTransaction(transaction)
    ```

    ### Parameters

    <ParamField type="EVMTransactionInput">
      The transaction to send.
    </ParamField>

    ### Returns

    <ParamField type="string">
      The hash of the transaction.
    </ParamField>

    <ParamField type="string">
      The explorer link of the transaction.
    </ParamField>
  </Tab>

  <Tab title="REST">
    Transactions must be approved by one of the wallet's [signers](/wallets/concepts/wallet-signers).
    The SDK handles this automatically, but with the REST API you must [approve the transaction](/api-reference/wallets/approve-transaction) to complete it.

    <Steps>
      <Step title="Create the transaction">
        Call the [create transaction](/api-reference/wallets/create-transaction) endpoint.

        <CodeGroup>
          ```bash cURL theme={null}
          curl --request POST \
              --url https://staging.crossmint.com/api/2025-06-09/wallets/<wallet-locator>/transactions \
              --header 'Content-Type: application/json' \
              --header 'X-API-KEY: <x-api-key>' \
              --data '{
                  "params": {
                      "calls": [{
                          "to": "0x...",
                          "value": "0x",
                          "data": "0x1234abcd..."
                      }],
                      "chain": "base-sepolia",
                      "signer": "external-wallet:<externalWalletAddress>"
                  }
              }'
          ```

          ```js Node.js theme={null}
          const url = 'https://staging.crossmint.com/api/2025-06-09/wallets/<wallet-locator>/transactions';

          const payload = {
              params: {
                  calls: [{
                      to: "0x...",
                      value: "0x",
                      data: "0x1234abcd..."
                  }],
                  chain: "base-sepolia",
                  signer: "external-wallet:<externalWalletAddress>"
              }
          };

          const options = {
              method: 'POST',
              headers: {
                  'X-API-KEY': '<x-api-key>',
                  'Content-Type': 'application/json'
              },
              body: JSON.stringify(payload)
          };

          try {
              const response = await fetch(url, options);
              const data = await response.json();
              console.log(data);
          } catch (error) {
              console.error(error);
          }
          ```

          ```python Python theme={null}
          import requests

          url = "https://staging.crossmint.com/api/2025-06-09/wallets/<walletAddress>/transactions"

          payload = {
              "params": {
                  "calls": [{
                      "to": "0x...",
                      "value": "0x",
                      "data": "0x1234abcd..."
                  }],
                  "chain": "base-sepolia",
                  "signer": "external-wallet:<externalWalletAddress>"
              }
          }
          headers = {
              "X-API-KEY": "<x-api-key>",
              "Content-Type": "application/json"
          }

          response = requests.post(url, json=payload, headers=headers)

          print(response.json())
          ```
        </CodeGroup>

        See the [API reference](/api-reference/wallets/create-transaction) for more details.
      </Step>

      <Step title="Choose your signer type">
        The next steps depend on which signer type you specified in the previous step.

        <Tabs>
          <Tab title="API Key">
            <Note>[Contact us](https://www.crossmint.com/contact/sales) for access to API key signers.</Note>

            [API Key](/wallets/guides/signers/api-key) signers require no additional steps. Crossmint approves transactions automatically when using API key authentication, so the remaining steps in this guide do not apply.
          </Tab>

          <Tab title="External Wallet">
            For [External Wallet](/wallets/guides/signers/external-wallet) signers, you must manually sign the approval message and submit it via the API. The response from Step 1 includes a pending approval with a `message` field that must be signed exactly as returned.

            From the previous step's response, extract:

            * `id` - The transaction ID (used in the next step)
            * `approvals.pending[0].message` - The hex message to sign

            Sign the message using your external wallet. The message is a raw hex string and must be signed exactly as returned. Here's an example using an EVM wallet with [Viem](https://viem.sh/):

            ```typescript theme={null}
            import { privateKeyToAccount } from "viem/accounts";

            // The message from tx.approvals.pending[0].message
            const messageToSign = "<messageFromResponse>";

            // Sign the message exactly as returned (raw hex)
            const account = privateKeyToAccount(`0x${"<privateKey>"}`);
            const signature = await account.signMessage({
                message: { raw: messageToSign },
            });
            ```
          </Tab>

          <Tab title="Email & Phone">
            [Email and phone](/wallets/guides/signers/email-otp) signers require client-side OTP verification and key derivation, which the Crossmint SDK handles automatically. While REST API signing is technically possible, Crossmint does not recommend it because you would still need client-side SDK integration for the signing step.

            <Warning>
              Crossmint recommends using the React, React Native, Swift, or Node.js SDK examples instead. The SDK handles the full signing flow for email and phone signers.
            </Warning>
          </Tab>

          <Tab title="Passkey">
            [Passkey](/wallets/guides/signers/passkey) signers use WebAuthn for biometric or password manager authentication, which requires browser interaction. While REST API signing is technically possible, Crossmint does not recommend it because you would still need client-side SDK integration for the WebAuthn signing step.

            <Warning>
              Crossmint recommends using the React, React Native, Swift, or Node.js SDK examples instead. The SDK handles the full passkey signing flow automatically.
            </Warning>
          </Tab>
        </Tabs>
      </Step>

      <Step title="Submit the approval">
        <Note>
          Skip this step if using an `api-key` signer.
        </Note>

        Call the [approve transaction](/api-reference/wallets/approve-transaction) endpoint with the signature from Step 2 and the transaction ID from Step 1.

        <CodeGroup>
          ```bash cURL theme={null}
          curl --request POST \
              --url https://staging.crossmint.com/api/2025-06-09/wallets/<walletAddress>/transactions/<txId>/approvals \
              --header 'Content-Type: application/json' \
              --header 'X-API-KEY: <x-api-key>' \
              --data '{
                  "approvals": [{
                      "signer": "external-wallet:<externalWalletAddress>",
                      "signature": "<signature>"
                  }]
              }'
          ```

          ```js Node.js theme={null}
          const url = 'https://staging.crossmint.com/api/2025-06-09/wallets/<walletAddress>/transactions/<txId>/approvals';

          const payload = {
              approvals: [{
                  signer: "external-wallet:<externalWalletAddress>",
                  signature: "<signature>"
              }]
          };

          const options = {
              method: 'POST',
              headers: {
                  'X-API-KEY': '<x-api-key>',
                  'Content-Type': 'application/json'
              },
              body: JSON.stringify(payload)
          };

          try {
              const response = await fetch(url, options);
              const data = await response.json();
              console.log(data);
          } catch (error) {
              console.error(error);
          }
          ```

          ```python Python theme={null}
          import requests

          url = "https://staging.crossmint.com/api/2025-06-09/wallets/<walletAddress>/transactions/<txId>/approvals"

          payload = {
              "approvals": [{
                  "signer": "external-wallet:<externalWalletAddress>",
                  "signature": "<signature>"
              }]
          }
          headers = {
              "X-API-KEY": "<x-api-key>",
              "Content-Type": "application/json"
          }

          response = requests.post(url, json=payload, headers=headers)

          print(response.json())
          ```
        </CodeGroup>

        See the [API reference](/api-reference/wallets/approve-transaction) for more details.
      </Step>
    </Steps>
  </Tab>
</Tabs>


# Solana
Source: https://docs.crossmint.com/wallets/guides/send-transaction-solana

Send transactions from your wallet

## Prerequisites

* Ensure you have a wallet created.
* **API Key**: Ensure you have an API key with the scopes: `wallets:transactions.create`.

## What is sending a custom transaction?

Sending a custom transaction lets you interact with any smart contract on the blockchain beyond simple transfers. Common use cases include minting free tokens, claiming rewards, or registering for allowlists—all without needing to manage private keys yourself.

## Sending a Transaction

<Tabs>
  <Tab title="React">
    ```typescript theme={null}
    import { useWallet, SolanaWallet } from '@crossmint/client-sdk-react-ui';

    const { wallet } = useWallet();

    const solanaWallet = SolanaWallet.from(wallet);

    const { hash, explorerLink } = await solanaWallet.sendTransaction({
        transaction: versionedTransaction,
        additionalSigners: additionalSigners,
    });
    ```

    See the [React SDK reference](/sdk-reference/wallets/react/hooks#wallet-methods) for more details.
  </Tab>

  <Tab title="Node.js">
    ```typescript theme={null}
    import { CrossmintWallets, createCrossmint, SolanaWallet } from "@crossmint/wallets-sdk";

    const crossmint = createCrossmint({
        apiKey: "<your-server-api-key>",
    });

    const crossmintWallets = CrossmintWallets.from(crossmint);

    const wallet = await crossmintWallets.getWallet(
        "email:user@example.com:solana",
        { chain: "solana", signer: { type: "email" } }
    );

    const solanaWallet = SolanaWallet.from(wallet);

    const { hash, explorerLink } = await solanaWallet.sendTransaction({
        transaction: versionedTransaction,
        additionalSigners: additionalSigners,
    });
    ```

    ### Parameters

    <ParamField type="VersionedTransaction">
      The transaction to send.
    </ParamField>

    <ParamField type="Signer[]">
      The additional signers to sign the transaction with.
    </ParamField>

    ### Returns

    <ParamField type="string">
      The hash of the transaction.
    </ParamField>

    <ParamField type="string">
      The explorer link of the transaction.
    </ParamField>
  </Tab>

  <Tab title="React Native">
    ```typescript theme={null}
    import { useWallet, SolanaWallet } from '@crossmint/client-sdk-react-native-ui';

    const { wallet } = useWallet();

    const solanaWallet = SolanaWallet.from(wallet);

    const { hash, explorerLink } = await solanaWallet.sendTransaction({
        transaction: versionedTransaction,
        additionalSigners: additionalSigners,
    });
    ```

    See the [React Native SDK reference](/sdk-reference/wallets/react-native/hooks#wallet-methods) for more details.
  </Tab>

  <Tab title="Swift">
    ```swift theme={null}
    import CrossmintClient
    import Wallet

    let sdk = CrossmintSDK.shared

    let wallet = try await sdk.crossmintWallets.getOrCreateWallet(
        chain: .solana,
        signer: .email("user@example.com")
    )

    let solanaWallet = try SolanaWallet.from(wallet: wallet)

    let result = try await solanaWallet.sendTransaction(transaction)
    ```

    ### Parameters

    <ParamField type="VersionedTransaction">
      The transaction to send.
    </ParamField>

    ### Returns

    <ParamField type="string">
      The hash of the transaction.
    </ParamField>

    <ParamField type="string">
      The explorer link of the transaction.
    </ParamField>
  </Tab>

  <Tab title="REST">
    Transactions must be approved by one of the wallet's [signers](/wallets/concepts/wallet-signers).
    The SDK handles this automatically, but with the REST API you must [approve the transaction](/api-reference/wallets/approve-transaction) to complete it.

    <Steps>
      <Step title="Create the transaction">
        Call the [create transaction](/api-reference/wallets/create-transaction) endpoint.

        <CodeGroup>
          ```bash cURL theme={null}
          curl --request POST \
              --url https://staging.crossmint.com/api/2025-06-09/wallets/<walletAddress>/transactions \
              --header 'Content-Type: application/json' \
              --header 'X-API-KEY: <x-api-key>' \
              --data '{
                  "params": {
                      "transaction": "AQAAAAAAAAAAAAA...",
                      "signer": "external-wallet:<externalWalletAddress>"
                  }
              }'
          ```

          ```js Node.js theme={null}
          const url = 'https://staging.crossmint.com/api/2025-06-09/wallets/<walletAddress>/transactions';

          const payload = {
              params: {
                  transaction: "AQAAAAAAAAAAAAA...",
                  signer: "external-wallet:<externalWalletAddress>"
              }
          };

          const options = {
              method: 'POST',
              headers: {
                  'X-API-KEY': '<x-api-key>',
                  'Content-Type': 'application/json'
              },
              body: JSON.stringify(payload)
          };

          try {
              const response = await fetch(url, options);
              const data = await response.json();
              console.log(data);
          } catch (error) {
              console.error(error);
          }
          ```

          ```python Python theme={null}
          import requests

          url = "https://staging.crossmint.com/api/2025-06-09/wallets/<walletAddress>/transactions"

          payload = {
              "params": {
                  "transaction": "AQAAAAAAAAAAAAA...",
                  "signer": "external-wallet:<externalWalletAddress>"
              }
          }
          headers = {
              "X-API-KEY": "<x-api-key>",
              "Content-Type": "application/json"
          }

          response = requests.post(url, json=payload, headers=headers)

          print(response.json())
          ```
        </CodeGroup>

        See the [API reference](/api-reference/wallets/create-transaction) for more details.
      </Step>

      <Step title="Choose your signer type">
        The next steps depend on which signer type you specified in the previous step.

        <Tabs>
          <Tab title="API Key">
            <Note>[Contact us](https://www.crossmint.com/contact/sales) for access to API key signers.</Note>

            [API Key](/wallets/guides/signers/api-key) signers require no additional steps. Crossmint approves transactions automatically when using API key authentication, so the remaining steps in this guide do not apply.
          </Tab>

          <Tab title="External Wallet">
            For [External Wallet](/wallets/guides/signers/external-wallet) signers, you must manually sign the approval message and submit it via the API. The response from Step 1 includes a pending approval with a `message` field that must be signed exactly as returned.

            From the previous step's response, extract:

            * `id` - The transaction ID (used in the next step)
            * `approvals.pending[0].message` - The hex message to sign

            Sign the message using your external wallet. The message is a raw hex string and must be signed exactly as returned. Here's an example using an EVM wallet with [Viem](https://viem.sh/):

            ```typescript theme={null}
            import { privateKeyToAccount } from "viem/accounts";

            // The message from tx.approvals.pending[0].message
            const messageToSign = "<messageFromResponse>";

            // Sign the message exactly as returned (raw hex)
            const account = privateKeyToAccount(`0x${"<privateKey>"}`);
            const signature = await account.signMessage({
                message: { raw: messageToSign },
            });
            ```
          </Tab>

          <Tab title="Email & Phone">
            [Email and phone](/wallets/guides/signers/email-otp) signers require client-side OTP verification and key derivation, which the Crossmint SDK handles automatically. While REST API signing is technically possible, Crossmint does not recommend it because you would still need client-side SDK integration for the signing step.

            <Warning>
              Crossmint recommends using the React, React Native, Swift, or Node.js SDK examples instead. The SDK handles the full signing flow for email and phone signers.
            </Warning>
          </Tab>

          <Tab title="Passkey">
            [Passkey](/wallets/guides/signers/passkey) signers use WebAuthn for biometric or password manager authentication, which requires browser interaction. While REST API signing is technically possible, Crossmint does not recommend it because you would still need client-side SDK integration for the WebAuthn signing step.

            <Warning>
              Crossmint recommends using the React, React Native, Swift, or Node.js SDK examples instead. The SDK handles the full passkey signing flow automatically.
            </Warning>
          </Tab>
        </Tabs>
      </Step>

      <Step title="Submit the approval">
        <Note>
          Skip this step if using an `api-key` signer.
        </Note>

        Call the [approve transaction](/api-reference/wallets/approve-transaction) endpoint with the signature from Step 2 and the transaction ID from Step 1.

        <CodeGroup>
          ```bash cURL theme={null}
          curl --request POST \
              --url https://staging.crossmint.com/api/2025-06-09/wallets/<walletAddress>/transactions/<txId>/approvals \
              --header 'Content-Type: application/json' \
              --header 'X-API-KEY: <x-api-key>' \
              --data '{
                  "approvals": [{
                      "signer": "external-wallet:<externalWalletAddress>",
                      "signature": "<signature>"
                  }]
              }'
          ```

          ```js Node.js theme={null}
          const url = 'https://staging.crossmint.com/api/2025-06-09/wallets/<walletAddress>/transactions/<txId>/approvals';

          const payload = {
              approvals: [{
                  signer: "external-wallet:<externalWalletAddress>",
                  signature: "<signature>"
              }]
          };

          const options = {
              method: 'POST',
              headers: {
                  'X-API-KEY': '<x-api-key>',
                  'Content-Type': 'application/json'
              },
              body: JSON.stringify(payload)
          };

          try {
              const response = await fetch(url, options);
              const data = await response.json();
              console.log(data);
          } catch (error) {
              console.error(error);
          }
          ```

          ```python Python theme={null}
          import requests

          url = "https://staging.crossmint.com/api/2025-06-09/wallets/<walletAddress>/transactions/<txId>/approvals"

          payload = {
              "approvals": [{
                  "signer": "external-wallet:<externalWalletAddress>",
                  "signature": "<signature>"
              }]
          }
          headers = {
              "X-API-KEY": "<x-api-key>",
              "Content-Type": "application/json"
          }

          response = requests.post(url, json=payload, headers=headers)

          print(response.json())
          ```
        </CodeGroup>

        See the [API reference](/api-reference/wallets/approve-transaction) for more details.
      </Step>
    </Steps>
  </Tab>
</Tabs>


# Stellar
Source: https://docs.crossmint.com/wallets/guides/send-transaction-stellar

Send transactions from your wallet

## Prerequisites

* Ensure you have a wallet created.
* **API Key**: Ensure you have an API key with the scopes: `wallets:transactions.create`.

## What is sending a custom transaction?

Sending a custom transaction lets you interact with any smart contract on the blockchain beyond simple transfers. Common use cases include minting free tokens, claiming rewards, or registering for allowlists—all without needing to manage private keys yourself.

## Sending a contract call transaction

<Tabs>
  <Tab title="React">
    ```typescript theme={null}
    import { useWallet, StellarWallet } from '@crossmint/client-sdk-react-ui';

    const { wallet } = useWallet();

    const stellarWallet = StellarWallet.from(wallet);

    const { hash, explorerLink } = await stellarWallet.sendTransaction({
        contractId: "GB3KQJ6N2YIE62YVO67X7W5TQK6Q5ZZ4P2LUVK2U6AU26CJQ626J",
        method: "transfer",
        args: {
            to: "GB3KQJ6N2YIE62YVO67X7W5TQK6Q5ZZ4P2LUVK2U6AU26CJQ626J",
            from: "GB3KQJ6N2YIE62YVO67X7W5TQK6Q5ZZ4P2LUVK2U6AU26CJQ626J",
            amount: "1000000000000000000"
        }
    });
    ```

    See the [React SDK reference](/sdk-reference/wallets/react/hooks#wallet-methods) for more details.
  </Tab>

  <Tab title="Node.js">
    ```typescript theme={null}
    import { CrossmintWallets, createCrossmint, StellarWallet } from "@crossmint/wallets-sdk";

    const crossmint = createCrossmint({
        apiKey: "<your-server-api-key>",
    });

    const crossmintWallets = CrossmintWallets.from(crossmint);

    const wallet = await crossmintWallets.getWallet(
        "email:user@example.com:stellar",
        { chain: "stellar", signer: { type: "email" } }
    );

    const stellarWallet = StellarWallet.from(wallet);

    const { hash, explorerLink } = await stellarWallet.sendTransaction({
        contractId: "GB3KQJ6N2YIE62YVO67X7W5TQK6Q5ZZ4P2LUVK2U6AU26CJQ626J",
        method: "transfer",
        args: {
            to: "GB3KQJ6N2YIE62YVO67X7W5TQK6Q5ZZ4P2LUVK2U6AU26CJQ626J",
            from: "GB3KQJ6N2YIE62YVO67X7W5TQK6Q5ZZ4P2LUVK2U6AU26CJQ626J",
            amount: "1000000000000000000"
        }
    });
    ```

    ### Parameters

    <ParamField type="string">
      The contract ID to send the transaction to.
    </ParamField>

    <ParamField type="string">
      The method to call on the contract.
    </ParamField>

    <ParamField type="Record<string, any>">
      The arguments to pass to the method.
    </ParamField>

    ### Returns

    <ParamField type="string">
      The hash of the transaction.
    </ParamField>

    <ParamField type="string">
      The explorer link of the transaction.
    </ParamField>
  </Tab>

  <Tab title="React Native">
    ```typescript theme={null}
    import { useWallet, StellarWallet } from '@crossmint/client-sdk-react-native-ui';

    const { wallet } = useWallet();

    const stellarWallet = StellarWallet.from(wallet);

    const { hash, explorerLink } = await stellarWallet.sendTransaction({
        contractId: "GB3KQJ6N2YIE62YVO67X7W5TQK6Q5ZZ4P2LUVK2U6AU26CJQ626J",
        method: "transfer",
        args: {
            to: "GB3KQJ6N2YIE62YVO67X7W5TQK6Q5ZZ4P2LUVK2U6AU26CJQ626J",
            from: "GB3KQJ6N2YIE62YVO67X7W5TQK6Q5ZZ4P2LUVK2U6AU26CJQ626J",
            amount: "1000000000000000000"
        }
    });
    ```

    See the [React Native SDK reference](/sdk-reference/wallets/react-native/hooks#wallet-methods) for more details.
  </Tab>

  <Tab title="REST">
    Transactions must be approved by one of the wallet's [signers](/wallets/concepts/wallet-signers).
    The SDK handles this automatically, but with the REST API you must [approve the transaction](/api-reference/wallets/approve-transaction) to complete it.

    <Steps>
      <Step title="Create the transaction">
        Call the [create transaction](/api-reference/wallets/create-transaction) endpoint.

        <CodeGroup>
          ```bash cURL theme={null}
          curl --request POST \
              --url https://staging.crossmint.com/api/2025-06-09/wallets/<walletAddress>/transactions \
              --header 'Content-Type: application/json' \
              --header 'X-API-KEY: <x-api-key>' \
              --data '{
                  "params": {
                      "transaction": {
                          "type": "contract-call",
                          "contractId": "GB3KQJ6N2YIE62YVO67X7W5TQK6Q5ZZ4P2LUVK2U6AU26CJQ626J",
                          "method": "transfer",
                          "args": {
                              "to": "GB3KQJ6N2YIE62YVO67X7W5TQK6Q5ZZ4P2LUVK2U6AU26CJQ626J",
                              "from": "GB3KQJ6N2YIE62YVO67X7W5TQK6Q5ZZ4P2LUVK2U6AU26CJQ626J",
                              "amount": "1000000000000000000"
                          }
                      }
                  }
              }'
          ```

          ```js Node.js theme={null}
          const url = 'https://staging.crossmint.com/api/2025-06-09/wallets/<walletAddress>/transactions';

          const payload = {
              params: {
                  transaction: {
                      type: "contract-call",
                      contractId: "GB3KQJ6N2YIE62YVO67X7W5TQK6Q5ZZ4P2LUVK2U6AU26CJQ626J",
                      method: "transfer",
                      args: {
                          to: "GB3KQJ6N2YIE62YVO67X7W5TQK6Q5ZZ4P2LUVK2U6AU26CJQ626J",
                          from: "GB3KQJ6N2YIE62YVO67X7W5TQK6Q5ZZ4P2LUVK2U6AU26CJQ626J",
                          amount: "1000000000000000000"
                      }
                  }
              }
          };

          const options = {
              method: 'POST',
              headers: {
                  'X-API-KEY': '<x-api-key>',
                  'Content-Type': 'application/json'
              },
              body: JSON.stringify(payload)
          };

          try {
              const response = await fetch(url, options);
              const data = await response.json();
              console.log(data);
          } catch (error) {
              console.error(error);
          }
          ```

          ```python Python theme={null}
          import requests

          url = "https://staging.crossmint.com/api/2025-06-09/wallets/<walletAddress>/transactions"

          payload = {
              "params": {
                  "transaction": {
                      "type": "contract-call",
                      "contractId": "GB3KQJ6N2YIE62YVO67X7W5TQK6Q5ZZ4P2LUVK2U6AU26CJQ626J",
                      "method": "transfer",
                      "args": {
                          "to": "GB3KQJ6N2YIE62YVO67X7W5TQK6Q5ZZ4P2LUVK2U6AU26CJQ626J",
                          "from": "GB3KQJ6N2YIE62YVO67X7W5TQK6Q5ZZ4P2LUVK2U6AU26CJQ626J",
                          "amount": "1000000000000000000"
                      }
                  }
              }
          }
          headers = {
              "X-API-KEY": "<x-api-key>",
              "Content-Type": "application/json"
          }

          response = requests.post(url, json=payload, headers=headers)

          print(response.json())
          ```
        </CodeGroup>

        See the [API reference](/api-reference/wallets/create-transaction) for more details.
      </Step>

      <Step title="Choose your signer type">
        The next steps depend on which signer type you specified in the previous step.

        <Tabs>
          <Tab title="API Key">
            <Note>[Contact us](https://www.crossmint.com/contact/sales) for access to API key signers.</Note>

            [API Key](/wallets/guides/signers/api-key) signers require no additional steps. Crossmint approves transactions automatically when using API key authentication, so the remaining steps in this guide do not apply.
          </Tab>

          <Tab title="External Wallet">
            For [External Wallet](/wallets/guides/signers/external-wallet) signers, you must manually sign the approval message and submit it via the API. The response from Step 1 includes a pending approval with a `message` field that must be signed exactly as returned.

            From the previous step's response, extract:

            * `id` - The transaction ID (used in the next step)
            * `approvals.pending[0].message` - The hex message to sign

            Sign the message using your external wallet. The message is a raw hex string and must be signed exactly as returned. Here's an example using an EVM wallet with [Viem](https://viem.sh/):

            ```typescript theme={null}
            import { privateKeyToAccount } from "viem/accounts";

            // The message from tx.approvals.pending[0].message
            const messageToSign = "<messageFromResponse>";

            // Sign the message exactly as returned (raw hex)
            const account = privateKeyToAccount(`0x${"<privateKey>"}`);
            const signature = await account.signMessage({
                message: { raw: messageToSign },
            });
            ```
          </Tab>

          <Tab title="Email & Phone">
            [Email and phone](/wallets/guides/signers/email-otp) signers require client-side OTP verification and key derivation, which the Crossmint SDK handles automatically. While REST API signing is technically possible, Crossmint does not recommend it because you would still need client-side SDK integration for the signing step.

            <Warning>
              Crossmint recommends using the React, React Native, Swift, or Node.js SDK examples instead. The SDK handles the full signing flow for email and phone signers.
            </Warning>
          </Tab>

          <Tab title="Passkey">
            [Passkey](/wallets/guides/signers/passkey) signers use WebAuthn for biometric or password manager authentication, which requires browser interaction. While REST API signing is technically possible, Crossmint does not recommend it because you would still need client-side SDK integration for the WebAuthn signing step.

            <Warning>
              Crossmint recommends using the React, React Native, Swift, or Node.js SDK examples instead. The SDK handles the full passkey signing flow automatically.
            </Warning>
          </Tab>
        </Tabs>
      </Step>

      <Step title="Submit the approval">
        <Note>
          Skip this step if using an `api-key` signer.
        </Note>

        Call the [approve transaction](/api-reference/wallets/approve-transaction) endpoint with the signature from Step 2 and the transaction ID from Step 1.

        <CodeGroup>
          ```bash cURL theme={null}
          curl --request POST \
              --url https://staging.crossmint.com/api/2025-06-09/wallets/<walletAddress>/transactions/<txId>/approvals \
              --header 'Content-Type: application/json' \
              --header 'X-API-KEY: <x-api-key>' \
              --data '{
                  "approvals": [{
                      "signer": "external-wallet:<externalWalletAddress>",
                      "signature": "<signature>"
                  }]
              }'
          ```

          ```js Node.js theme={null}
          const url = 'https://staging.crossmint.com/api/2025-06-09/wallets/<walletAddress>/transactions/<txId>/approvals';

          const payload = {
              approvals: [{
                  signer: "external-wallet:<externalWalletAddress>",
                  signature: "<signature>"
              }]
          };

          const options = {
              method: 'POST',
              headers: {
                  'X-API-KEY': '<x-api-key>',
                  'Content-Type': 'application/json'
              },
              body: JSON.stringify(payload)
          };

          try {
              const response = await fetch(url, options);
              const data = await response.json();
              console.log(data);
          } catch (error) {
              console.error(error);
          }
          ```

          ```python Python theme={null}
          import requests

          url = "https://staging.crossmint.com/api/2025-06-09/wallets/<walletAddress>/transactions/<txId>/approvals"

          payload = {
              "approvals": [{
                  "signer": "external-wallet:<externalWalletAddress>",
                  "signature": "<signature>"
              }]
          }
          headers = {
              "X-API-KEY": "<x-api-key>",
              "Content-Type": "application/json"
          }

          response = requests.post(url, json=payload, headers=headers)

          print(response.json())
          ```
        </CodeGroup>

        See the [API reference](/api-reference/wallets/approve-transaction) for more details.
      </Step>
    </Steps>
  </Tab>
</Tabs>


# EVM
Source: https://docs.crossmint.com/wallets/guides/sign-message-evm

Sign messages from your wallet

## Prerequisites

* Ensure you have a wallet created.
* **API Key**: Ensure you have an API key with the scopes: `wallets:signatures.create`.

<Warning>
  If you are signing with an [operational signer](/wallets/guides/signers/registering-a-signer), the wallet must have executed at least one transaction before signatures will work. This is because the wallet needs to be deployed onchain first.
</Warning>

## Signing a Message

<Tabs>
  <Tab title="React">
    ```typescript theme={null}
    import { useWallet, EVMWallet } from '@crossmint/client-sdk-react-ui';

    const { wallet } = useWallet();

    const evmWallet = EVMWallet.from(wallet);

    const signedMessage = await evmWallet.signMessage({ message: "Hello, world!" });
    ```

    See the [React SDK reference](/sdk-reference/wallets/react/hooks#wallet-methods) for more details.
  </Tab>

  <Tab title="Node.js">
    ```typescript theme={null}
    import { CrossmintWallets, createCrossmint, EVMWallet } from "@crossmint/wallets-sdk";

    const crossmint = createCrossmint({
        apiKey: "<your-server-api-key>",
    });

    const crossmintWallets = CrossmintWallets.from(crossmint);

    const wallet = await crossmintWallets.getWallet(
        "email:user@example.com:evm",
        { chain: "base-sepolia", signer: { type: "email" } }
    );

    const evmWallet = EVMWallet.from(wallet);

    const signedMessage = await evmWallet.signMessage({ message: "Hello, world!" });
    ```

    ### Parameters

    <ParamField type="string">
      The message to sign.
    </ParamField>

    ### Returns

    <ParamField type="string">
      The signature of the message.
    </ParamField>
  </Tab>

  <Tab title="React Native">
    ```typescript theme={null}
    import { useWallet, EVMWallet } from '@crossmint/client-sdk-react-native-ui';

    const { wallet } = useWallet();

    const evmWallet = EVMWallet.from(wallet);

    const signedMessage = await evmWallet.signMessage({ message: "Hello, world!" });
    ```

    See the [React Native SDK reference](/sdk-reference/wallets/react-native/hooks#wallet-methods) for more details.
  </Tab>

  <Tab title="Swift">
    ```swift theme={null}
    import CrossmintClient
    import Wallet

    let sdk = CrossmintSDK.shared

    let wallet = try await sdk.crossmintWallets.getOrCreateWallet(
        chain: .baseSepolia,
        signer: .email("user@example.com")
    )

    let evmWallet = try EVMWallet.from(wallet: wallet)

    let signature = try await evmWallet.signMessage("Hello, world!")
    ```

    ### Parameters

    <ParamField type="string">
      The message to sign.
    </ParamField>

    ### Returns

    <ParamField type="string">
      The signature of the message.
    </ParamField>
  </Tab>

  <Tab title="REST">
    Signatures must be approved by one of the wallet's [signers](/wallets/concepts/wallet-signers).
    The SDK handles this automatically, but with the REST API you must [approve the signature](/api-reference/wallets/approve-signature) to complete it.

    <Steps>
      <Step title="Create the signature">
        Call the [create signature](/api-reference/wallets/create-signature) endpoint.

        <CodeGroup>
          ```bash Curl theme={null}
          curl --request POST \
              --url https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:evm/signatures \
              --header 'Content-Type: application/json' \
              --header 'X-API-KEY: <x-api-key>' \
              --data '{
                  "type": "message",
                  "params": {
                      "message": "Hello, world!",
                      "signer": "email:user@example.com",
                      "chain": "base-sepolia"
                  }
              }'
          ```

          ```js Node.js theme={null}
          const url = 'https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:evm/signatures';

          const payload = {
              type: "message",
              params: {
                  message: "Hello, world!",
                  signer: "email:user@example.com",
                  chain: "base-sepolia"
              }
          };

          const options = {
              method: 'POST',
              headers: {
                  'X-API-KEY': '<x-api-key>',
                  'Content-Type': 'application/json'
              },
              body: JSON.stringify(payload)
          };

          try {
              const response = await fetch(url, options);
              const data = await response.json();
              console.log(data);
          } catch (error) {
              console.error(error);
          }
          ```

          ```python Python theme={null}
          import requests

          url = "https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:evm/signatures"

          payload = {
              "type": "message",
              "params": {
                  "message": "Hello, world!",
                  "signer": "email:user@example.com",
                  "chain": "base-sepolia"
              }
          }
          headers = {
              "X-API-KEY": "<x-api-key>",
              "Content-Type": "application/json"
          }

          response = requests.post(url, json=payload, headers=headers)

          print(response.json())
          ```
        </CodeGroup>

        See the [API reference](/api-reference/wallets/create-signature) for more details.
      </Step>

      <Step title="Sign the approval returned in the response">
        <Note>
          If you are using an `api-key` as the recovery signer (admin signer) you can skip the following steps.
        </Note>

        Sign the approval message field returned in the response inside `signature.approvals` using the signer.
      </Step>

      <Step title="Approve the signature">
        Call the [approve signature](/api-reference/wallets/approve-signature) endpoint using the signature from the previous step and the signature id returned in the call from Step 1.

        <CodeGroup>
          ```bash cURL theme={null}
          curl --request POST \
              --url https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:evm/signatures/91e90094-9fe0-43a7-bab6-e5725767a3ad/approvals \
              --header 'Content-Type: application/json' \
              --header 'X-API-KEY: <x-api-key>' \
              --data '{
                  "approvals": [{
                      "signer": "email:user@example.com",
                      "signature": "0x1234567890abcdef..."
                  }]
              }'
          ```

          ```js Node.js theme={null}
          const url = 'https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:evm/signatures/91e90094-9fe0-43a7-bab6-e5725767a3ad/approvals';

          const payload = {
              approvals: [{
                  signer: "email:user@example.com",
                  signature: "0x1234567890abcdef..."
              }]
          };

          const options = {
              method: 'POST',
              headers: {
                  'X-API-KEY': '<x-api-key>',
                  'Content-Type': 'application/json'
              },
              body: JSON.stringify(payload)
          };

          try {
              const response = await fetch(url, options);
              const data = await response.json();
              console.log(data);
          } catch (error) {
              console.error(error);
          }
          ```

          ```python Python theme={null}
          import requests

          url = "https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:evm/signatures/91e90094-9fe0-43a7-bab6-e5725767a3ad/approvals"

          payload = {
              "approvals": [{
                  "signer": "email:user@example.com",
                  "signature": "0x1234567890abcdef..."
              }]
          }
          headers = {
              "X-API-KEY": "<x-api-key>",
              "Content-Type": "application/json"
          }

          response = requests.post(url, json=payload, headers=headers)

          print(response.json())
          ```
        </CodeGroup>

        See the [API reference](/api-reference/wallets/approve-signature) for more details.
      </Step>
    </Steps>
  </Tab>
</Tabs>

## Signing Typed Data

<Tabs>
  <Tab title="React">
    ```typescript theme={null}
    import { useWallet, EVMWallet } from '@crossmint/client-sdk-react-ui';

    const { wallet } = useWallet();

    const evmWallet = EVMWallet.from(wallet);
    const typedData = {
        "types": {
            "EIP712Domain": [{
                "name": "name",
                "type": "string"
            }],
        },
        "primaryType": "Mail",
        "domain": {
            "name": "example.com",
            "version": "1"
        },
        "message": {
            "from": {
                "name": "John Doe"
            },
            "to": {
                "name": "Jane Doe"
            },
            "contents": "Hello, world!"
        }
    };
    const signedMessage = await evmWallet.signTypedData(typedData);
    ```

    See the [React SDK reference](/sdk-reference/wallets/react/hooks#wallet-methods) for more details.
  </Tab>

  <Tab title="Node.js">
    ```typescript theme={null}
    import { CrossmintWallets, createCrossmint, EVMWallet } from "@crossmint/wallets-sdk";

    const crossmint = createCrossmint({
        apiKey: "<your-server-api-key>",
    });

    const crossmintWallets = CrossmintWallets.from(crossmint);

    const wallet = await crossmintWallets.getWallet(
        "email:user@example.com:evm",
        { chain: "base-sepolia", signer: { type: "email" } }
    );
    const evmWallet = EVMWallet.from(wallet);

    const typedData = {
        "types": {
            "EIP712Domain": [{
                "name": "name",
                "type": "string"
            }],
        },
        "primaryType": "Mail",
        "domain": {
            "name": "example.com",
            "version": "1"
        },
        "message": {
            "from": {
                "name": "John Doe"
            },
            "to": {
                "name": "Jane Doe"
            },
            "contents": "Hello, world!"
        }
    };
    const signedMessage = await evmWallet.signTypedData(typedData);
    ```
  </Tab>

  <Tab title="React Native">
    ```typescript theme={null}
    import { useWallet, EVMWallet } from '@crossmint/client-sdk-react-native-ui';

    const { wallet } = useWallet();

    const evmWallet = EVMWallet.from(wallet);

    const typedData = {
        "types": {
            "EIP712Domain": [{
                "name": "name",
                "type": "string"
            }],
        },
        "primaryType": "Mail",
        "domain": {
            "name": "example.com",
            "version": "1"
        },
        "message": {
            "from": {
                "name": "John Doe"
            },
            "to": {
                "name": "Jane Doe"
            },
            "contents": "Hello, world!"
        }
    };
    const signedMessage = await evmWallet.signTypedData(typedData);
    ```

    See the [React Native SDK reference](/sdk-reference/wallets/react-native/hooks#wallet-methods) for more details.
  </Tab>

  <Tab title="Swift">
    ```swift theme={null}
    import CrossmintClient
    import Wallet

    let sdk = CrossmintSDK.shared

    let wallet = try await sdk.crossmintWallets.getOrCreateWallet(
        chain: .baseSepolia,
        signer: .email("user@example.com")
    )

    let evmWallet = try EVMWallet.from(wallet: wallet)

    let signature = try await evmWallet.signTypedData(typedData)
    ```

    ### Parameters

    <ParamField type="TypedData">
      The typed data to sign.
    </ParamField>

    ### Returns

    <ParamField type="string">
      The signature of the message.
    </ParamField>
  </Tab>

  <Tab title="REST">
    Signatures must be approved by one of the wallet's [signers](/wallets/concepts/wallet-signers).
    The SDK handles this automatically, but with the REST API you must [approve the signature](/api-reference/wallets/approve-signature) to complete it.

    <Steps>
      <Step title="Create the signature">
        Call the [create signature](/api-reference/wallets/create-signature) endpoint.

        <CodeGroup>
          ```bash Curl theme={null}
          curl --request POST \
              --url https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:evm/signatures \
              --header 'Content-Type: application/json' \
              --header 'X-API-KEY: <x-api-key>' \
              --data '{
                  "type": "typed-data",
                  "params": {
                      "typedData": {
                          "types": {
                              "EIP712Domain": [{
                                  "name": "name",
                                  "type": "string"
                              }],
                          },
                          "primaryType": "Mail",
                          "domain": {
                              "name": "example.com",
                              "version": "1"
                          },
                          "message": {
                              "from": {
                                  "name": "John Doe"
                              },
                              "to": {
                                  "name": "Jane Doe"
                              },
                              "contents": "Hello, world!"
                          }
                      },
                      "signer": "email:user@example.com",
                      "chain": "base-sepolia"
                  }
              }'
          ```

          ```js Node.js theme={null}
          const url = 'https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:evm/signatures';

          const payload = {
              type: "typed-data",
              params: {
                  typedData: {
                      types: {
                          EIP712Domain: [{
                              name: "name",
                              type: "string"
                          }]
                      },
                      primaryType: "Mail",
                      domain: {
                          name: "example.com",
                          version: "1"
                      },
                      message: {
                          from: {
                              name: "John Doe"
                          },
                          to: {
                              name: "Jane Doe"
                          },
                          contents: "Hello, world!"
                      }
                  },
                  signer: "email:user@example.com",
                  chain: "base-sepolia"
              }
          };

          const options = {
              method: 'POST',
              headers: {
                  'X-API-KEY': '<x-api-key>',
                  'Content-Type': 'application/json'
              },
              body: JSON.stringify(payload)
          };

          try {
              const response = await fetch(url, options);
              const data = await response.json();
              console.log(data);
          } catch (error) {
              console.error(error);
          }
          ```

          ```python Python theme={null}
          import requests

          url = "https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:evm/signatures"

          payload = {
              "type": "typed-data",
              "params": {
                  "typedData": {
                      "types": {
                          "EIP712Domain": [{
                              "name": "name",
                              "type": "string"
                          }],
                      },
                      "primaryType": "Mail",
                      "domain": {
                          "name": "example.com",
                          "version": "1"
                      },
                      "message": {
                          "from": {
                              "name": "John Doe"
                          },
                          "to": {
                              "name": "Jane Doe"
                          },
                          "contents": "Hello, world!"
                      }
                  },
                  "signer": "email:user@example.com",
                  "chain": "base-sepolia"
              }
          }
          headers = {
              "X-API-KEY": "<x-api-key>",
              "Content-Type": "application/json"
          }

          response = requests.post(url, json=payload, headers=headers)

          print(response.json())
          ```
        </CodeGroup>

        See the [API reference](/api-reference/wallets/create-signature) for more details.
      </Step>

      <Step title="Sign the approval returned in the response">
        <Note>
          If you are using an `api-key` as the recovery signer (admin signer) you can skip the following steps.
        </Note>

        Sign the approval message field returned in the response inside `signature.approvals` using the signer.
      </Step>

      <Step title="Approve the signature">
        Call the [approve signature](/api-reference/wallets/approve-signature) endpoint using the signature from the previous step and the signature id returned in the call from Step 1.

        <CodeGroup>
          ```bash cURL theme={null}
          curl --request POST \
              --url https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:evm/signatures/91e90094-9fe0-43a7-bab6-e5725767a3ad/approvals \
              --header 'Content-Type: application/json' \
              --header 'X-API-KEY: <x-api-key>' \
              --data '{
                  "approvals": [{
                      "signer": "email:user@example.com",
                      "signature": "0x1234567890abcdef..."
                  }]
              }'
          ```

          ```js Node.js theme={null}
          const url = 'https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:evm/signatures/91e90094-9fe0-43a7-bab6-e5725767a3ad/approvals';

          const payload = {
              approvals: [{
                  signer: "email:user@example.com",
                  signature: "0x1234567890abcdef..."
              }]
          };

          const options = {
              method: 'POST',
              headers: {
                  'X-API-KEY': '<x-api-key>',
                  'Content-Type': 'application/json'
              },
              body: JSON.stringify(payload)
          };

          try {
              const response = await fetch(url, options);
              const data = await response.json();
              console.log(data);
          } catch (error) {
              console.error(error);
          }
          ```

          ```python Python theme={null}
          import requests

          url = "https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:evm/signatures/91e90094-9fe0-43a7-bab6-e5725767a3ad/approvals"

          payload = {
              "approvals": [{
                  "signer": "email:user@example.com",
                  "signature": "0x1234567890abcdef..."
              }]
          }
          headers = {
              "X-API-KEY": "<x-api-key>",
              "Content-Type": "application/json"
          }

          response = requests.post(url, json=payload, headers=headers)

          print(response.json())
          ```
        </CodeGroup>

        See the [API reference](/api-reference/wallets/approve-signature) for more details.
      </Step>
    </Steps>
  </Tab>
</Tabs>


# Solana
Source: https://docs.crossmint.com/wallets/guides/sign-message-solana

Sign messages from your wallet

<Note>
  Signing messages is not yet supported in Solana smart wallets. To send a transaction, check the [Send Transaction
  guide](/wallets/guides/send-transaction-solana).
</Note>


# Stellar
Source: https://docs.crossmint.com/wallets/guides/sign-message-stellar

Sign messages from your wallet

<Note>
  Signing messages is not yet supported in Stellar smart wallets. To send a transaction, check the [Send Transaction
  guide](/wallets/guides/send-transaction-stellar).
</Note>


# API Key Signer (Deprecated)
Source: https://docs.crossmint.com/wallets/guides/signers/api-key

Configure an API key signer for wallet creation. This signer type is deprecated.

<Warning>
  API key signers are deprecated and will be removed in a future release. All signer types require an API key for authentication, but an API key is no longer a valid standalone signer.

  If you currently use API key signers for server-side or agent operations, migrate to [server keys](/wallets/guides/signers/server-key) instead.
</Warning>

In earlier versions of the Crossmint Wallets API, an API key could be used directly as an operational signer. This model is deprecated in favor of dedicated signer types that separate authentication (API key) from transaction authorization (signer key).

For a conceptual overview, see [API key](/wallets/concepts/wallet-signers#api-key) in the Wallet Signers guide.

## Configuration

<Tabs>
  <Tab title="React">
    ```typescript theme={null}
    import { useWallet } from '@crossmint/client-sdk-react-ui';

    const { getOrCreateWallet } = useWallet();

    const wallet = await getOrCreateWallet({
        chain: "evm",
        signer: {
            type: "api-key",
        },
    });
    ```
  </Tab>

  <Tab title="Node.js">
    ```typescript theme={null}
    import { CrossmintWallets, createCrossmint } from "@crossmint/wallets-sdk";

    const crossmint = createCrossmint({
        apiKey: "<your-server-api-key>",
    });
    const crossmintWallets = CrossmintWallets.from(crossmint);

    const wallet = await crossmintWallets.createWallet({
        chain: "evm",
        signer: {
            type: "api-key",
        },
    });
    ```
  </Tab>

  <Tab title="React Native">
    ```typescript theme={null}
    import { useWallet } from '@crossmint/client-sdk-react-native-ui';

    const { getOrCreateWallet } = useWallet();

    const wallet = await getOrCreateWallet({
        chain: "evm",
        signer: {
            type: "api-key",
        },
    });
    ```
  </Tab>

  <Tab title="REST">
    <CodeGroup>
      ```bash Curl theme={null}
      curl --request POST \
          --url https://staging.crossmint.com/api/2025-06-09/wallets \
          --header 'Content-Type: application/json' \
          --header 'X-API-KEY: <x-api-key>' \
          --data '{
              "chainType": "evm",
              "config": {
                  "adminSigner": {
                      "type": "api-key"
                  }
              }
          }'
      ```

      ```js Node.js theme={null}
      const url = 'https://staging.crossmint.com/api/2025-06-09/wallets';

      const payload = {
          chainType: "evm",
          config: {
              adminSigner: {
                  type: "api-key"
              }
          }
      };

      const options = {
          method: 'POST',
          headers: {
              'X-API-KEY': '<x-api-key>',
              'Content-Type': 'application/json'
          },
          body: JSON.stringify(payload)
      };

      try {
          const response = await fetch(url, options);
          const data = await response.json();
          console.log(data);
      } catch (error) {
          console.error(error);
      }
      ```

      ```python Python theme={null}
      import requests

      url = "https://staging.crossmint.com/api/2025-06-09/wallets"

      payload = {
          "chainType": "evm",
          "config": {
              "adminSigner": {
                  "type": "api-key"
              }
          }
      }
      headers = {
          "X-API-KEY": "<x-api-key>",
          "Content-Type": "application/json"
      }

      response = requests.post(url, json=payload, headers=headers)

      print(response.json())
      ```
    </CodeGroup>
  </Tab>
</Tabs>


# Cloud KMS Signer
Source: https://docs.crossmint.com/wallets/guides/signers/cloud-kms

Configure a Cloud KMS signer using AWS KMS, Azure Key Vault, or GCP Cloud HSM.

A Cloud KMS signer uses a signing key generated and stored inside a cloud key management service — AWS KMS, Azure Key Vault, or GCP Cloud HSM. The key is non-extractable by design: no employee at your company (or at the cloud provider) can ever retrieve the raw key material.

Cloud KMS signers support advanced enterprise security controls natively, including IP allowlisting, cloud IAM-based access policies, rate limiting, circuit breakers, and detailed audit logs and alerting.

For a conceptual overview, see [Cloud KMS](/wallets/concepts/wallet-signers#cloud-kms) in the Wallet Signers guide. To learn how to register additional operational signers on an existing wallet, see [Registering a signer](/wallets/guides/signers/registering-a-signer).

## Configuration

For a step-by-step guide on setting up an AWS KMS signer, see the [AWS KMS signer guide](/stablecoin-orchestration/treasury-wallet/guides/signer-aws-kms).

<Info>
  Guides for Azure Key Vault and GCP Cloud HSM signers are coming soon. <a href="https://www.crossmint.com/contact/sales">Contact our team</a> if you need help configuring Cloud KMS signers for your project.
</Info>


# Device Key Signer
Source: https://docs.crossmint.com/wallets/guides/signers/device-key

Configure a device key signer that uses the device's secure enclave for wallet operations.

A device key signer uses P-256 keys generated inside the secure storage of the user's phone, computer, or browser — such as the iOS Secure Enclave, Android Keystore, or the browser's built-in credential store. These keys are non-extractable and never leave the device.

By default, signing is silent — transactions can be authorized without requiring the user to actively confirm each one. Device keys can optionally be configured to require biometric authentication on every use, or after a configurable idle period.

For a conceptual overview, see [Device key](/wallets/concepts/wallet-signers#device-key) in the Wallet Signers guide. To learn how to register additional operational signers on an existing wallet, see [Registering a signer](/wallets/guides/signers/registering-a-signer).

## Configuration

<Info>
  Detailed configuration guides for device key signers are coming soon. <a href="https://www.crossmint.com/contact/sales">Contact our team</a> if you need help setting up device key signers for your project.
</Info>


# Email OTP Signer
Source: https://docs.crossmint.com/wallets/guides/signers/email-otp

Configure an email OTP recovery signer for wallet recovery.

Use an email OTP signer as a **recovery signer** to let users regain access to their wallets when their operational signer is no longer available — for example, when they switch to a new device. The user verifies ownership of their email address via a one-time password, which authorizes the enrollment of a new operational signer.

<Note>
  Email OTP is a recovery signer, not an operational signer. It is not intended for authorizing day-to-day transactions. The code examples below show how to configure it as the initial signer at wallet creation time, which sets up email-based recovery for the wallet.
</Note>

For a conceptual overview, see [Email OTP](/wallets/concepts/wallet-signers#email-otp) in the Wallet Signers guide. To learn how to register operational signers on a wallet, see [Registering a signer](/wallets/guides/signers/registering-a-signer).

## Configuration

<Tabs>
  <Tab title="React">
    ```typescript theme={null}
    import { useWallet } from '@crossmint/client-sdk-react-ui';

    const { getOrCreateWallet } = useWallet();

    const wallet = await getOrCreateWallet({
        chain: "base",
        signer: {
            type: "email",
            email: "user@example.com"
        },
    });
    ```
  </Tab>

  <Tab title="Node.js">
    ```typescript theme={null}
    import { CrossmintWallets, createCrossmint } from "@crossmint/wallets-sdk";

    const crossmint = createCrossmint({
        apiKey: "<your-server-api-key>",
    });
    const crossmintWallets = CrossmintWallets.from(crossmint);

    const wallet = await crossmintWallets.createWallet({
        chain: "base",
        signer: {
            type: "email",
            email: "user@example.com"
        },
    });
    ```
  </Tab>

  <Tab title="React Native">
    ```typescript theme={null}
    import { useWallet } from '@crossmint/client-sdk-react-native-ui';

    const { getOrCreateWallet } = useWallet();

    const wallet = await getOrCreateWallet({
        chain: "base",
        signer: {
            type: "email",
            email: "user@example.com"
        },
    });
    ```
  </Tab>

  <Tab title="REST">
    <CodeGroup>
      ```bash Curl theme={null}
      curl --request POST \
          --url https://staging.crossmint.com/api/2025-06-09/wallets \
          --header 'Content-Type: application/json' \
          --header 'X-API-KEY: <x-api-key>' \
          --data '{
              "chainType": "evm",
              "config": {
                  "adminSigner": {
                      "type": "email",
                      "email": "user@example.com"
                  }
              }
          }'
      ```

      ```js Node.js theme={null}
      const url = 'https://staging.crossmint.com/api/2025-06-09/wallets';

      const payload = {
          chainType: "evm",
          config: {
              adminSigner: {
                  type: "email",
                  email: "user@example.com"
              }
          }
      };

      const options = {
          method: 'POST',
          headers: {
              'X-API-KEY': '<x-api-key>',
              'Content-Type': 'application/json'
          },
          body: JSON.stringify(payload)
      };

      try {
          const response = await fetch(url, options);
          const data = await response.json();
          console.log(data);
      } catch (error) {
          console.error(error);
      }
      ```

      ```python Python theme={null}
      import requests

      url = "https://staging.crossmint.com/api/2025-06-09/wallets"

      payload = {
          "chainType": "evm",
          "config": {
              "adminSigner": {
                  "type": "email",
                  "email": "user@example.com"
              }
          }
      }
      headers = {
          "X-API-KEY": "<x-api-key>",
          "Content-Type": "application/json"
      }

      response = requests.post(url, json=payload, headers=headers)

      print(response.json())
      ```
    </CodeGroup>
  </Tab>
</Tabs>


# External Wallet Signer
Source: https://docs.crossmint.com/wallets/guides/signers/external-wallet

Configure an external wallet or keypair as a signer for your Crossmint smart wallet.

Use an external wallet signer to connect an existing blockchain wallet or keypair — such as MetaMask, Phantom, or a raw keypair — as an operational signer on a Crossmint smart wallet. This signer type is designed for crypto-native users who already have a wallet and want to use it to control a Crossmint smart wallet.

For a conceptual overview, see [External wallet](/wallets/concepts/wallet-signers#external-wallet) in the Wallet Signers guide. To learn how to register additional operational signers on an existing wallet, see [Registering a signer](/wallets/guides/signers/registering-a-signer).

## Configuration

<Tabs>
  <Tab title="React">
    ```typescript theme={null}
    import { useWallet } from '@crossmint/client-sdk-react-ui';

    const { getOrCreateWallet } = useWallet();

    const wallet = await getOrCreateWallet({
        chain: "solana",
        signer: {
            type: "external-wallet",
            address: "WUyB2nCgAFhcf9vJ34s7vUK4KJc77bgoeM3swMcwfWn",
        },
    });
    ```
  </Tab>

  <Tab title="Node.js">
    ```typescript theme={null}
    import { CrossmintWallets, createCrossmint } from "@crossmint/wallets-sdk";

    const crossmint = createCrossmint({
        apiKey: "<your-server-api-key>",
    });
    const crossmintWallets = CrossmintWallets.from(crossmint);

    const wallet = await crossmintWallets.createWallet({
        chain: "solana",
        signer: {
            type: "external-wallet",
            address: "WUyB2nCgAFhcf9vJ34s7vUK4KJc77bgoeM3swMcwfWn",
        },
    });
    ```
  </Tab>

  <Tab title="React Native">
    ```typescript theme={null}
    import { useWallet } from '@crossmint/client-sdk-react-native-ui';

    const { getOrCreateWallet } = useWallet();

    const wallet = await getOrCreateWallet({
        chain: "solana",
        signer: {
            type: "external-wallet",
            address: "WUyB2nCgAFhcf9vJ34s7vUK4KJc77bgoeM3swMcwfWn",
        },
    });
    ```
  </Tab>

  <Tab title="REST">
    <CodeGroup>
      ```bash Curl theme={null}
      curl --request POST \
          --url https://staging.crossmint.com/api/2025-06-09/wallets \
          --header 'Content-Type: application/json' \
          --header 'X-API-KEY: <x-api-key>' \
          --data '{
              "chainType": "solana",
              "config": {
                  "adminSigner": {
                      "type": "external-wallet",
                      "address": "WUyB2nCgAFhcf9vJ34s7vUK4KJc77bgoeM3swMcwfWn"
                  }
              }
          }'
      ```

      ```js Node.js theme={null}
      const url = 'https://staging.crossmint.com/api/2025-06-09/wallets';

      const payload = {
          chainType: "solana",
          config: {
              adminSigner: {
                  type: "external-wallet",
                  address: "WUyB2nCgAFhcf9vJ34s7vUK4KJc77bgoeM3swMcwfWn"
              }
          }
      };

      const options = {
          method: 'POST',
          headers: {
              'X-API-KEY': '<x-api-key>',
              'Content-Type': 'application/json'
          },
          body: JSON.stringify(payload)
      };

      try {
          const response = await fetch(url, options);
          const data = await response.json();
          console.log(data);
      } catch (error) {
          console.error(error);
      }
      ```

      ```python Python theme={null}
      import requests

      url = "https://staging.crossmint.com/api/2025-06-09/wallets"

      payload = {
          "chainType": "solana",
          "config": {
              "adminSigner": {
                  "type": "external-wallet",
                  "address": "WUyB2nCgAFhcf9vJ34s7vUK4KJc77bgoeM3swMcwfWn"
              }
          }
      }
      headers = {
          "X-API-KEY": "<x-api-key>",
          "Content-Type": "application/json"
      }

      response = requests.post(url, json=payload, headers=headers)

      print(response.json())
      ```
    </CodeGroup>
  </Tab>
</Tabs>


# Managed Support Center Recovery
Source: https://docs.crossmint.com/wallets/guides/signers/managed-support-center

Configure managed support center recovery for high-value wallet recovery with KYC verification.

Managed support center recovery is a white-glove recovery option: the wallet owner contacts a specialized support center, completes identity verification (KYC), and a trained agent facilitates the enrollment of a new operational signer. This is the most robust recovery option available and is best reserved as a last resort for situations where all other recovery methods have been exhausted.

For a conceptual overview, see [Managed support center](/wallets/concepts/wallet-signers#managed-support-center) in the Wallet Signers guide.

## Configuration

<Info>
  Managed support center recovery requires an enterprise agreement. <a href="https://www.crossmint.com/contact/sales">Contact our team</a> to set up managed recovery for your project.
</Info>


# Passkey Signer
Source: https://docs.crossmint.com/wallets/guides/signers/passkey

Configure a passkey signer for wallet creation using WebAuthn biometrics.

Use a passkey signer to let users access their wallets and authorize transactions using biometric authentication — Face ID, Touch ID, fingerprint, or Windows Hello — or their password manager's unlock mechanism. Passkeys are built on the <a href="https://www.w3.org/TR/webauthn-3/">WebAuthn</a> standard and are synchronized across devices by providers such as Apple Keychain, Google Password Manager, 1Password, and Dashlane.

Every transaction signed with a passkey requires the user to authenticate, making this one of the most secure operational signer options.

For a conceptual overview, see [Passkey](/wallets/concepts/wallet-signers#passkey) in the Wallet Signers guide. To learn how to register additional operational signers on an existing wallet, see [Registering a signer](/wallets/guides/signers/registering-a-signer).

## Configuration

<Tabs>
  <Tab title="React">
    ```typescript theme={null}
    import { useWallet } from '@crossmint/client-sdk-react-ui';

    const { getOrCreateWallet } = useWallet();

    const wallet = await getOrCreateWallet({
        chain: "base",
        signer: {
            type: "passkey",
        },
    });
    ```
  </Tab>

  <Tab title="REST">
    When using a passkey as the recovery signer (admin signer) via REST, you must provide the credential details from your passkey registration flow (WebAuthn). The `id` is the credential identifier, `name` is a human-readable label for the passkey, and `publicKey.x` / `publicKey.y` are the public key coordinates from the registration response. In the browser, you can implement this registration flow using a WebAuthn helper library such as [`@simplewebauthn/browser`](https://www.npmjs.com/package/@simplewebauthn/browser).

    <CodeGroup>
      ```bash Curl theme={null}
      curl --request POST \
          --url https://staging.crossmint.com/api/2025-06-09/wallets \
          --header 'Content-Type: application/json' \
          --header 'X-API-KEY: <x-api-key>' \
          --data '{
              "chainType": "evm",
              "config": {
                  "adminSigner": {
                      "type": "passkey",
                      "id": "cWtP7gmZbd98HbKUuGXx5Q",
                      "name": "hgranger",
                      "publicKey": {
                          "x": "38035223810536273945556366218149112558607829411547667975304293530457502824247",
                          "y": "91117823763706733837104303008228095481082989039135234750508288790583476078729"
                      }
                  }
              }
          }'
      ```

      ```js Node.js theme={null}
      const url = 'https://staging.crossmint.com/api/2025-06-09/wallets';

      const payload = {
          chainType: "evm",
          config: {
              adminSigner: {
                  type: "passkey",
                  id: "cWtP7gmZbd98HbKUuGXx5Q",
                  name: "hgranger",
                  publicKey: {
                      x: "38035223810536273945556366218149112558607829411547667975304293530457502824247",
                      y: "91117823763706733837104303008228095481082989039135234750508288790583476078729"
                  }
              }
          }
      };

      const options = {
          method: 'POST',
          headers: {
              'X-API-KEY': '<x-api-key>',
              'Content-Type': 'application/json'
          },
          body: JSON.stringify(payload)
      };

      try {
          const response = await fetch(url, options);
          const data = await response.json();
          console.log(data);
      } catch (error) {
          console.error(error);
      }
      ```

      ```python Python theme={null}
      import requests

      url = "https://staging.crossmint.com/api/2025-06-09/wallets"

      payload = {
          "chainType": "evm",
          "config": {
              "adminSigner": {
                  "type": "passkey",
                  "id": "cWtP7gmZbd98HbKUuGXx5Q",
                  "name": "hgranger",
                  "publicKey": {
                      "x": "38035223810536273945556366218149112558607829411547667975304293530457502824247",
                      "y": "91117823763706733837104303008228095481082989039135234750508288790583476078729"
                  }
              }
          }
      }
      headers = {
          "X-API-KEY": "<x-api-key>",
          "Content-Type": "application/json"
      }

      response = requests.post(url, json=payload, headers=headers)

      print(response.json())
      ```
    </CodeGroup>
  </Tab>
</Tabs>


# Registering a Signer
Source: https://docs.crossmint.com/wallets/guides/signers/registering-a-signer

Register an operational signer on an existing Crossmint wallet.

<Warning>
  Previous versions of these guides used the term **delegated signer**. We have moved to **operational signer** as the standard terminology. The next breaking API / SDK version will adopt this naming convention in method signatures and types. Until then, the code snippets below still reference `addDelegatedSigner` and `delegatedSigners`.
</Warning>

Register an operational signer on an existing wallet for day-to-day operations. This signer can be set up with the wallet owner — for example, a device key for user wallets or a server key for company wallets.

For an overview of available signer types, see [Wallet Signers](/wallets/concepts/wallet-signers).

## Prerequisites

* Ensure you have a wallet created.
* **API Key**: Ensure you have an API key with the scopes: `wallets:signatures.create` and `wallets:transactions.create`.

## Adding an operational signer

<Tabs>
  <Tab title="React">
    ```typescript theme={null}
    import { useWallet } from '@crossmint/client-sdk-react-ui';

    const { wallet } = useWallet();

    const externalSigner = {
        type: "external-wallet",
        address: "0x1234567890123456789012345678901234567890"
    }

    await wallet.addDelegatedSigner({
        signer: externalSigner,
    });
    ```

    See the [React SDK reference](/sdk-reference/wallets/react/hooks#wallet-methods) for more details.
  </Tab>

  <Tab title="Node.js">
    ```typescript theme={null}
    import { CrossmintWallets, createCrossmint } from "@crossmint/wallets-sdk";

    const crossmint = createCrossmint({
        apiKey: "<your-server-api-key>",
    });

    const crossmintWallets = CrossmintWallets.from(crossmint);

    const wallet = await crossmintWallets.getWallet(
        "email:user@example.com:evm",
        { chain: "base-sepolia", signer: { type: "email" } }
    );

    const externalSigner = {
        type: "external-wallet",
        address: "0x1234567890123456789012345678901234567890"
    }

    await wallet.addDelegatedSigner({
        signer: externalSigner,
    });
    ```

    ### Parameters

    <ResponseField name="signer" type="string | object">
      The locator of the signer to add.
    </ResponseField>
  </Tab>

  <Tab title="React Native">
    ```typescript theme={null}
    import { useWallet } from '@crossmint/client-sdk-react-native-ui';

    const { wallet } = useWallet();

    const externalSigner = {
        type: "external-wallet",
        address: "0x1234567890123456789012345678901234567890"
    }

    await wallet.addDelegatedSigner({
        signer: externalSigner,
    });
    ```

    See the [React Native SDK reference](/sdk-reference/wallets/react-native/hooks#wallet-methods) for more details.
  </Tab>

  <Tab title="REST">
    Operational signers must be approved by the wallet's recovery signer (called `adminSigner` in the current API).
    The SDK handles this automatically, but with the REST API you must [approve the transaction](/api-reference/wallets/approve-transaction) (if using Solana, Stellar)
    or [signature](/api-reference/wallets/approve-signature) (if using EVM) to complete it.

    <Steps>
      <Step title="Create the operational signer">
        Call the [create delegated signer](/api-reference/wallets/register-delegated-key) endpoint.

        <CodeGroup>
          ```bash cURL theme={null}
          curl --request POST \
              --url https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:evm/signers \
              --header 'Content-Type: application/json' \
              --header 'X-API-KEY: <x-api-key>' \
              --data '{
                  "chain": "base",
                  "signer": "external-wallet:0x1234567890123456789012345678901234567890"
              }'
          ```

          ```js Node.js theme={null}
          const url = 'https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:evm/signers';

          const payload = {
              chain: "base",
              signer: "external-wallet:0x1234567890123456789012345678901234567890"
          };

          const options = {
              method: 'POST',
              headers: {
                  'X-API-KEY': '<x-api-key>',
                  'Content-Type': 'application/json'
              },
              body: JSON.stringify(payload)
          };

          try {
              const response = await fetch(url, options);
              const data = await response.json();
              console.log(data);
          } catch (error) {
              console.error(error);
          }
          ```

          ```python Python theme={null}
          import requests

          url = "https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:evm/signers"

          payload = {
              "chain": "base",
              "signer": "external-wallet:0x1234567890123456789012345678901234567890"
          }
          headers = {
              "X-API-KEY": "<x-api-key>",
              "Content-Type": "application/json"
          }

          response = requests.post(url, json=payload, headers=headers)

          print(response.json())
          ```
        </CodeGroup>

        See the [API reference](/api-reference/wallets/register-delegated-key) for more details.
      </Step>

      <Step title="Sign the approval returned in the response">
        <Note>
          If you are using an `api-key` as the recovery signer (admin signer) you can skip the following steps.
        </Note>

        Sign the approval message field returned in the response inside `transaction.approvals` (for EVM) or `signature.approvals` (for Solana and Stellar)             using the recovery signer (admin signer).
      </Step>

      <Step title="Approve the transaction or signature to register the operational signer">
        <Tabs>
          <Tab title="EVM">
            Call the [approve signature](/api-reference/wallets/approve-signature) endpoint using the signature from the previous step and the signature id returned in the call from Step 1.

            <CodeGroup>
              ```bash cURL theme={null}
              curl --request POST \
                  --url https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:evm/signatures/b984491a-5785-43c0-8811-45d46fe6e520/approvals \
                  --header 'Content-Type: application/json' \
                  --header 'X-API-KEY: <x-api-key>' \
                  --data '{
                      "approvals": [{
                          "signer": "email:user@example.com",
                          "signature": "0x1234567890abcdef..."
                      }]
                  }'
              ```

              ```js Node.js theme={null}
              const url = 'https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:evm/signatures/b984491a-5785-43c0-8811-45d46fe6e520/approvals';

              const payload = {
                  approvals: [{
                      signer: "email:user@example.com",
                      signature: "0x1234567890abcdef..."
                  }]
              };

              const options = {
                  method: 'POST',
                  headers: {
                      'X-API-KEY': '<x-api-key>',
                      'Content-Type': 'application/json'
                  },
                  body: JSON.stringify(payload)
              };

              try {
                  const response = await fetch(url, options);
                  const data = await response.json();
                  console.log(data);
              } catch (error) {
                  console.error(error);
              }
              ```

              ```python Python theme={null}
              import requests

              url = "https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:evm/signatures/b984491a-5785-43c0-8811-45d46fe6e520/approvals"

              payload = {
                  "approvals": [{
                      "signer": "email:user@example.com",
                      "signature": "0x1234567890abcdef..."
                  }]
              }
              headers = {
                  "X-API-KEY": "<x-api-key>",
                  "Content-Type": "application/json"
              }

              response = requests.post(url, json=payload, headers=headers)

              print(response.json())
              ```
            </CodeGroup>

            See the [API reference](/api-reference/wallets/approve-signature) for more details.
          </Tab>

          <Tab title="Solana and Stellar">
            Call the [approve transaction](/api-reference/wallets/approve-transaction) endpoint using the signature from the previous step and the transaction id returned in the call from Step 1.

            <CodeGroup>
              ```bash cURL theme={null}
              curl --request POST \
                  --url https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:solana/transactions/b984491a-5785-43c0-8811-45d46fe6e520/approvals \
                  --header 'Content-Type: application/json' \
                  --header 'X-API-KEY: <x-api-key>' \
                  --data '{
                      "approvals": [{
                          "signer": "email:user@example.com",
                          "signature": "5qY6wXw6zTn7..."
                      }]
                  }'
              ```

              ```js Node.js theme={null}
              const url = 'https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:solana/transactions/b984491a-5785-43c0-8811-45d46fe6e520/approvals';

              const payload = {
                  approvals: [{
                      signer: "email:user@example.com",
                      signature: "5qY6wXw6zTn7..."
                  }]
              };

              const options = {
                  method: 'POST',
                  headers: {
                      'X-API-KEY': '<x-api-key>',
                      'Content-Type': 'application/json'
                  },
                  body: JSON.stringify(payload)
              };

              try {
                  const response = await fetch(url, options);
                  const data = await response.json();
                  console.log(data);
              } catch (error) {
                  console.error(error);
              }
              ```

              ```python Python theme={null}
              import requests

              url = "https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:solana/transactions/b984491a-5785-43c0-8811-45d46fe6e520/approvals"

              payload = {
                  "approvals": [{
                      "signer": "email:user@example.com",
                      "signature": "5qY6wXw6zTn7..."
                  }]
              }
              headers = {
                  "X-API-KEY": "<x-api-key>",
                  "Content-Type": "application/json"
              }

              response = requests.post(url, json=payload, headers=headers)

              print(response.json())
              ```
            </CodeGroup>

            See the [API reference](/api-reference/wallets/approve-transaction) for more details.
          </Tab>
        </Tabs>
      </Step>
    </Steps>
  </Tab>
</Tabs>

## Listing all operational signers

<Tabs>
  <Tab title="React">
    ```typescript theme={null}
    import { useWallet } from '@crossmint/client-sdk-react-ui';

    const { wallet } = useWallet();

    const signers = await wallet.delegatedSigners();
    ```

    See the [React SDK reference](/sdk-reference/wallets/react/hooks#wallet-methods) for more details.
  </Tab>

  <Tab title="Node.js">
    ```typescript theme={null}
    import { CrossmintWallets, createCrossmint } from "@crossmint/wallets-sdk";

    const crossmint = createCrossmint({
        apiKey: "<your-server-api-key>",
    });

    const crossmintWallets = CrossmintWallets.from(crossmint);

    const wallet = await crossmintWallets.getWallet(
        "email:user@example.com:evm",
        { chain: "base-sepolia", signer: { type: "email" } }
    );

    const signers = await wallet.delegatedSigners();
    ```

    ### Returns

    <ResponseField name="signers" type="DelegatedSigner[]">
      The operational signers.

      <Expandable title="properties">
        <ResponseField name="signer" type="string">
          The locator of the signer.
        </ResponseField>
      </Expandable>
    </ResponseField>
  </Tab>

  <Tab title="React Native">
    ```typescript React Native theme={null}
    import { useWallet } from '@crossmint/client-sdk-react-native-ui';

    const { wallet } = useWallet();

    const signers = await wallet.delegatedSigners();
    ```

    See the [React Native SDK reference](/sdk-reference/wallets/react-native/hooks#wallet-methods) for more details.
  </Tab>

  <Tab title="REST">
    <CodeGroup>
      ```bash cURL theme={null}
      curl --request GET \
          --url https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:evm \
          --header 'X-API-KEY: <x-api-key>'
      ```

      ```js Node.js theme={null}
      const url = 'https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:evm';

      const options = {
          method: 'GET',
          headers: {
              'X-API-KEY': '<x-api-key>'
          }
      };

      try {
          const response = await fetch(url, options);
          const data = await response.json();
          console.log(data);
      } catch (error) {
          console.error(error);
      }
      ```

      ```python Python theme={null}
      import requests

      url = "https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:evm"

      headers = {"X-API-KEY": "<x-api-key>"}

      response = requests.get(url, headers=headers)

      print(response.json())
      ```
    </CodeGroup>

    See the [API reference](/api-reference/wallets/get-wallet-by-locator) for more details.
  </Tab>
</Tabs>


# Server Key Signer
Source: https://docs.crossmint.com/wallets/guides/signers/server-key

Configure a server key signer for server-side and agent wallet operations.

A server key signer uses a P-256 or native blockchain keypair injected as an environment variable (or equivalent secret) into a server-side application. Signing happens entirely in-process with no external network call, making this the lowest-latency option available.

Because this key lives as a secret in your infrastructure, enforcing regular rotations is recommended — for example, quarterly — to limit exposure in the event of a compromised environment, a departed employee, or an infrastructure incident.

For a conceptual overview, see [Server key](/wallets/concepts/wallet-signers#server-key) in the Wallet Signers guide. To learn how to register additional operational signers on an existing wallet, see [Registering a signer](/wallets/guides/signers/registering-a-signer).

## Configuration

<Info>
  Detailed configuration guides for server key signers are coming soon. <a href="https://www.crossmint.com/contact/sales">Contact our team</a> if you need help setting up server key signers for your project.
</Info>


# SMS OTP Signer
Source: https://docs.crossmint.com/wallets/guides/signers/sms-otp

Configure an SMS OTP recovery signer for wallet recovery.

Use an SMS OTP signer as a **recovery signer** to let users regain access to their wallets when their operational signer is no longer available — for example, when they switch to a new device. The user verifies ownership of their phone number via a one-time password delivered by SMS or optionally WhatsApp, which authorizes the enrollment of a new operational signer.

<Note>
  SMS OTP is a recovery signer, not an operational signer. It is not intended for authorizing day-to-day transactions. The code examples below show how to configure it as the initial signer at wallet creation time, which sets up phone-based recovery for the wallet.
</Note>

For a conceptual overview, see [SMS OTP](/wallets/concepts/wallet-signers#sms-otp) in the Wallet Signers guide. To learn how to register operational signers on a wallet, see [Registering a signer](/wallets/guides/signers/registering-a-signer).

## Configuration

<Tabs>
  <Tab title="React">
    ```typescript theme={null}
    import { useWallet } from '@crossmint/client-sdk-react-ui';

    const { getOrCreateWallet } = useWallet();

    const wallet = await getOrCreateWallet({
        chain: "base",
        signer: {
            type: "phone",
            phone: "+1234567890"
        },
    });
    ```
  </Tab>

  <Tab title="Node.js">
    ```typescript theme={null}
    import { CrossmintWallets, createCrossmint } from "@crossmint/wallets-sdk";

    const crossmint = createCrossmint({
        apiKey: "<your-server-api-key>",
    });
    const crossmintWallets = CrossmintWallets.from(crossmint);

    const wallet = await crossmintWallets.createWallet({
        chain: "base",
        signer: {
            type: "phone",
            phone: "+1234567890"
        },
    });
    ```
  </Tab>

  <Tab title="React Native">
    ```typescript theme={null}
    import { useWallet } from '@crossmint/client-sdk-react-native-ui';

    const { getOrCreateWallet } = useWallet();

    const wallet = await getOrCreateWallet({
        chain: "base",
        signer: {
            type: "phone",
            phone: "+1234567890"
        },
    });
    ```
  </Tab>

  <Tab title="REST">
    <CodeGroup>
      ```bash Curl theme={null}
      curl --request POST \
          --url https://staging.crossmint.com/api/2025-06-09/wallets \
          --header 'Content-Type: application/json' \
          --header 'X-API-KEY: <x-api-key>' \
          --data '{
              "chainType": "evm",
              "config": {
                  "adminSigner": {
                      "type": "phone",
                      "phone": "+1234567890"
                  }
              }
          }'
      ```

      ```js Node.js theme={null}
      const url = 'https://staging.crossmint.com/api/2025-06-09/wallets';

      const payload = {
          chainType: "evm",
          config: {
              adminSigner: {
                  type: "phone",
                  phone: "+1234567890"
              }
          }
      };

      const options = {
          method: 'POST',
          headers: {
              'X-API-KEY': '<x-api-key>',
              'Content-Type': 'application/json'
          },
          body: JSON.stringify(payload)
      };

      try {
          const response = await fetch(url, options);
          const data = await response.json();
          console.log(data);
      } catch (error) {
          console.error(error);
      }
      ```

      ```python Python theme={null}
      import requests

      url = "https://staging.crossmint.com/api/2025-06-09/wallets"

      payload = {
          "chainType": "evm",
          "config": {
              "adminSigner": {
                  "type": "phone",
                  "phone": "+1234567890"
              }
          }
      }
      headers = {
          "X-API-KEY": "<x-api-key>",
          "Content-Type": "application/json"
      }

      response = requests.post(url, json=payload, headers=headers)

      print(response.json())
      ```
    </CodeGroup>
  </Tab>
</Tabs>


# Social Recovery Signer
Source: https://docs.crossmint.com/wallets/guides/signers/social-recovery

Configure social recovery to let a trusted contact authorize wallet recovery.

Social recovery lets a wallet owner designate a trusted contact — a friend, family member, or colleague — who can authorize wallet recovery on the owner's behalf via their own email or phone OTP. The trusted contact does not have access to the wallet itself; they can only co-authorize a recovery event.

This recovery mechanism is best used in combination with another recovery signer (such as email or SMS OTP) rather than in isolation.

For a conceptual overview, see [Social recovery](/wallets/concepts/wallet-signers#social-recovery) in the Wallet Signers guide.

## Configuration

<Note>
  Social recovery is coming in Q2 2026. <a href="https://www.crossmint.com/contact/sales">Contact our team</a> to learn more or get early access.
</Note>


# Spam Filters
Source: https://docs.crossmint.com/wallets/guides/spam-filters

Automatically block spam NFTs from your wallets

<Warning>
  Spam filters require an enterprise subscription. [Contact us](https://www.crossmint.com/contact/sales) to learn
  more.
</Warning>

Blocking spam NFTs from wallets is critical to delivering a good user experience and keeping your users safe, specially in low cost chains where spam is widespread.

Once spam filters are enabled for your project, the API to [get NFTs](/api-reference/wallets/get-nfts-from-wallet) from a wallet will flag spam NFTs, which you can use to hide potentially malicious assets.

You can access this information in two ways:

### Mode 1: Boolean

The API returns an `isSpam` attribute with values `true` or `false` based on Crossmint's default rules.

<Accordion title="See sample response">
  ```
  {
      "chain":"polygon",
      "contractAddress":"0xC5F45D4B5Be198A430b39D194cbB32132BE2cfec",
      "tokenId":"1",
      "metadata":{
      ...
      },
      "locator":"poly:0xC5F45D4B5Be198A430b39D194cbB32132BE2cfec:1",
      "tokenStandard":"erc-721",
      "isSpam":true
  }
  ```
</Accordion>

### Mode 2: Spam Score

The API returns a `spamScore` between 0-100 (100 = most likely to be spam), so you can adjust your tolerance threshold.

<Accordion title="See sample response">
  ```
  {
      "chain":"polygon",
      "contractAddress":"0xC5F45D4B5Be198A430b39D194cbB32132BE2cfec",
      "tokenId":"1",
      "metadata":{
      ...
      },
      "locator":"poly:0xC5F45D4B5Be198A430b39D194cbB32132BE2cfec:1",
      "tokenStandard":"erc-721",
      "spamScore":50 //This is a range of 0-100 
  }
  ```
</Accordion>


# Transfer Tokens
Source: https://docs.crossmint.com/wallets/guides/transfer-tokens

Transfer tokens between wallets using Crossmint's APIs

## Prerequisites

* **Wallet**: [Create a wallet](/wallets/guides/create-wallet) to transfer from.
* **Test Tokens**: Fund your wallet with [USDXM testnet tokens](/wallets/guides/get-staging-tokens) before transferring.
* **API Key**: Get an API key with the `wallets:transactions.create` scope. In staging, all scopes are included by default.

## What is a token transfer?

A token transfer moves a token from one wallet address to another onchain. This creates an onchain transaction that costs gas, which Crossmint handles for you. Once the blockchain confirms the transaction, the transfer is final and cannot be reversed.

## Sending tokens

<Tabs>
  <Tab title="React">
    ```typescript theme={null}
    import { useWallet } from '@crossmint/client-sdk-react-ui';

    const { wallet } = useWallet();

    const { hash, explorerLink } = await wallet.send("0x0D282906CDD8F6934d60E4dCAa79fa5B1c7a1925", "usdxm", "3.14");
    ```

    See the [React SDK reference](/sdk-reference/wallets/react/hooks#wallet-methods) for more details.
  </Tab>

  <Tab title="Node.js">
    ```typescript theme={null}
    import { CrossmintWallets, createCrossmint } from "@crossmint/wallets-sdk";

    const crossmint = createCrossmint({
        apiKey: "<your-server-api-key>",
    });

    const crossmintWallets = CrossmintWallets.from(crossmint);

    const wallet = await crossmintWallets.getWallet(
        "email:user@example.com:evm",
        { chain: "base-sepolia", signer: { type: "email" } }
    );

    const { hash, explorerLink } = await wallet.send("0x0D282906CDD8F6934d60E4dCAa79fa5B1c7a1925", "usdxm", "3.14");
    ```
  </Tab>

  <Tab title="React Native">
    ```typescript theme={null}
    import { useWallet } from '@crossmint/client-sdk-react-native-ui';

    const { wallet } = useWallet();

    const { hash, explorerLink } = await wallet.send("0x0D282906CDD8F6934d60E4dCAa79fa5B1c7a1925", "usdxm", "3.14");
    ```

    See the [React Native SDK reference](/sdk-reference/wallets/react-native/hooks#wallet-methods) for more details.
  </Tab>

  <Tab title="Swift">
    ```swift theme={null}
    import CrossmintClient
    import Wallet

    let sdk = CrossmintSDK.shared

    let wallet = try await sdk.crossmintWallets.getOrCreateWallet(
        chain: .baseSepolia,
        signer: .email("user@example.com")
    )

    let result = try await wallet.send("0x0D282906CDD8F6934d60E4dCAa79fa5B1c7a1925", "usdxm", 3.14)
    ```
  </Tab>

  <Tab title="REST">
    Transfers must be approved by one of the wallet's [signers](/wallets/concepts/wallet-signers).
    The SDK handles this automatically, but with the REST API you may need to craft, sign, and submit the approval manually.

    <Steps>
      <Step title="Create the transaction">
        Call the [transfer token](/api-reference/wallets/transfer-token) endpoint.

        <CodeGroup>
          ```bash Curl theme={null}
          curl --request POST \
              --url https://staging.crossmint.com/api/2025-06-09/wallets/<walletAddress>/tokens/base-sepolia:usdc/transfers \
              --header 'Content-Type: application/json' \
              --header 'X-API-KEY: <x-api-key>' \
              --data '{
                  "recipient": "<recipientAddress>",
                  "amount": "3.14",
                  "signer": "external-wallet:<externalWalletAddress>"
              }'
          ```

          ```js Node.js theme={null}
          const url = 'https://staging.crossmint.com/api/2025-06-09/wallets/<walletAddress>/tokens/base-sepolia:usdc/transfers';

          const payload = {
              recipient: "<recipientAddress>",
              amount: "3.14",
              signer: "external-wallet:<externalWalletAddress>"
          };

          const options = {
              method: 'POST',
              headers: {
                  'X-API-KEY': '<x-api-key>',
                  'Content-Type': 'application/json'
              },
              body: JSON.stringify(payload)
          };

          try {
              const response = await fetch(url, options);
              const data = await response.json();
              console.log(data);
          } catch (error) {
              console.error(error);
          }
          ```

          ```python Python theme={null}
          import requests

          url = "https://staging.crossmint.com/api/2025-06-09/wallets/<walletAddress>/tokens/base-sepolia:usdc/transfers"

          payload = {
              "recipient": "<recipientAddress>",
              "amount": "3.14",
              "signer": "external-wallet:<externalWalletAddress>"
          }
          headers = {
              "X-API-KEY": "<x-api-key>",
              "Content-Type": "application/json"
          }

          response = requests.post(url, json=payload, headers=headers)

          print(response.json())
          ```
        </CodeGroup>

        See the [API reference](/api-reference/wallets/transfer-token) for more details.
      </Step>

      <Step title="Choose your signer type">
        The next steps depend on which signer type you specified in the previous step.

        <Tabs>
          <Tab title="API Key">
            <Note>[Contact us](https://www.crossmint.com/contact/sales) for access to API key signers.</Note>

            [API Key](/wallets/guides/signers/api-key) signers require no additional steps. Crossmint approves transactions automatically when using API key authentication, so the remaining steps in this guide do not apply.
          </Tab>

          <Tab title="External Wallet">
            For [External Wallet](/wallets/guides/signers/external-wallet) signers, you must manually sign the approval message and submit it via the API. The response from Step 1 includes a pending approval with a `message` field that must be signed exactly as returned.

            From the previous step's response, extract:

            * `id` - The transaction ID (used in the next step)
            * `approvals.pending[0].message` - The hex message to sign

            Sign the message using your external wallet. The message is a raw hex string and must be signed exactly as returned. Here's an example using an EVM wallet with [Viem](https://viem.sh/):

            ```typescript theme={null}
            import { privateKeyToAccount } from "viem/accounts";

            // The message from tx.approvals.pending[0].message
            const messageToSign = "<messageFromResponse>";

            // Sign the message exactly as returned (raw hex)
            const account = privateKeyToAccount(`0x${"<privateKey>"}`);
            const signature = await account.signMessage({
                message: { raw: messageToSign },
            });
            ```
          </Tab>

          <Tab title="Email & Phone">
            [Email and phone](/wallets/guides/signers/email-otp) signers require client-side OTP verification and key derivation, which the Crossmint SDK handles automatically. While REST API signing is technically possible, Crossmint does not recommend it because you would still need client-side SDK integration for the signing step.

            <Warning>
              Crossmint recommends using the React, React Native, Swift, or Node.js SDK examples instead. The SDK handles the full signing flow for email and phone signers.
            </Warning>
          </Tab>

          <Tab title="Passkey">
            [Passkey](/wallets/guides/signers/passkey) signers use WebAuthn for biometric or password manager authentication, which requires browser interaction. While REST API signing is technically possible, Crossmint does not recommend it because you would still need client-side SDK integration for the WebAuthn signing step.

            <Warning>
              Crossmint recommends using the React, React Native, Swift, or Node.js SDK examples instead. The SDK handles the full passkey signing flow automatically.
            </Warning>
          </Tab>
        </Tabs>
      </Step>

      <Step title="Submit the approval">
        <Note>
          Skip this step if using an `api-key` signer.
        </Note>

        Call the [approve transaction](/api-reference/wallets/approve-transaction) endpoint with the signature from Step 2 and the transaction ID from Step 1.

        <CodeGroup>
          ```bash cURL theme={null}
          curl --request POST \
              --url https://staging.crossmint.com/api/2025-06-09/wallets/<walletAddress>/transactions/<txId>/approvals \
              --header 'Content-Type: application/json' \
              --header 'X-API-KEY: <x-api-key>' \
              --data '{
                  "approvals": [{
                      "signer": "external-wallet:<externalWalletAddress>",
                      "signature": "<signature>"
                  }]
              }'
          ```

          ```js Node.js theme={null}
          const url = 'https://staging.crossmint.com/api/2025-06-09/wallets/<walletAddress>/transactions/<txId>/approvals';

          const payload = {
              approvals: [{
                  signer: "external-wallet:<externalWalletAddress>",
                  signature: "<signature>"
              }]
          };

          const options = {
              method: 'POST',
              headers: {
                  'X-API-KEY': '<x-api-key>',
                  'Content-Type': 'application/json'
              },
              body: JSON.stringify(payload)
          };

          try {
              const response = await fetch(url, options);
              const data = await response.json();
              console.log(data);
          } catch (error) {
              console.error(error);
          }
          ```

          ```python Python theme={null}
          import requests

          url = "https://staging.crossmint.com/api/2025-06-09/wallets/<walletAddress>/transactions/<txId>/approvals"

          payload = {
              "approvals": [{
                  "signer": "external-wallet:<externalWalletAddress>",
                  "signature": "<signature>"
              }]
          }
          headers = {
              "X-API-KEY": "<x-api-key>",
              "Content-Type": "application/json"
          }

          response = requests.post(url, json=payload, headers=headers)

          print(response.json())
          ```
        </CodeGroup>

        See the [API reference](/api-reference/wallets/approve-transaction) for more details.
      </Step>

      <Step title="(Optional) Check transaction status">
        You can poll the transaction status to confirm it completed successfully.

        <CodeGroup>
          ```bash cURL theme={null}
          curl --request GET \
              --url https://staging.crossmint.com/api/2025-06-09/wallets/<walletAddress>/transactions/<txId> \
              --header 'X-API-KEY: <x-api-key>'
          ```

          ```js Node.js theme={null}
          const url = 'https://staging.crossmint.com/api/2025-06-09/wallets/<walletAddress>/transactions/<txId>';

          const options = {
              method: 'GET',
              headers: {
                  'X-API-KEY': '<x-api-key>'
              }
          };

          try {
              const response = await fetch(url, options);
              const data = await response.json();
              console.log(data);
          } catch (error) {
              console.error(error);
          }
          ```

          ```python Python theme={null}
          import requests

          url = "https://staging.crossmint.com/api/2025-06-09/wallets/<walletAddress>/transactions/<txId>"

          headers = {
              "X-API-KEY": "<x-api-key>"
          }

          response = requests.get(url, headers=headers)

          print(response.json())
          ```
        </CodeGroup>
      </Step>
    </Steps>

    ### Complete example

    Here's a complete, copy-pastable example for the `external-wallet` signer flow using <Tooltip>Viem</Tooltip>:

    ```typescript theme={null}
    import { privateKeyToAccount } from "viem/accounts";

    // ============================
    // Config (replace placeholders)
    // ============================
    const API_BASE_URL = "https://staging.crossmint.com";
    const API_VERSION = "2025-06-09";

    const API_KEY = "<x-api-key>";
    const WALLET_ADDRESS = "<walletAddress>";
    const CHAIN = "base-sepolia";
    const TOKEN = "usdc";

    // The externally-owned address that will sign the approval message:
    const EXTERNAL_WALLET_ADDRESS = "<externalWalletAddress>";

    const RECIPIENT_ADDRESS = "<recipientAddress>";

    const AMOUNT = "0.69";

    const headers = {
        "X-API-KEY": API_KEY,
        "Content-Type": "application/json",
    };

    // ============================
    // STEP 1: Create the transaction
    // ============================
    const createTransferUrl = `${API_BASE_URL}/api/${API_VERSION}/wallets/${WALLET_ADDRESS}/tokens/${CHAIN}:${TOKEN}/transfers`;

    const createTransferPayload = {
        recipient: RECIPIENT_ADDRESS,
        amount: AMOUNT,
        signer: `external-wallet:${EXTERNAL_WALLET_ADDRESS}`,
    };

    const createTransferRes = await fetch(createTransferUrl, {
        method: "POST",
        headers,
        body: JSON.stringify(createTransferPayload),
    });

    if (!createTransferRes.ok) {
        throw new Error(
            `Failed to create transfer: ${createTransferRes.status} ${await createTransferRes.text()}`
        );
    }

    const tx = await createTransferRes.json();
    const txId = tx.id;
    const messageToSign = tx?.approvals?.pending?.[0]?.message;

    if (!messageToSign) {
        throw new Error(
            "No approval message found. Ensure signer is external-wallet and that an approval is pending."
        );
    }

    console.log("txId:", txId);
    console.log("messageToSign:", messageToSign);

    // ============================
    // STEP 2: Sign the approval message (Viem)
    // ============================
    // IMPORTANT: sign the message EXACTLY as returned (a raw hex string).
    const account = privateKeyToAccount(`0x${"<privateKey>"}`);

    const signature = await account.signMessage({
        message: { raw: messageToSign },
    });

    console.log("signature:", signature);

    // ============================
    // STEP 3: Submit the signature
    // ============================
    const submitApprovalUrl = `${API_BASE_URL}/api/${API_VERSION}/wallets/${WALLET_ADDRESS}/transactions/${txId}/approvals`;

    const submitApprovalPayload = {
        approvals: [
            {
                signer: `external-wallet:${EXTERNAL_WALLET_ADDRESS}`,
                signature,
            },
        ],
    };

    const submitApprovalRes = await fetch(submitApprovalUrl, {
        method: "POST",
        headers,
        body: JSON.stringify(submitApprovalPayload),
    });

    if (!submitApprovalRes.ok) {
        throw new Error(
            `Failed to submit approval: ${submitApprovalRes.status} ${await submitApprovalRes.text()}`
        );
    }

    const approvalResult = await submitApprovalRes.json();
    console.log("approvalResult:", approvalResult);

    // ============================
    // STEP 4 (optional): Check transaction status
    // ============================
    const getTxUrl = `${API_BASE_URL}/api/${API_VERSION}/wallets/${WALLET_ADDRESS}/transactions/${txId}`;

    const getTxRes = await fetch(getTxUrl, { method: "GET", headers });

    if (!getTxRes.ok) {
        throw new Error(
            `Failed to fetch transaction: ${getTxRes.status} ${await getTxRes.text()}`
        );
    }

    const txStatus = await getTxRes.json();
    console.log("txStatus:", txStatus);
    ```
  </Tab>
</Tabs>

See the [API reference](/api-reference/wallets/transfer-token) for all supported locator formats.

## Verify your transfer

Once the transfer completes, you can verify it in two ways:

1. **View the onchain transaction** using the `explorerLink` returned by the `send` method:

```typescript theme={null}
console.log("View transaction:", explorerLink);
// Example: https://sepolia.basescan.org/tx/0xe5844116732d6cd21127bfc100ba29aee02b82cc4ab51e134d44e719ca8d0b48
```

2. **Check the recipient's balance** programmatically using the [check balances API](/wallets/guides/check-balances).

## Next steps

<CardGroup>
  <Card title="Monitor transfers with webhooks" icon="bell" href="/wallets/guides/monitor-transfers-webhooks">
    Track transactions and receive completion notifications
  </Card>

  <Card title="How to check wallet balances" icon="wallet" href="/wallets/guides/check-balances">
    Query token balances across your wallets
  </Card>

  <Card title="Test the Transfer Tokens API" icon="code" href="/api-reference/wallets/transfer-token">
    Try out the API in the interactive playground
  </Card>
</CardGroup>


# LI.FI
Source: https://docs.crossmint.com/wallets/guides/wallet-extensions/bridge-lifi

Bridge tokens between chains using Crossmint wallets and LI.FI

This guide explains how to bridge tokens across chains using the <a href="https://docs.li.fi/li.fi-api/li.fi-api">LI.FI</a> API with Crossmint wallets. LI.FI aggregates bridges and DEXs to find optimal cross-chain routes.

## Prerequisites

To use LI.FI bridging with Crossmint wallets, you need:

* A Crossmint [wallet](/wallets/guides/create-wallet) on any supported EVM chain
* A **production** **API Key** with the scope: `wallets:transactions.create` (create in the <a href="https://www.crossmint.com/console">Production Console</a>)

This guide uses Base → Polygon as an example. To follow along, you will also need:

* USDC on Base mainnet in the wallet
* ETH on Base for gas fees (not required if [gas sponsorship](/wallets/guides/gas-sponsorship) is enabled)

You can adapt the code to bridge between any chains and tokens that LI.FI supports. See [Customizing the Bridge](#customizing-the-bridge) below.

## Bridge Tokens

High level steps to bridging tokens with LI.FI and Crossmint:

1. Request a bridge quote from the LI.FI API
2. Approve the LI.FI router to spend the source token
3. Execute the bridge transaction using the quote calldata
4. Poll the LI.FI status endpoint until the bridge completes

<Warning>
  Cross-chain bridges operate on mainnet only. The wallet must hold sufficient tokens on the source chain and ETH for gas fees.
</Warning>

<Tabs>
  <Tab title="React">
    ```typescript theme={null}
    import { useWallet, EVMWallet } from "@crossmint/client-sdk-react-ui";
    import { encodeFunctionData, erc20Abi, parseUnits } from "viem";

    const LIFI_API = "https://li.quest/v1";
    const FROM_CHAIN = "8453"; // Base
    const TO_CHAIN = "137"; // Polygon
    const FROM_TOKEN = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"; // USDC on Base
    const TO_TOKEN = "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359"; // USDC on Polygon
    const USDC_DECIMALS = 6;

    export function BridgeComponent() {
        const { wallet } = useWallet();

        async function bridge(amount: string) {
            if(!wallet) return;
            const evmWallet = EVMWallet.from(wallet);

            // 1. Get a bridge quote from the LI.FI API
            const quoteRes = await fetch(
                `${LIFI_API}/quote?` +
                    new URLSearchParams({
                        fromChain: FROM_CHAIN,
                        toChain: TO_CHAIN,
                        fromToken: FROM_TOKEN,
                        toToken: TO_TOKEN,
                        fromAmount: parseUnits(amount, USDC_DECIMALS).toString(),
                        fromAddress: wallet.address,
                        integrator: "crossmint",
                    })
            );
            if (!quoteRes.ok) {
                throw new Error(`Quote request failed: ${quoteRes.status}`);
            }
            const quote = await quoteRes.json();

            // 2. Approve the LI.FI router to spend USDC
            if (quote.estimate.approvalAddress) {
                await evmWallet.sendTransaction({
                    to: FROM_TOKEN,
                    data: encodeFunctionData({
                        abi: erc20Abi,
                        functionName: "approve",
                        args: [
                            quote.estimate.approvalAddress,
                            parseUnits(amount, USDC_DECIMALS),
                        ],
                    }),
                });
            }

            // 3. Execute the bridge transaction
            const tx = await evmWallet.sendTransaction({
                to: quote.transactionRequest.to,
                data: quote.transactionRequest.data,
                value: quote.transactionRequest.value
                    ? BigInt(quote.transactionRequest.value)
                    : 0n,
            });

            // 4. Poll the LI.FI status endpoint until completion
            let status = "PENDING";
            while (status === "PENDING" || status === "NOT_FOUND") {
                await new Promise((r) => setTimeout(r, 5000));
                const statusRes = await fetch(
                    `${LIFI_API}/status?` +
                        new URLSearchParams({
                            txHash: tx.hash,
                            fromChain: FROM_CHAIN,
                            toChain: TO_CHAIN,
                        })
                );
                const s = await statusRes.json();
                status = s.status;
            }
        }

        return (
            <button onClick={() => bridge("5")}>Bridge Tokens</button>
        );
    }
    ```

    See the [React SDK reference](/sdk-reference/wallets/react/hooks#wallet-methods) for more details.
  </Tab>

  <Tab title="Node.js">
    ```typescript theme={null}
    import { CrossmintWallets, createCrossmint, EVMWallet } from "@crossmint/wallets-sdk";
    import { encodeFunctionData, erc20Abi, parseUnits } from "viem";

    const crossmint = createCrossmint({
        apiKey: <YOUR_SERVER_API_KEY>,
    });
    const crossmintWallets = CrossmintWallets.from(crossmint);

    const wallet = await crossmintWallets.getWallet(
        "email:user@example.com:evm",
        { chain: "base", signer: { type: "email" } }
    );
    if(!wallet) throw new Error("Wallet not found");
    const evmWallet = EVMWallet.from(wallet);

    const LIFI_API = "https://li.quest/v1";
    const FROM_CHAIN = "8453"; // Base
    const TO_CHAIN = "137"; // Polygon
    const FROM_TOKEN = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"; // USDC on Base
    const TO_TOKEN = "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359"; // USDC on Polygon
    const USDC_DECIMALS = 6;
    const amount = "5";

    // 1. Get a bridge quote from the LI.FI API
    const quoteRes = await fetch(
        `${LIFI_API}/quote?` +
            new URLSearchParams({
                fromChain: FROM_CHAIN,
                toChain: TO_CHAIN,
                fromToken: FROM_TOKEN,
                toToken: TO_TOKEN,
                fromAmount: parseUnits(amount, USDC_DECIMALS).toString(),
                fromAddress: wallet.address,
                integrator: "crossmint",
            })
    );
    if (!quoteRes.ok) {
        throw new Error(`Quote request failed: ${quoteRes.status}`);
    }
    const quote = await quoteRes.json();

    // 2. Approve the LI.FI router to spend USDC
    if (quote.estimate.approvalAddress) {
        await evmWallet.sendTransaction({
            to: FROM_TOKEN,
            data: encodeFunctionData({
                abi: erc20Abi,
                functionName: "approve",
                args: [
                    quote.estimate.approvalAddress,
                    parseUnits(amount, USDC_DECIMALS),
                ],
            }),
        });
    }

    // 3. Execute the bridge transaction
    const tx = await evmWallet.sendTransaction({
        to: quote.transactionRequest.to,
        data: quote.transactionRequest.data,
        value: quote.transactionRequest.value
            ? BigInt(quote.transactionRequest.value)
            : 0n,
    });

    // 4. Poll the LI.FI status endpoint until completion
    let status = "PENDING";
    while (status === "PENDING" || status === "NOT_FOUND") {
        await new Promise((r) => setTimeout(r, 5000));
        const statusRes = await fetch(
            `${LIFI_API}/status?` +
                new URLSearchParams({
                    txHash: tx.hash,
                    fromChain: FROM_CHAIN,
                    toChain: TO_CHAIN,
                })
        );
        const s = await statusRes.json();
        status = s.status;
    }

    console.log("Bridge complete!");
    ```
  </Tab>

  <Tab title="React Native">
    ```typescript theme={null}
    import { useWallet, EVMWallet } from "@crossmint/client-sdk-react-native-ui";
    import { View, Button } from "react-native";
    import { encodeFunctionData, erc20Abi, parseUnits } from "viem";

    const LIFI_API = "https://li.quest/v1";
    const FROM_CHAIN = "8453"; // Base
    const TO_CHAIN = "137"; // Polygon
    const FROM_TOKEN = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"; // USDC on Base
    const TO_TOKEN = "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359"; // USDC on Polygon
    const USDC_DECIMALS = 6;

    export function BridgeComponent() {
        const { wallet } = useWallet();

        async function bridge(amount: string) {
            if(!wallet) return;
            const evmWallet = EVMWallet.from(wallet);

            // 1. Get a bridge quote from the LI.FI API
            const quoteRes = await fetch(
                `${LIFI_API}/quote?` +
                    new URLSearchParams({
                        fromChain: FROM_CHAIN,
                        toChain: TO_CHAIN,
                        fromToken: FROM_TOKEN,
                        toToken: TO_TOKEN,
                        fromAmount: parseUnits(amount, USDC_DECIMALS).toString(),
                        fromAddress: wallet.address,
                        integrator: "crossmint",
                    })
            );
            if (!quoteRes.ok) {
                throw new Error(`Quote request failed: ${quoteRes.status}`);
            }
            const quote = await quoteRes.json();

            // 2. Approve the LI.FI router to spend USDC
            if (quote.estimate.approvalAddress) {
                await evmWallet.sendTransaction({
                    to: FROM_TOKEN,
                    data: encodeFunctionData({
                        abi: erc20Abi,
                        functionName: "approve",
                        args: [
                            quote.estimate.approvalAddress,
                            parseUnits(amount, USDC_DECIMALS),
                        ],
                    }),
                });
            }

            // 3. Execute the bridge transaction
            const tx = await evmWallet.sendTransaction({
                to: quote.transactionRequest.to,
                data: quote.transactionRequest.data,
                value: quote.transactionRequest.value
                    ? BigInt(quote.transactionRequest.value)
                    : 0n,
            });

            // 4. Poll the LI.FI status endpoint until completion
            let status = "PENDING";
            while (status === "PENDING" || status === "NOT_FOUND") {
                await new Promise((r) => setTimeout(r, 5000));
                const statusRes = await fetch(
                    `${LIFI_API}/status?` +
                        new URLSearchParams({
                            txHash: tx.hash,
                            fromChain: FROM_CHAIN,
                            toChain: TO_CHAIN,
                        })
                );
                const s = await statusRes.json();
                status = s.status;
            }
        }

        return (
            <View>
                <Button title="Bridge Tokens" onPress={() => bridge("5")} />
            </View>
        );
    }
    ```

    See the [React Native SDK reference](/sdk-reference/wallets/react-native/hooks#wallet-methods) for more details.
  </Tab>

  <Tab title="Swift">
    ```swift theme={null}
    import CrossmintClient
    import Wallet
    import Foundation

    let sdk = CrossmintSDK.shared

    let wallet = try await sdk.crossmintWallets
        .getOrCreateWallet(
            chain: .base,
            signer: .email(email: "user@example.com")
        )

    let evmWallet = try EVMWallet.from(wallet: wallet)

    let fromChain = "8453"
    let toChain = "137"
    let fromToken = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
    let toToken = "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359"
    let amount = "5000000" // 5 USDC (6 decimals)

    // 1. Get a bridge quote from the LI.FI API
    var quoteURL = URLComponents(string: "https://li.quest/v1/quote")!
    quoteURL.queryItems = [
        URLQueryItem(name: "fromChain", value: fromChain),
        URLQueryItem(name: "toChain", value: toChain),
        URLQueryItem(name: "fromToken", value: fromToken),
        URLQueryItem(name: "toToken", value: toToken),
        URLQueryItem(name: "fromAmount", value: amount),
        URLQueryItem(name: "fromAddress", value: wallet.address),
        URLQueryItem(name: "integrator", value: "crossmint"),
    ]

    let (quoteData, quoteResponse) = try await URLSession.shared.data(from: quoteURL.url!)
    guard let httpResponse = quoteResponse as? HTTPURLResponse,
          httpResponse.statusCode == 200 else {
        throw URLError(.badServerResponse)
    }
    let quote = try JSONSerialization.jsonObject(with: quoteData) as! [String: Any]
    let estimate = quote["estimate"] as! [String: Any]
    let txRequest = quote["transactionRequest"] as! [String: Any]

    // 2. Approve the LI.FI router to spend USDC
    //    Encodes ERC-20 approve(address,uint256) — selector 0x095ea7b3
    //    Note: UInt64 supports up to ~18.4e18. For tokens with 18 decimals
    //    and large amounts, use a big-integer hex conversion instead.
    func leftPad(_ str: String, toLength len: Int) -> String {
        String(repeating: "0", count: max(0, len - str.count)) + str
    }

    if let approvalAddress = estimate["approvalAddress"] as? String {
        let addr = leftPad(String(approvalAddress.dropFirst(2)), toLength: 64)
        let amt = leftPad(String(UInt64(amount)!, radix: 16), toLength: 64)
        let approveData = "0x095ea7b3" + addr + amt
        let _ = try await evmWallet.sendTransaction(
            to: fromToken,
            value: "0",
            data: approveData
        )
    }

    // 3. Execute the bridge transaction
    let result = try await evmWallet.sendTransaction(
        to: txRequest["to"] as! String,
        value: (txRequest["value"] as? String) ?? "0",
        data: txRequest["data"] as! String
    )

    // 4. Poll the LI.FI status endpoint until completion
    var bridgeStatus = "PENDING"
    while bridgeStatus == "PENDING" || bridgeStatus == "NOT_FOUND" {
        try await Task.sleep(nanoseconds: 5_000_000_000)

        var statusURL = URLComponents(string: "https://li.quest/v1/status")!
        statusURL.queryItems = [
            URLQueryItem(name: "txHash", value: result.hash),
            URLQueryItem(name: "fromChain", value: fromChain),
            URLQueryItem(name: "toChain", value: toChain),
        ]
        let (statusData, _) = try await URLSession.shared.data(from: statusURL.url!)
        let statusJSON = try JSONSerialization.jsonObject(with: statusData) as! [String: Any]
        bridgeStatus = statusJSON["status"] as! String
    }
    ```

    See the [Swift SDK reference](/sdk-reference/wallets/swift/classes/evmwallet) for more details.
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
    import com.crossmint.kotlin.compose.LocalCrossmintSDK
    import com.crossmint.kotlin.types.EVMChain
    import com.crossmint.kotlin.types.SignerData
    import kotlinx.coroutines.Dispatchers
    import kotlinx.coroutines.delay
    import kotlinx.coroutines.withContext
    import kotlinx.serialization.json.Json
    import kotlinx.serialization.json.buildJsonObject
    import kotlinx.serialization.json.contentOrNull
    import kotlinx.serialization.json.jsonObject
    import kotlinx.serialization.json.jsonPrimitive
    import kotlinx.serialization.json.put
    import kotlinx.serialization.json.putJsonArray
    import kotlinx.serialization.json.putJsonObject
    import java.net.HttpURLConnection
    import java.net.URL

    val API_KEY = "<YOUR_API_KEY>"
    val SIGNER_EMAIL = "user@example.com"
    val LIFI_API = "https://li.quest/v1"
    val CROSSMINT_API = "https://www.crossmint.com/api/2025-06-09"
    val FROM_CHAIN = "8453"  // Base
    val TO_CHAIN = "137"     // Polygon
    val FROM_TOKEN = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"  // USDC on Base
    val TO_TOKEN = "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359"    // USDC on Polygon
    val AMOUNT = "5000000"   // 5 USDC (6 decimals)

    // Access the SDK — must be called inside a CrossmintSDKProvider composable
    val sdk = LocalCrossmintSDK.current
    val wallet = sdk.crossmintWallets
        .getOrCreateWallet(EVMChain.Base, SignerData.Email(SIGNER_EMAIL))
        .getOrThrow()

    val json = Json { ignoreUnknownKeys = true }

    // 1. Get a bridge quote from the LI.FI API
    val quoteText = withContext(Dispatchers.IO) {
        val conn = URL(
            "$LIFI_API/quote?fromChain=$FROM_CHAIN&toChain=$TO_CHAIN" +
                "&fromToken=$FROM_TOKEN&toToken=$TO_TOKEN" +
                "&fromAmount=$AMOUNT&fromAddress=${wallet.address}&integrator=crossmint"
        ).openConnection() as HttpURLConnection
        check(conn.responseCode == 200) { "Quote request failed: ${conn.responseCode}" }
        conn.inputStream.bufferedReader().readText()
    }
    val quote = json.parseToJsonElement(quoteText).jsonObject
    val estimate = quote["estimate"]!!.jsonObject
    val txRequest = quote["transactionRequest"]!!.jsonObject

    // The Kotlin SDK's send() only supports simple token transfers, not raw calldata.
    // The REST API is used here to create approval and bridge transactions directly.
    suspend fun sendEvmTransaction(to: String, data: String, value: String = "0"): String {
        val body = buildJsonObject {
            putJsonObject("params") {
                put("chain", "base")
                put("signer", "email:$SIGNER_EMAIL")
                putJsonArray("calls") {
                    add(buildJsonObject {
                        put("to", to)
                        put("value", value)
                        put("data", data)
                    })
                }
            }
        }.toString()
        val responseText = withContext(Dispatchers.IO) {
            val conn = URL("$CROSSMINT_API/wallets/${wallet.address}/transactions")
                .openConnection() as HttpURLConnection
            conn.requestMethod = "POST"
            conn.setRequestProperty("X-API-KEY", API_KEY)
            conn.setRequestProperty("Content-Type", "application/json")
            conn.doOutput = true
            conn.outputStream.write(body.toByteArray())
            val code = conn.responseCode
            if (code !in 200..299) {
                val err = conn.errorStream?.bufferedReader()?.readText()
                error("Transaction request failed ($code): $err")
            }
            conn.inputStream.bufferedReader().readText()
        }
        val transactionId = json.parseToJsonElement(responseText)
            .jsonObject["id"]!!.jsonPrimitive.content
        val tx = wallet.approve(transactionId).getOrThrow()
        return tx.onChain.txId ?: tx.onChain.userOperationHash
            ?: error("Transaction completed but no hash was returned")
    }

    // 2. Approve the LI.FI router to spend USDC
    //    Encodes ERC-20 approve(address,uint256) — selector 0x095ea7b3
    //    Note: Long supports up to ~9.2e18. For tokens with 18 decimals
    //    and large amounts, use a BigInteger hex conversion instead.
    val approvalAddress = estimate["approvalAddress"]?.jsonPrimitive?.contentOrNull
    if (approvalAddress != null) {
        val addr = approvalAddress.removePrefix("0x").padStart(64, '0')
        val amt = AMOUNT.toLong().toString(16).padStart(64, '0')
        sendEvmTransaction(to = FROM_TOKEN, data = "0x095ea7b3$addr$amt")
    }

    // 3. Execute the bridge transaction
    val txHash = sendEvmTransaction(
        to = txRequest["to"]!!.jsonPrimitive.content,
        data = txRequest["data"]!!.jsonPrimitive.content,
        value = txRequest["value"]?.jsonPrimitive?.contentOrNull ?: "0",
    )

    // 4. Poll the LI.FI status endpoint until completion
    var bridgeStatus = "PENDING"
    while (bridgeStatus == "PENDING" || bridgeStatus == "NOT_FOUND") {
        delay(5_000)
        val statusText = withContext(Dispatchers.IO) {
            val conn = URL("$LIFI_API/status?txHash=$txHash&fromChain=$FROM_CHAIN&toChain=$TO_CHAIN")
                .openConnection() as HttpURLConnection
            check(conn.responseCode == 200) { "Status request failed: ${conn.responseCode}" }
            conn.inputStream.bufferedReader().readText()
        }
        bridgeStatus = json.parseToJsonElement(statusText).jsonObject["status"]!!.jsonPrimitive.content
    }
    ```

    See the [Kotlin SDK reference](/sdk-reference/wallets/kotlin/classes/wallet) for more details.
  </Tab>

  <Tab title="REST">
    Transactions must be approved by one of the wallet's [signers](/wallets/concepts/wallet-signers).
    The SDK handles this automatically, but with the REST API you must [approve the transaction](/api-reference/wallets/approve-transaction) to complete it.

    <Steps>
      <Step title="Get a bridge quote from the LI.FI API">
        Call the <a href="https://docs.li.fi/li.fi-api/li.fi-api">LI.FI API</a> `/quote` endpoint with the source and destination chain, token addresses, and amount.

        <CodeGroup>
          ```bash cURL theme={null}
          curl --request GET \
              --url 'https://li.quest/v1/quote?fromChain=8453&toChain=137&fromToken=0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913&toToken=0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359&fromAmount=5000000&fromAddress=<wallet-address>&integrator=crossmint' \
              --header 'Content-Type: application/json'
          ```

          ```js Node.js theme={null}
          const params = new URLSearchParams({
              fromChain: "8453",
              toChain: "137",
              fromToken:
                  "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
              toToken:
                  "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
              fromAmount: "5000000",
              fromAddress: "<wallet-address>",
              integrator: "crossmint",
          });

          const response = await fetch(
              `https://li.quest/v1/quote?${params}`
          );
          const quote = await response.json();
          ```

          ```python Python theme={null}
          import requests

          response = requests.get(
              "https://li.quest/v1/quote",
              params={
                  "fromChain": "8453",
                  "toChain": "137",
                  "fromToken": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
                  "toToken": "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
                  "fromAmount": "5000000",
                  "fromAddress": "<wallet-address>",
                  "integrator": "crossmint",
              }
          )
          quote = response.json()
          ```
        </CodeGroup>

        The response includes `estimate.approvalAddress` and `transactionRequest` with the bridge calldata.
      </Step>

      <Step title="Send the approve and bridge transactions">
        Use the quote response to send two transactions via the Crossmint REST API:

        1. **Approve** — call the USDC contract with ERC-20 `approve` calldata targeting `estimate.approvalAddress`
        2. **Bridge** — send `transactionRequest.to`, `transactionRequest.data`, and `transactionRequest.value`

        Follow the steps in the [Send a transaction](/wallets/guides/send-transaction-evm#rest) guide to submit each transaction via the Crossmint REST API.
      </Step>

      <Step title="Poll for bridge status">
        Call the LI.FI `/status` endpoint every five seconds until the bridge completes.

        <CodeGroup>
          ```bash cURL theme={null}
          curl --request GET \
              --url 'https://li.quest/v1/status?txHash=<bridge-tx-hash>&fromChain=8453&toChain=137' \
              --header 'Content-Type: application/json'
          ```

          ```js Node.js theme={null}
          const statusParams = new URLSearchParams({
              txHash: "<bridge-tx-hash>",
              fromChain: "8453",
              toChain: "137",
          });

          const statusRes = await fetch(
              `https://li.quest/v1/status?${statusParams}`
          );
          const status = await statusRes.json();
          // status.status is "DONE", "FAILED",
          // "PENDING", or "NOT_FOUND"
          ```

          ```python Python theme={null}
          import requests

          response = requests.get(
              "https://li.quest/v1/status",
              params={
                  "txHash": "<bridge-tx-hash>",
                  "fromChain": "8453",
                  "toChain": "137",
              }
          )
          status = response.json()
          # status["status"] is "DONE", "FAILED",
          # "PENDING", or "NOT_FOUND"
          ```
        </CodeGroup>

        The bridge is complete when `status` is `DONE`. If `FAILED`, check the transaction on the block explorer for details.
      </Step>
    </Steps>
  </Tab>
</Tabs>

## Customizing the Bridge

You can bridge any token pair that LI.FI supports by changing the chain and token constants. You can also perform cross-chain swaps — changing both the asset and the chain in a single operation:

```typescript theme={null}
const FROM_CHAIN = "1"; // Ethereum
const TO_CHAIN = "42161"; // Arbitrum
const FROM_TOKEN =
    "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"; // USDC on Ethereum
const TO_TOKEN =
    "0xaf88d065e77c8cC2239327C5EDb3A432268e5831"; // USDC on Arbitrum
```

See the full list of supported chains and tokens in the <a href="https://docs.li.fi/introduction/chains#chain-overview">LI.FI Documentation</a>.

## Troubleshooting

<AccordionGroup>
  <Accordion title="Transaction fails with insufficient balance">
    Verify the wallet holds enough USDC on Base and ETH for gas fees.
    Use the [Check Balances](/wallets/guides/check-balances) guide to confirm token balances before bridging.
  </Accordion>

  <Accordion title="ERC-20 approval transaction is rejected">
    Ensure the approval amount is greater than or equal to the bridge amount.
    If a previous approval exists for a smaller amount, send a new approval transaction with the correct value.
    Verify the API key has the `wallets:transactions.create` scope.
  </Accordion>

  <Accordion title="Bridge status stays PENDING for a long time">
    Cross-chain bridges can take several minutes depending on the route and chain congestion.
    The LI.FI `/status` endpoint returns `PENDING` until both the source and destination chain transactions confirm.
    If the status does not change after 10 minutes, check the source transaction on a block explorer to verify it was included.
  </Accordion>
</AccordionGroup>

## Next Steps

<CardGroup>
  <Card title="Check Balances" icon="wallet" href="/wallets/guides/check-balances">
    Verify updated token balances after bridging on any chain
  </Card>

  <Card title="Send a Transaction" icon="arrow-right" href="/wallets/guides/transfer-tokens">
    Transfer tokens from any chain
  </Card>
</CardGroup>


# Credit Cards
Source: https://docs.crossmint.com/wallets/guides/wallet-extensions/credit-cards

Build a complete Visa credit card application for your users using Rain cards and Crossmint wallets.

<Note>
  This integration requires access to both Rain's card issuance API and
  Crossmint's wallet services.
</Note>

## Introduction

This guide shows you how to integrate Rain's card issuance platform with Crossmint wallets to build a complete crypto-to-credit card application. You'll learn how to create an app where users can sign up, issue a Visa card, and fund them directly from their wallets.

<Note>
  Check out our [live demo](https://rain-wallets-demo.vercel.app/) to see the
  integration in action before building your own.
</Note>

**What you'll build:**

* Virtual Visa card issuance
* Crypto-to-card funding with RUSD tokens
* Real-time balance and transaction monitoring

**Tech Stack:**

* Next.js >=15 (with App Router)
* React Server Actions for API integration
* [Crossmint React SDK](https://www.npmjs.com/package/@crossmint/client-sdk-react-ui) for wallet and authentication
* Rain API for card issuance ([contact the rain team for access](https://www.rain.xyz/contact-us))

## Prerequisites

<Steps>
  <Step icon="circle-dot" title="Rain API Key">
    [Get your Rain Staging API key](https://use-dev.raincards.xyz) with card
    issuance permissions
  </Step>

  <Step icon="circle-dot" title="Crossmint API Key">
    [Get your Crossmint Staging API
    key](https://docs.crossmint.com/introduction/platform/api-keys/client-side)
    with wallet and transaction scopes
  </Step>

  <Step icon="circle-dot" title="Next.js Project">
    Set up a Next.js project with App Router enabled for server actions: `npx
            create-next-app@latest my-rain-crossmint-app`
  </Step>

  <Step icon="circle-dot" title="Install Dependencies">
    ```bash theme={null}
    # Using npm
    npm install @crossmint/client-sdk-react-ui viem

    # Using pnpm
    pnpm add @crossmint/client-sdk-react-ui viem

    # Using yarn
    yarn add @crossmint/client-sdk-react-ui viem
    ```
  </Step>
</Steps>

## Integration Steps

<Steps>
  <Step title="Set up Crossmint Authentication and Wallet Providers">
    Set up the complete Crossmint provider stack with authentication and wallet functionality. This enables users to sign in and automatically creates wallets for them. This example uses [Crossmint Auth](/authentication/introduction) for simplicity, but for production you should [bring your own auth provider](/wallets/guides/bring-your-own-auth).

    ```tsx app/providers.tsx theme={null}
    "use client";

    import {
      CrossmintProvider,
      CrossmintAuthProvider,
      CrossmintWalletProvider,
    } from "@crossmint/client-sdk-react-ui";

    export function Providers({ children }: { children: React.ReactNode }) {
      return (
        <CrossmintProvider apiKey={process.env.NEXT_PUBLIC_CROSSMINT_API_KEY!}>
          <CrossmintAuthProvider>
            <CrossmintWalletProvider
              createOnLogin={{
                chain: "base-sepolia", // Using Base Sepolia for this demo
                signer: {
                  type: "email",
                },
              }}
            >
              {children}
            </CrossmintWalletProvider>
          </CrossmintAuthProvider>
        </CrossmintProvider>
      );
    }
    ```

    ```tsx app/layout.tsx theme={null}
    import { Providers } from "./providers";

    export default function RootLayout({ children }: { children: React.ReactNode }) {
      return (
        <html lang="en">
          <body>
            <Providers>{children}</Providers>
          </body>
        </html>
      );
    }
    ```
  </Step>

  <Step title="Add Environment Configuration">
    Set up your environment variables for both Rain and Crossmint APIs.

    ```bash .env theme={null}
    # Crossmint Configuration
    NEXT_PUBLIC_CROSSMINT_API_KEY=your_crossmint_api_key
    NEXT_PUBLIC_CHAIN=base-sepolia

    # Rain Configuration
    RAIN_API_KEY=your_rain_api_key
    ```
  </Step>

  <Step title="Build the Rain Integration Layer">
    Create Next.js server action functions to handle Rain API calls securely on the server side. This keeps your Rain API key secure and provides a clean interface for your React components.

    ```typescript actions/rain.ts theme={null}
    "use server";

    const RAIN_API_URL = "https://api-dev.raincards.xyz/v1";

    /**
    * Creates a new Rain user application with KYC data
    * This is the first step - submits user information to Rain for account creation
    * Using "approved" as lastName will skip KYC verification in sandbox mode
    */
    export async function createRainUserApplication(params: {
      firstName: string;
      lastName: string;
      email: string;
      walletAddress: string;
      // ... other required fields
    }) {
      const response = await fetch(`${RAIN_API_URL}/issuing/applications/user`, {
        method: "POST",
        headers: {
          "Api-Key": process.env.RAIN_API_KEY!, // This variable should be defined in your .env file
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          ...params,
          // Demo data for quick testing
          birthDate: "1990-01-01",
          nationalId: "123456789",
          countryOfIssue: "US",
          address: {
            line1: "123 Test Street",
            city: "San Francisco",
            region: "CA",
            postalCode: "94105",
            countryCode: "US",
          },
          ipAddress: "127.0.0.1",
          phoneCountryCode: "1",
          phoneNumber: "5551234567",
          annualSalary: "75000",
          accountPurpose: "personal",
          expectedMonthlyVolume: "2000",
          isTermsOfServiceAccepted: true,
        }),
      });

      if (!response.ok) {
        const error = await response.json();
        throw new Error(`Rain application failed: ${error.message}`);
      }

      const result = await response.json();
      return { userId: result.id, status: result.applicationStatus };
    }

    /**
    * Creates a smart contract for the approved Rain user
    * Rain manages the smart contract deployment and operations for collateral handling
    * This contract will hold the user's crypto collateral (RUSD tokens)
    */
    export async function createRainUserContract(userId: string, chainId: number) {
      await fetch(`${RAIN_API_URL}/issuing/users/${userId}/contracts`, {
        method: "POST",
        headers: {
          "Api-Key": process.env.RAIN_API_KEY!,
          "Content-Type": "application/json",
        },
        body: JSON.stringify({ chainId }),
      });
    }

    /**
    * Issues a virtual Visa credit card for the Rain user
    * The card will be linked to their smart contract for collateral-backed spending
    * Card starts active and ready to be funded with crypto collateral
    */
    export async function issueRainCard(userId: string, displayName: string) {
      const response = await fetch(
        `${RAIN_API_URL}/issuing/users/${userId}/cards`,
        {
          method: "POST",
          headers: {
            "Api-Key": process.env.RAIN_API_KEY!,
            "Content-Type": "application/json",
          },
          body: JSON.stringify({
            type: "virtual",
            limit: { frequency: "allTime", amount: 1000 },
            displayName,
            status: "active",
          }),
        }
      );

      return await response.json();
    }

    /**
    * Gets user's existing Rain cards
    * Returns array of cards with basic info like status and last four digits
    */
    export async function getRainUserCards(userId: string) {
      const response = await fetch(
        `${RAIN_API_URL}/issuing/cards?userId=${userId}&limit=20`,
        {
          headers: { "Api-Key": process.env.RAIN_API_KEY! },
        }
      );
      return await response.json();
    }

    /**
    * Gets Rain user smart contracts with retry logic
    * Returns Base Sepolia contract with RUSD token info
    */
    export async function getRainUserContracts(userId: string) {
      const BASE_SEPOLIA_CHAIN_ID = 84532;
      const RUSD_CONTRACT_BASE_SEPOLIA =
        "0x10b5Be494C2962A7B318aFB63f0Ee30b959D000b";

      // Simple retry logic - try up to 3 times
      for (let attempt = 0; attempt < 3; attempt++) {
        try {
          const response = await fetch(
            `${RAIN_API_URL}/issuing/users/${userId}/contracts`,
            {
              headers: { "Api-Key": process.env.RAIN_API_KEY! },
            }
          );

          const contracts = await response.json();
          const baseContract = contracts.find(
            (c: { chainId: number }) => c.chainId === BASE_SEPOLIA_CHAIN_ID
          );

          if (baseContract) {
            const rusdToken = baseContract.tokens.find(
              (t: { address: string }) => t.address === RUSD_CONTRACT_BASE_SEPOLIA
            );
            return {
              contractId: baseContract.id,
              depositAddress: baseContract.depositAddress,
              tokens: baseContract.tokens,
              rusdBalance: rusdToken?.balance || "0.0",
            };
          }

          // Wait 2 seconds before retry if no contract found
          if (attempt < 2)
            await new Promise((resolve) => setTimeout(resolve, 2000));
        } catch (error) {
          if (attempt === 2) throw error;
          await new Promise((resolve) => setTimeout(resolve, 2000));
        }
      }
      throw new Error("No Base Sepolia contract found after retries");
    }

    /**
    * Gets user's credit balances and spending power
    * Returns simplified balance info in dollars (converted from cents)
    */
    export async function getRainUserCreditBalances(userId: string) {
      const response = await fetch(
        `${RAIN_API_URL}/issuing/users/${userId}/balances`,
        {
          headers: { "Api-Key": process.env.RAIN_API_KEY! },
        }
      );

      const data = await response.json();
      return {
        creditLimit: data.creditLimit / 100,
        spendingPower: data.spendingPower / 100,
        balanceDue: data.balanceDue / 100,
      };
    }

    /**
    * Gets Rain user status by checking application status
    * Returns basic user info and approval status
    */
    export async function getRainUserStatus(userId: string) {
      const response = await fetch(
        `${RAIN_API_URL}/issuing/applications/user/${userId}`,
        {
          headers: { "Api-Key": process.env.RAIN_API_KEY! },
        }
      );

      const result = await response.json();
      return {
        userId: result.id,
        applicationStatus: result.applicationStatus,
        email: result.email,
        isActive: result.isActive,
      };
    }

    /**
    * Finds Rain user by wallet address
    * Returns array of users (should be 0 or 1 for unique wallets)
    */
    export async function getRainUserByWalletAddress(walletAddress: string) {
      const response = await fetch(`${RAIN_API_URL}/issuing/users?limit=100`, {
        headers: { "Api-Key": process.env.RAIN_API_KEY! },
      });

      const users = await response.json();
      return users.filter(
        (user: { walletAddress: string }) => user.walletAddress === walletAddress
      );
    }
    ```
  </Step>

  <Step title="Create the Main Integration Component">
    Build a React component that handles both authentication and the Rain integration flow in one place.

    ```tsx components/rain-integration.tsx theme={null}
    "use client";

    import { useState, useEffect } from "react";
    import { useAuth, useWallet, EVMWallet } from "@crossmint/client-sdk-react-ui";
    import { encodeFunctionData } from "viem";
    import {
      createRainUserApplication,
      createRainUserContract,
      issueRainCard,
      getRainUserByWalletAddress,
      getRainUserContracts,
      getRainUserCards,
      getRainUserCreditBalances,
      getRainUserStatus,
    } from "../actions/rain";

    const RUSD_CONTRACT_BASE_SEPOLIA = "0x10b5Be494C2962A7B318aFB63f0Ee30b959D000b";

    export function RainIntegration() {
      const { wallet } = useWallet();
      const { user, login, logout } = useAuth();
      const [step, setStep] = useState<"signup" | "contract" | "card" | "funded">(
        "signup"
      );
      const [rainUserId, setRainUserId] = useState("");
      const [contractAddress, setContractAddress] = useState("");
      const [contractData, setContractData] = useState<{
        contractId: string;
        depositAddress: string;
        tokens: Array<{ address: string; balance: string }>;
        rusdBalance: string;
      } | null>(null);
      const [cardData, setCardData] = useState<{
        id: string;
        type: string;
        status: string;
        last4: string;
        expirationMonth: string;
        expirationYear: string;
        limit: {
          amount: number;
          frequency: string;
        };
      } | null>(null);
      const [loading, setLoading] = useState(false);
      const [initialLoading, setInitialLoading] = useState(true);
      const [creditBalances, setCreditBalances] = useState<{
        creditLimit: number;
        spendingPower: number;
        balanceDue: number;
      } | null>(null);
      const [isRefreshingBalances, setIsRefreshingBalances] = useState(false);

      // Comprehensive state determination on wallet connection
      useEffect(() => {
        const determineCurrentState = async () => {
          if (!wallet?.address || !user?.email) {
            setInitialLoading(false);
            return;
          }
          setInitialLoading(true);
          try {
            // Step 1: Check if user exists
            const existingUsers = await getRainUserByWalletAddress(wallet.address);
            if (existingUsers.length === 0) {
              // No user exists - start from signup
              setStep("signup");
              return;
            }
            // User exists - get their details
            const rainUser = existingUsers[0];
            setRainUserId(rainUser.id);
            // Step 2: Check user status
            const userStatus = await getRainUserStatus(rainUser.id);
            if (userStatus.applicationStatus !== "approved") {
              setStep("signup");
              return;
            }
            // Step 3: Check for contracts
            try {
              const contractInfo = await getRainUserContracts(rainUser.id);
              setContractAddress(contractInfo.depositAddress);
              setContractData(contractInfo);

              // Step 4: Check for cards
              try {
                const cards = await getRainUserCards(rainUser.id);
                if (cards.length > 0) {
                  // User has cards - check if funded
                  const card = cards[0];
                  setCardData({
                    id: card.id,
                    type: card.type,
                    status: card.status,
                    last4: card.last4,
                    expirationMonth: card.expirationMonth,
                    expirationYear: card.expirationYear,
                    limit: card.limit,
                  });
                  // Get credit balances to determine if funded
                  const balances = await getRainUserCreditBalances(rainUser.id);
                  setCreditBalances(balances);
                  // If there's spending power, consider it funded
                  if (balances.spendingPower > 0) {
                    setStep("funded");
                  } else {
                    setStep("card");
                  }
                } else {
                  // Contract exists but no card
                  setStep("contract");
                }
              } catch {
                // Error getting cards - assume no cards exist
                setStep("contract");
              }
            } catch {
              // No contract exists - need to create one
              setStep("contract");
            }
          } catch (error) {
            console.error("Error determining state:", error);
            setStep("signup"); // Default to signup on error
          } finally {
            setInitialLoading(false);
          }
        };
        determineCurrentState();
      }, [wallet?.address, user?.email]);

      const handleSignup = async () => {
        if (!wallet || !user?.email) return;
        setLoading(true);
        try {
          const result = await createRainUserApplication({
            firstName: user.email,
            lastName: "approved", // Skip KYC for demo
            email: user.email,
            walletAddress: wallet.address,
          });
          setRainUserId(result.userId);
          // Move to contract step - don't auto-create contract here
          // Let the user manually trigger contract creation
          setStep("contract");
        } catch (error) {
          console.error("Signup failed:", error);
          alert("Signup failed: " + error);
        } finally {
          setLoading(false);
        }
      };

      const handleCreateContract = async () => {
        if (!rainUserId) return;
        setLoading(true);
        try {
          // Create the contract
          await createRainUserContract(rainUserId, 84532);
          // Wait a bit for contract to be created
          await new Promise((resolve) => setTimeout(resolve, 3000));
          // Try to get contract info with retry logic
          let contractInfo;
          let attempts = 0;
          const maxAttempts = 5;
          while (attempts < maxAttempts) {
            try {
              contractInfo = await getRainUserContracts(rainUserId);
              if (contractInfo?.depositAddress) {
                break;
              }
            } catch {
              console.log(`Attempt ${attempts + 1} failed, retrying...`);
            }
            attempts++;
            if (attempts < maxAttempts) {
              await new Promise((resolve) => setTimeout(resolve, 2000));
            }
          }
          if (contractInfo?.depositAddress) {
            setContractAddress(contractInfo.depositAddress);
            setContractData(contractInfo);
            alert("✅ Smart contract created successfully!");
          } else {
            throw new Error(
              "Contract was created but details are not yet available. Please refresh the page."
            );
          }
        } catch (error) {
          console.error("Contract creation failed:", error);
          alert(
            "Contract creation may have succeeded but details are not yet available. Please refresh the page to check."
          );
        } finally {
          setLoading(false);
        }
      };

      const handleIssueCard = async () => {
        if (!rainUserId) return;

        setLoading(true);
        try {
          const card = await issueRainCard(rainUserId, user?.email || "Demo User");
          setCardData({
            id: card.id,
            type: card.type,
            status: card.status,
            last4: card.last4,
            expirationMonth: card.expirationMonth,
            expirationYear: card.expirationYear,
            limit: card.limit,
          });
          // Fetch initial credit balances after card issuance
          await handleRefreshCreditBalances();
          setStep("card");
        } catch (error) {
          console.error("Card issuance failed:", error);
          alert("Card issuance failed: " + error);
        } finally {
          setLoading(false);
        }
      };

      const handleRefreshCreditBalances = async () => {
        if (!rainUserId) return;
        setIsRefreshingBalances(true);
        try {
          const balances = await getRainUserCreditBalances(rainUserId);
          setCreditBalances(balances);
        } catch (error) {
          console.error("Failed to refresh credit balances:", error);
        } finally {
          setIsRefreshingBalances(false);
        }
      };

      const handleFundCard = async () => {
        if (!wallet || !contractAddress) return;
        setLoading(true);
        try {
          const evmWallet = EVMWallet.from(wallet);
          // Mint RUSD tokens
          const mintData = encodeFunctionData({
            abi: [
              {
                name: "mint",
                type: "function",
                inputs: [{ name: "_amountDollars_Max100", type: "uint256" }],
                outputs: [],
              },
            ],
            functionName: "mint",
            args: [BigInt(10)], // Mint $10 RUSD
          });
          await evmWallet.sendTransaction({
            to: RUSD_CONTRACT_BASE_SEPOLIA,
            data: mintData,
            value: BigInt(0),
            chain: "base-sepolia", // Using Base Sepolia - see Rain docs for other supported chains
          });
          // Send RUSD to contract
          await wallet.send(contractAddress, RUSD_CONTRACT_BASE_SEPOLIA, "10");
          // Refresh credit balances after funding
          await handleRefreshCreditBalances();
          setStep("funded");
        } catch (error) {
          console.error("Funding failed:", error);
        } finally {
          setLoading(false);
        }
      };

      // Show login screen if user is not authenticated
      if (!user) {
        return (
          <div className="max-w-md mx-auto p-6 bg-white rounded-lg shadow text-center">
            <h2 className="text-2xl font-bold mb-4">Rain Card Demo</h2>
            <p className="text-gray-600 mb-6">
              Sign in to create your account and get started with crypto-backed
              credit cards
            </p>
            <button
              onClick={login}
              className="bg-blue-600 text-white py-2 px-6 rounded-lg hover:bg-blue-700 transition-colors"
            >
              Login to Get Started
            </button>
          </div>
        );
      }

      // Show loading screen while determining current state
      if (initialLoading) {
        return (
          <div className="max-w-md mx-auto p-6 bg-white rounded-lg shadow text-center">
            <h2 className="text-2xl font-bold mb-4">Rain Card Demo</h2>
            <div className="flex items-center justify-center py-8">
              <div className="w-8 h-8 border-4 border-blue-600 border-t-transparent rounded-full animate-spin" />
              <p className="text-gray-600 ml-3">
                Checking your Rain account status...
              </p>
            </div>
          </div>
        );
      }

      return (
        <div className="max-w-md mx-auto p-6 bg-white rounded-lg shadow">
          {/* Header with user info and logout */}
          <div className="flex justify-between items-center mb-6">
            <h2 className="text-xl font-bold">Rain Card Demo</h2>
            <div className="flex items-center gap-3">
              {wallet && (
                <span className="text-xs text-gray-500">
                  {wallet.address.slice(0, 6)}...{wallet.address.slice(-4)}
                </span>
              )}
              <button
                onClick={logout}
                className="text-sm text-gray-600 hover:text-gray-800 transition-colors"
              >
                Logout
              </button>
            </div>
          </div>
          {/* Card Data Display - Show whenever card data exists */}
          {cardData?.last4 && (
            <div className="mb-6">
              {/* Credit Card Visual */}
              <div className="relative w-full max-w-sm mx-auto aspect-[1.586/1] bg-gray-900 rounded-lg shadow-2xl overflow-hidden">
                {/* Card Background Pattern */}
                <div className="absolute inset-0 opacity-10">
                  <div className="absolute top-4 right-4 w-12 h-12 border-2 border-white rounded-full"></div>
                  <div className="absolute top-4 right-20 w-8 h-8 border-2 border-white rounded-full"></div>
                </div>
                {/* Card Content */}
                <div className="relative h-full p-6 flex flex-col justify-between text-white">
                  {/* Top Section */}
                  <div className="flex justify-between items-start">
                    <div>
                      <div className="text-xs opacity-70 mb-1">VIRTUAL CARD</div>
                      <div className="text-sm font-semibold">Rain Card</div>
                    </div>
                    <div
                      className={`px-2 py-1 rounded text-xs font-medium ${
                        cardData.status === "active"
                          ? "bg-green-500 text-white"
                          : "bg-yellow-500 text-black"
                      }`}
                    >
                      {cardData.status.toUpperCase()}
                    </div>
                  </div>
                  {/* Card Number */}
                  <div className="my-4">
                    <div className="font-mono text-lg tracking-wider">
                      •••• •••• •••• {cardData.last4}
                    </div>
                  </div>
                  {/* Bottom Section */}
                  <div className="flex justify-between items-end">
                    <div>
                      {cardData.expirationMonth && cardData.expirationYear && (
                        <div>
                          <div className="text-xs opacity-70">VALID THRU</div>
                          <div className="font-mono text-sm">
                            {cardData.expirationMonth}/
                            {cardData.expirationYear.slice(-2)}
                          </div>
                        </div>
                      )}
                    </div>
                    <div className="text-right">
                      <div className="text-xs opacity-70">SPENDING POWER</div>
                      <div className="text-sm font-semibold">
                        ${creditBalances?.spendingPower?.toFixed(0) || "0"}
                      </div>
                    </div>
                  </div>
                </div>
              </div>
              {/* Credit Balance Refresh - Only show when card exists */}
              {creditBalances && (
                <div className="text-center mt-2">
                  <button
                    onClick={handleRefreshCreditBalances}
                    disabled={isRefreshingBalances}
                    className="text-xs px-3 py-1 bg-gray-100 text-gray-700 rounded hover:bg-gray-200 disabled:opacity-50"
                  >
                    {isRefreshingBalances ? "Refreshing..." : "Refresh Balance"}
                  </button>
                </div>
              )}
            </div>
          )}
          {step === "signup" && (
            <div>
              <p className="mb-4">
                Create your Rain account and get approved instantly
              </p>
              <button
                onClick={handleSignup}
                disabled={loading || !wallet}
                className="w-full bg-blue-600 text-white py-2 px-4 rounded disabled:opacity-50"
              >
                {loading ? "Creating Account..." : "Sign Up for Rain Card"}
              </button>
            </div>
          )}
          {step === "contract" && (
            <div>
              {!contractData ? (
                <div>
                  <p className="mb-4">
                    ✅ Account approved! Ready to create your smart contract.
                  </p>
                  <button
                    onClick={handleCreateContract}
                    disabled={loading}
                    className="w-full bg-blue-600 text-white py-2 px-4 rounded disabled:opacity-50 mb-4"
                  >
                    {loading
                      ? "Creating Smart Contract..."
                      : "Create Smart Contract"}
                  </button>
                </div>
              ) : (
                <div>
                  <p className="mb-4">
                    🏗️ Smart contract created! Ready to issue your card.
                  </p>
                  <button
                    onClick={handleIssueCard}
                    disabled={loading}
                    className="w-full bg-green-600 text-white py-2 px-4 rounded disabled:opacity-50"
                  >
                    {loading ? "Issuing Card..." : "Issue Virtual Card"}
                  </button>
                </div>
              )}
            </div>
          )}
          {step === "card" && (
            <div>
              <p className="mb-4">🎉 Card issued! Fund it to start spending.</p>

              <button
                onClick={handleFundCard}
                disabled={loading}
                className="w-full bg-purple-600 text-white py-2 px-4 rounded disabled:opacity-50"
              >
                {loading ? "Funding..." : "Fund Card ($10 RUSD)"}
              </button>
            </div>
          )}
          {step === "funded" && (
            <div className="text-center">
              <p className="text-green-600 font-bold mb-2">🎉 Card Ready!</p>
              <p className="text-sm text-gray-600">
                Your card is funded and ready to use for purchases. Balance may take
                a moment to update.
              </p>
            </div>
          )}
        </div>
      );
    }
    ```
  </Step>

  <Step title="Wire Everything Together">
    Update your main page component to use the `RainIntegration` component directly.

    ```tsx app/page.tsx theme={null}
    import { RainIntegration } from "./components/rain-integration";

    export default function HomePage() {
      return (
        <div className="min-h-screen bg-gray-50 py-8">
          <RainIntegration />
        </div>
      );
    }
    ```
  </Step>
</Steps>

## Next Steps

<CardGroup>
  <Card title="Learn Token Transfers" icon="credit-card" href="https://docs.crossmint.com/wallets/guides/transfer-tokens">
    Send tokens between wallets and external addresses
  </Card>

  <Card title="Bring Your Own Auth" icon="key" href="https://docs.crossmint.com/wallets/guides/bring-your-own-auth#bring-your-own-auth">
    Use your own authentication system with Crossmint
  </Card>

  <Card title="Staging vs Production" icon="shield-check" href="https://docs.crossmint.com/introduction/platform/staging-vs-production">
    Learn about staging and production environments
  </Card>
</CardGroup>

## Need Help?

<Card title="Contact Sales" icon="comment" href="https://www.crossmint.com/contact/sales">
  Contact our team if you're interested in planning your integration.
</Card>

## Resources

* [Rain API Documentation](https://api-dev.raincards.xyz/v1)
* [Crossmint Wallet SDK](https://docs.crossmint.com/wallets)
* [Demo Repository](https://github.com/Crossmint/rain-wallets-demo)
* [Base Sepolia Explorer](https://sepolia.basescan.org/)


# Yield Generation
Source: https://docs.crossmint.com/wallets/guides/wallet-extensions/generate-yield

Generate yield from your wallet's tokens using Crossmint and Yield.xyz

<Frame type="simple">
  <img alt="Generate Yield" />
</Frame>

<Info>
  New to yield? Learn about [yield strategies and mechanisms](/wallets/concepts/wallet-extensions/yield-introduction) before diving into this implementation guide.
</Info>

<Card title="Live Demo" icon="play" href="https://fintech-starter-app.demos-crossmint.com/">
  Explore a working fintech app where users deposit USDC and earn yield
</Card>

## Supported Networks

Yield.xyz supports Ethereum, Base, Solana, and 50+ other chains across EVM and non-EVM networks. Testnet support includes Stellar-Testnet, Base-Sepolia, Ethereum-Sepolia, and Solana Devnet. For the complete and up-to-date list, see the [Yield.xyz Supported Networks documentation](https://docs.yield.xyz/docs/supported-networks).

<Info>
  This guide uses **Base** network with testnet wallets connected to mainnet
  yield opportunities, giving you a realistic experience without using real funds.
</Info>

## Prerequisites

Before you start, make sure you have:

* Completed the [React Quickstart](/wallets/quickstarts/react) to set up Crossmint providers and wallet creation
* A wallet funded with USDC testnet tokens (get test USDC from [Circle's Faucet](https://faucet.circle.com/))

<Warning>
  Since this guide uses testnet tokens, deposits will not actually earn yield. For production, use mainnet USDC and ensure your Crossmint wallet is configured for mainnet.

  Need help launching in production or getting access to Yield.xyz? [Contact sales](https://www.crossmint.com/contact/sales).
</Warning>

<Steps>
  <Step title="Get a Yield.xyz API Key">
    Request an API key from [Yield.xyz](https://yield.xyz) and add it to your environment:

    ```bash .env.local theme={null}
    NEXT_PUBLIC_YIELD_API_KEY=YOUR_YIELD_XYZ_API_KEY
    ```
  </Step>

  <Step title="Create the Yield API utilities">
    Create a file with all the Yield.xyz API functions and types:

    * **Fetch Yields**: Retrieve available USDC yield opportunities on Base
    * **Enter Yield**: Deposit USDC into a yield-generating position
    * **Exit Yield**: Withdraw USDC from an active yield position
    * **Get Yield Balance**: Check the current balance in a yield position
    * **Get Active Positions**: Retrieve all active yield positions for a wallet

    ```typescript yield-api.ts theme={null}
    const YIELD_API_URL = "https://api.yield.xyz";
    const YIELD_NETWORK = "base"; // Hardcoded to Base network

    // Types
    export interface YieldOpportunity {
      id: string;
      network: string;
      providerId: string;
      metadata: { name: string; description?: string };
      rewardRate: { total: number; rateType: "APY" | "APR" };
      status: { enter: boolean; exit: boolean };
    }

    export interface YieldAction {
      id: string;
      intent: "enter" | "exit";
      yieldId: string;
      amount: string;
      amountUsd: string;
      status: "CREATED" | "PROCESSING" | "SUCCESS" | "FAILED";
      createdAt: string;
    }

    // Fetch available yield opportunities
    export async function fetchYields(): Promise<YieldOpportunity[]> {
      const response = await fetch(
        `${YIELD_API_URL}/v1/yields?network=${YIELD_NETWORK}&token=USDC&limit=10`,
        {
          headers: {
            "Content-Type": "application/json",
            "X-API-KEY": process.env.NEXT_PUBLIC_YIELD_API_KEY!,
          },
        }
      );
      if (!response.ok) {
        throw new Error("Failed to fetch yields");
      }

      const data = await response.json();
      return data.data || data.items || [];
    }

    // Enter a yield position (deposit)
    export async function enterYield(yieldId: string, address: string, amount: string) {
      const response = await fetch(`${YIELD_API_URL}/v1/actions/enter`, {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          "X-API-KEY": process.env.NEXT_PUBLIC_YIELD_API_KEY!,
        },
        body: JSON.stringify({
          yieldId,
          address,
          arguments: { amount }, // Human-readable (e.g., "100" for 100 USDC)
        }),
      });

      if (!response.ok) {
        throw new Error("Failed to create deposit");
      }

      return response.json();
    }

    // Exit a yield position (withdraw)
    export async function exitYield(yieldId: string, address: string, amount?: string) {
      const response = await fetch(`${YIELD_API_URL}/v1/actions/exit`, {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          "X-API-KEY": process.env.NEXT_PUBLIC_YIELD_API_KEY!,
        },
        body: JSON.stringify({
          yieldId,
          address,
          arguments: amount ? { amount } : { useMaxAmount: true },
        }),
      });

      if (!response.ok) {
        throw new Error("Failed to create withdrawal");
      }

      return response.json();
    }

    // Get balance for a yield position
    export async function getYieldBalance(yieldId: string, address: string): Promise<string> {
      const response = await fetch(
        `${YIELD_API_URL}/v1/yields/${yieldId}/balances?address=${address}`,
        {
          headers: {
            "Content-Type": "application/json",
            "X-API-KEY": process.env.NEXT_PUBLIC_YIELD_API_KEY!,
          },
        }
      );

      if (!response.ok) {
        return "0";
      }

      const data = await response.json();
      const activeBalance = data.balances?.find((b: any) => b.type === "active");
      return activeBalance?.amount || "0";
    }

    // Get user's active positions
    export async function getActivePositions(address: string): Promise<YieldAction[]> {
      const response = await fetch(`${YIELD_API_URL}/v1/actions?address=${address}&limit=20`, {
        headers: {
          "Content-Type": "application/json",
          "X-API-KEY": process.env.NEXT_PUBLIC_YIELD_API_KEY!,
        },
      });

      if (!response.ok) {
        return [];
      }

      const { items = [] } = await response.json();

      // Group by yieldId and filter to active positions (no exit after enter)
      const byYield = new Map<string, YieldAction[]>();
      for (const action of items) {
        const list = byYield.get(action.yieldId) || [];
        list.push(action);
        byYield.set(action.yieldId, list);
      }

      const active: YieldAction[] = [];
      for (const [, actions] of byYield) {
        const sorted = actions.sort(
          (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
        );
        const lastEnter = sorted.find((a) => a.intent === "enter");
        const hasExit = sorted.some(
          (a) =>
            a.intent === "exit" && lastEnter && new Date(a.createdAt) > new Date(lastEnter.createdAt)
        );
        if (lastEnter && !hasExit) active.push(lastEnter);
      }
      return active;
    }
    ```
  </Step>

  <Step title="Build a yield component with deposit and withdraw">
    Create a component that displays yields, handles deposits, and shows active positions:

    ```tsx yield-app.tsx theme={null}
    import { useState, useEffect } from "react";
    import { useWallet, EVMWallet } from "@crossmint/client-sdk-react-ui";
    import {
      fetchYields,
      enterYield,
      exitYield,
      getActivePositions,
      getYieldBalance,
      YieldOpportunity,
      YieldAction,
    } from "./yield-api";

    export function YieldApp() {
      const { wallet } = useWallet();
      const [yields, setYields] = useState<YieldOpportunity[]>([]);
      const [positions, setPositions] = useState<YieldAction[]>([]);
      const [selectedYield, setSelectedYield] = useState<string | null>(null);
      const [amount, setAmount] = useState("");
      const [loading, setLoading] = useState(false);

      // Load yields
      useEffect(() => {
        fetchYields().then(setYields);
      }, []);

      useEffect(() => {
        if (wallet?.address) {
          getActivePositions(wallet.address).then(setPositions);
        }
      }, [wallet?.address]);

      // Execute transactions through Crossmint wallet
      const executeTransactions = async (transactions: any[]) => {
        const evmWallet = EVMWallet.from(wallet!);
        const sorted = transactions.sort((a, b) => a.stepIndex - b.stepIndex);

        for (const tx of sorted) {
          const unsigned = JSON.parse(tx.unsignedTransaction);
          await evmWallet.sendTransaction({
            to: unsigned.to,
            data: unsigned.data,
            value: unsigned.value || "0x0",
          });
        }
      };

      const handleDeposit = async (yieldId: string) => {
        if (!wallet?.address || !amount) {
          return;
        }

        setLoading(true);
        try {
          const { transactions } = await enterYield(yieldId, wallet.address, amount);
          await executeTransactions(transactions);
          setPositions(await getActivePositions(wallet.address));
          setAmount("");
          setSelectedYield(null);
        } catch (err) {
          console.error("Deposit failed:", err);
        }
        setLoading(false);
      };

      const handleWithdraw = async (yieldId: string) => {
        if (!wallet?.address) {
          return;
        }

        setLoading(true);
        try {
          // Fetch current balance to pass to exit
          const balance = await getYieldBalance(yieldId, wallet.address);
          const { transactions } = await exitYield(yieldId, wallet.address, balance);
          await executeTransactions(transactions);
          setPositions(await getActivePositions(wallet.address));
        } catch (err) {
          console.error("Withdraw failed:", err);
        }
        setLoading(false);
      };

      if (!wallet) {
        return <p>Connect your wallet to view yield opportunities.</p>;
      }

      return (
        <div className="space-y-6 p-4">
          <h2 className="text-xl font-bold">💰 Earn Yield on USDC</h2>

          {/* Yield Opportunities */}
          <div className="space-y-3">
            <h3 className="font-semibold">Available Yields</h3>
            {yields.map((y) => (
              <div
                key={y.id}
                onClick={() => setSelectedYield(selectedYield === y.id ? null : y.id)}
                className={`cursor-pointer rounded-xl border p-4 ${
                  selectedYield === y.id ? "border-blue-500" : ""
                }`}
              >
                <div className="flex justify-between">
                  <span className="font-semibold">{y.metadata.name}</span>
                  <span className="text-green-600">{(y.rewardRate.total * 100).toFixed(2)}% APY</span>
                </div>
                <p className="text-sm text-gray-500">{y.providerId}</p>

                {selectedYield === y.id && (
                  <div className="mt-3 flex gap-2" onClick={(e) => e.stopPropagation()}>
                    <input
                      type="number"
                      placeholder="Amount (USDC)"
                      value={amount}
                      onChange={(e) => setAmount(e.target.value)}
                      className="flex-1 rounded border px-3 py-2"
                    />
                    <button
                      onClick={() => handleDeposit(y.id)}
                      disabled={loading || !amount}
                      className="rounded bg-blue-600 px-4 py-2 text-white hover:bg-blue-700 disabled:opacity-50"
                    >
                      {loading ? "..." : "Deposit"}
                    </button>
                  </div>
                )}
              </div>
            ))}
          </div>

          {/* Active Positions */}
          {positions.length > 0 && (
            <div className="space-y-3">
              <h3 className="font-semibold">Your Positions</h3>
              {positions.map((p) => (
                <div key={p.id} className="flex items-center justify-between rounded-xl border p-4">
                  <div>
                    <span className="font-semibold">{p.yieldId.split("-")[2]}</span>
                    <p className="text-sm text-gray-500">${p.amountUsd} USDC</p>
                  </div>
                  <button
                    onClick={() => handleWithdraw(p.yieldId)}
                    disabled={loading}
                    className="rounded border border-red-200 bg-red-50 px-4 py-2 text-red-600 hover:bg-red-100"
                  >
                    {loading ? "..." : "Withdraw"}
                  </button>
                </div>
              ))}
            </div>
          )}
        </div>
      );
    }
    ```
  </Step>

  <Step title="Render the yield app">
    Add the yield component to your application (inside your Crossmint providers):

    ```tsx page.tsx theme={null}
    "use client";

    import { Providers } from "./providers";
    import { YieldApp } from "./yield-app";

    export default function Home() {
      return (
        <Providers>
          <YieldApp />
        </Providers>
      );
    }
    ```
  </Step>
</Steps>

## Next Steps

<CardGroup>
  <Card title="Yield.xyz API Docs" icon="book" href="https://docs.yield.xyz">
    Full API reference for yields, actions, and balances
  </Card>

  <Card title="Credit Cards" icon="credit-card" href="/wallets/guides/wallet-extensions/credit-cards">
    Let users spend their wallet balance with virtual credit cards
  </Card>
</CardGroup>


# Jupiter
Source: https://docs.crossmint.com/wallets/guides/wallet-extensions/swap-jupiter

Swap tokens using Jupiter in Solana

## Prerequisites

* Ensure you have a wallet created.
* **API Key**: Ensure you have an API key with the scopes: `wallets:transactions.create`.

## Swap Tokens

This guide explains how to swap tokens in Solana using the Jupiter advanced routing engine, which requires special configuration to work with smart wallets.
If you're using EVM chains, you can use [0x](https://0x.org/docs/api) or [1inch](https://1inch.io/page-api/) directly.

To perform a swap with the Jupiter Swap API and Crossmint wallets, follow these steps:

1. [Request a quote from the Jupiter API](https://dev.jup.ag/docs/api/swap-api/quote).
2. [Build the swap transaction for that quote using the Jupiter API](https://dev.jup.ag/docs/api/swap-api/swap).
3. Send the transaction using the Crossmint wallet.

<Note>
  For tokens with lower liquidity, the number of hops required to reach the destination token may be higher. This can
  make the transaction size larger and increase the risk of failure. To minimize this risk, always set maxAccounts=33
  when building the swap transaction. This ensures that even multi-hop swaps fit within Solana's transaction account
  limits and execute reliably.
</Note>

<Tabs>
  <Tab title="React">
    ```typescript theme={null}
    import { useWallet, SolanaWallet } from '@crossmint/client-sdk-react-ui';
    import { VersionedTransaction } from '@solana/web3.js';

    export function SwapTokensComponent() {
        const { wallet } = useWallet();

        async function swapTokens(tokenIn: string, tokenOut: string, amount: number) {
            // Get a quote from the Jupiter API
            const queryParams = new URLSearchParams({
                inputMint: tokenIn, // e.g "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
                outputMint: tokenOut, // e.g "XsCPL9dNWBMvFtTmwcCA5v3xWPSMEBCszbQdiLLq6aN"
                amount: amount.toString(), // In lamports!
                slippageBps: "50",
                maxAccounts: "33", // This ensures that even multi-hop swaps fit within Solana's transaction account limits and execute reliably.
            });

            const response = await fetch(`https://lite-api.jup.ag/swap/v1/quote?${queryParams}`, {
                method: "GET",
                headers: {
                    "Content-Type": "application/json",
                },
            });

            const quoteResponse = await response.json();

            // Build the swap transaction
            const swapResponse = await fetch("https://lite-api.jup.ag/swap/v1/swap", {
                method: "POST",
                headers: {
                    "Content-Type": "application/json",
                },
                body: JSON.stringify({
                    userPublicKey: wallet.address,
                    quoteResponse: quoteResponse,
                }),
            });

            const swapResponseData = await swapResponse.json();

            // Send the transaction
            const solanaWallet = SolanaWallet.from(wallet);

            const versionedTransaction = VersionedTransaction.deserialize(
                Buffer.from(swapResponseData.swapTransaction, "base64")
            );

            const tx = await solanaWallet.sendTransaction({
                transaction: versionedTransaction,
            });

            console.log("Swap transaction sent successfully!");
        }

        return (
            <div>
                <button onClick={() => swapTokens("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", "XsCPL9dNWBMvFtTmwcCA5v3xWPSMEBCszbQdiLLq6aN", 1)}>Swap Tokens</button>
            </div>
        );
    }
    ```

    See the [React SDK reference](/sdk-reference/wallets/react/hooks#wallet-methods) for more details.
  </Tab>

  <Tab title="Node.js">
    ```typescript theme={null}
    import { CrossmintWallets, createCrossmint, SolanaWallet } from "@crossmint/wallets-sdk";
    import { VersionedTransaction } from "@solana/web3.js";

    const crossmint = createCrossmint({
        apiKey: "<your-server-api-key>",
    });

    const crossmintWallets = CrossmintWallets.from(crossmint);

    const wallet = await crossmintWallets.getWallet(
        "email:user@example.com:solana",
        { chain: "solana", signer: { type: "email" } }
    );

    // Get a quote from the Jupiter API
    const tokenIn = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
    const tokenOut = "XsCPL9dNWBMvFtTmwcCA5v3xWPSMEBCszbQdiLLq6aN";
    const amount = 1000000000;

    const queryParams = new URLSearchParams({
        inputMint: tokenIn,
        outputMint: tokenOut,
        amount: amount.toString(), // In lamports!
        slippageBps: "50",
        maxAccounts: "33", // This ensures that even multi-hop swaps fit within Solana's transaction account limits and execute reliably.
    });

    const response = await fetch(`https://lite-api.jup.ag/swap/v1/quote?${queryParams}`, {
        method: "GET",
        headers: {
            "Content-Type": "application/json",
        },
    });

    const quoteResponse = await response.json();

    // Build the swap transaction
    const swapResponse = await fetch("https://lite-api.jup.ag/swap/v1/swap", {
        method: "POST",
        headers: {
            "Content-Type": "application/json",
        },
        body: JSON.stringify({
            userPublicKey: wallet.address,
            quoteResponse: quoteResponse,
        }),
    });

    const swapResponseData = await swapResponse.json();

    // Send the transaction
    const solanaWallet = SolanaWallet.from(wallet);

    const versionedTransaction = VersionedTransaction.deserialize(
        Buffer.from(swapResponseData.swapTransaction, "base64")
    );

    const tx = await solanaWallet.sendTransaction({
        transaction: versionedTransaction,
    });

    console.log("Swap transaction sent successfully!");
    ```
  </Tab>

  <Tab title="React Native">
    ```typescript theme={null}
    import { useWallet, SolanaWallet } from '@crossmint/client-sdk-react-native-ui';
    import { View, Button } from 'react-native';
    import { VersionedTransaction } from '@solana/web3.js';

    export function SwapTokensComponent() {
        const { wallet } = useWallet();

        async function swapTokens(tokenIn: string, tokenOut: string, amount: number) {
            // Get a quote from the Jupiter API
            const queryParams = new URLSearchParams({
                inputMint: tokenIn, // e.g "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
                outputMint: tokenOut, // e.g "XsCPL9dNWBMvFtTmwcCA5v3xWPSMEBCszbQdiLLq6aN"
                amount: amount.toString(), // In lamports!
                slippageBps: "50",
                maxAccounts: "33", // This ensures that even multi-hop swaps fit within Solana's transaction account limits and execute reliably.
            });

            const response = await fetch(`https://lite-api.jup.ag/swap/v1/quote?${queryParams}`, {
                method: "GET",
                headers: {
                    "Content-Type": "application/json",
                },
            });

            const quoteResponse = await response.json();

            // Build the swap transaction
            const swapResponse = await fetch("https://lite-api.jup.ag/swap/v1/swap", {
                method: "POST",
                headers: {
                    "Content-Type": "application/json",
                },
                body: JSON.stringify({
                    userPublicKey: wallet.address,
                    quoteResponse: quoteResponse,
                }),
            });

            const swapResponseData = await swapResponse.json();

            // Send the transaction
            const solanaWallet = SolanaWallet.from(wallet);

            const versionedTransaction = VersionedTransaction.deserialize(
                Buffer.from(swapResponseData.swapTransaction, "base64")
            );

            const tx = await solanaWallet.sendTransaction({
                transaction: versionedTransaction,
            });

            console.log("Swap transaction sent successfully!");
        }

        return (
            <View>
                <Button onPress={() => swapTokens("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", "XsCPL9dNWBMvFtTmwcCA5v3xWPSMEBCszbQdiLLq6aN", 1)}>Swap Tokens</Button>
            </View>
        );
    }
    ```

    See the [React Native SDK reference](/sdk-reference/wallets/react-native/hooks#wallet-methods) for more details.
  </Tab>

  <Tab title="REST">
    Transactions must be approved by one of the wallet's [signers](/wallets/concepts/wallet-signers).
    The SDK handles this automatically, but with the REST API you must [approve the transaction](/api-reference/wallets/approve-transaction) to complete it.

    <Steps>
      <Step title="Call the get quote endpoint">
        Call the [get quote endpoint](https://dev.jup.ag/docs/api/swap-api/quote) to get a quote for the swap.

        <CodeGroup>
          ```bash cURL theme={null}
          curl --request POST \
              --url https://lite-api.jup.ag/swap/v1/quote?inputMint=EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v&outputMint=XsCPL9dNWBMvFtTmwcCA5v3xWPSMEBCszbQdiLLq6aN&amount=1000000000&slippageBps=50&maxAccounts=33 \
              --header 'Content-Type: application/json'
          ```

          ```js Node.js theme={null}
          const url = 'https://lite-api.jup.ag/swap/v1/quote?inputMint=EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v&outputMint=XsCPL9dNWBMvFtTmwcCA5v3xWPSMEBCszbQdiLLq6aN&amount=1000000000&slippageBps=50&maxAccounts=33';
          const options = {
              method: 'GET',
              headers: {'Content-Type': 'application/json'},
          };

          try {
              const response = await fetch(url, options);
              const data = await response.json();
              console.log(data);
          } catch (error) {
              console.error(error);
          }
          ```

          ```python Python theme={null}
          import requests

          url = "https://lite-api.jup.ag/swap/v1/quote?inputMint=EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v&outputMint=XsCPL9dNWBMvFtTmwcCA5v3xWPSMEBCszbQdiLLq6aN&amount=1000000000&slippageBps=50&maxAccounts=33"

          headers = {
              "Content-Type": "application/json"
          }

          response = requests.get(url, headers=headers)

          print(response.json())
          ```
        </CodeGroup>

        See the [Jupiter API docs](https://dev.jup.ag/docs/api/swap-api/quote) for more details.
      </Step>

      <Step title="Build the swap transaction">
        Build the swap transaction using the [swap endpoint](https://dev.jup.ag/docs/api/swap-api/swap) and pass in the quote response from the previous step.

        <CodeGroup>
          ```bash cURL theme={null}
          curl --request POST \
              --url https://lite-api.jup.ag/swap/v1/swap \
              --header 'Content-Type: application/json' \
              --data '{"userPublicKey": "<user-public-key>", "quoteResponse": <quote-response>}'
          ```

          ```js Node.js theme={null}
          const url = 'https://lite-api.jup.ag/swap/v1/swap';
          const options = {
              method: 'POST',
              headers: {'Content-Type': 'application/json'},
              body: JSON.stringify({
                  userPublicKey: "<wallet-address>",
                  quoteResponse: <quote-response>
              })
          };

          try {
              const response = await fetch(url, options);
              const data = await response.json();
              console.log(data);
          } catch (error) {
              console.error(error);
          }
          ```

          ```python Python theme={null}
          import requests

          url = "https://lite-api.jup.ag/swap/v1/swap"

          headers = {
              "Content-Type": "application/json"
          }

          payload = {
              "userPublicKey": "<wallet-address>",
              "quoteResponse": <quote-response>
          }

          response = requests.post(url, json=payload, headers=headers)

          print(response.json())
          ```
        </CodeGroup>

        See the [Jupiter API docs](https://dev.jup.ag/docs/api/swap-api/swap) for more details.
      </Step>

      <Step title="Send the transaction">
        Follow the steps in the [Send a transaction](/wallets/guides/send-transaction-solana#rest) guide to submit the returned transaction in the previous step.
      </Step>
    </Steps>
  </Tab>
</Tabs>


# Overview
Source: https://docs.crossmint.com/wallets/guides/wallet-extensions/swapping-and-bridging

Exchange tokens and move assets across chains with Crossmint wallets

Crossmint wallets support token swapping and cross-chain bridging through third-party protocols. This lets you build applications where users can exchange tokens or move assets between blockchains directly from their wallets.

## What is Swapping?

Token swapping is the exchange of one token for another on the **same blockchain**. For example, swapping USDC for SOL on Solana, or swapping ETH for USDC on Base. Swaps execute in a single transaction and settle instantly.

## What is Bridging?

Bridging moves tokens from one blockchain to another. For example, moving USDC from Base to Polygon. Bridges involve transactions on both the source and destination chains, and typically take a few minutes to complete depending on the chains involved.

## What are Cross-Chain Swaps?

Cross-chain swaps combine swapping and bridging into a single operation — converting a token on one chain into a different token on another chain. For example, swapping USDC on Ethereum for SOL on Solana in one step.

## Explore the Guides

<CardGroup>
  <Card title="Jupiter" icon="arrow-right-arrow-left" href="/wallets/guides/wallet-extensions/swap-jupiter" />

  <Card title="LI.FI" icon="bridge" href="/wallets/guides/wallet-extensions/bridge-lifi" />
</CardGroup>


# Transfer Webhooks
Source: https://docs.crossmint.com/wallets/guides/webhooks

Receive real-time notifications for transfers

Wallet transfer webhooks allow you to receive real-time notifications when tokens are transferred in or out of wallets in your project. This enables you to track transfers, update your application state, and trigger automated workflows based on transfer events.

## Supported Configurations

Transfer webhooks have different levels of support depending on the blockchain and wallet type:

| Chain                                   | Wallet Types           | Token Types                                                      |
| --------------------------------------- | ---------------------- | ---------------------------------------------------------------- |
| **EVM** (Ethereum, Polygon, Base, etc.) | Smart wallets and EOAs | ERC-20 tokens only (native tokens like ETH, MATIC not supported) |
| **Solana**                              | Smart wallets and EOAs | All SPL tokens including native SOL                              |
| **Stellar**                             | Smart wallets and EOAs | Soroban tokens (fungible)                                        |

## Event Types

Crossmint provides two webhook event types for wallet transfers:

### `wallets.transfer.in`

Triggered when tokens are transferred **into** a wallet in your project. This event is only sent for successful transfers that have been confirmed onchain.

### `wallets.transfer.out`

Triggered when tokens are transferred **out of** a wallet in your project. This event is sent for both successful and failed transfer attempts, allowing you to track the complete lifecycle of outgoing transactions.

## Setup

To start receiving wallet transfer webhooks, you need to configure a webhook endpoint in the Crossmint Console.

### Step 1: Add a Webhook Endpoint

Follow the instructions in [Add an Endpoint](/introduction/platform/webhooks/add-endpoint) to configure your webhook URL and select the event types you want to receive.

When adding your endpoint, make sure to select:

* `wallets.transfer.in` - to receive notifications for incoming transfers
* `wallets.transfer.out` - to receive notifications for outgoing transfers

<Tip>
  Your webhook endpoint must return a 2xx HTTP status code within 15 seconds to acknowledge receipt. This is critical for webhook delivery confirmation.
</Tip>

### Step 2: Verify Webhook Signatures

To ensure webhook requests are legitimate and come from Crossmint, you must verify the signature of each webhook. See [Verify Webhooks](/introduction/platform/webhooks/verify-webhooks) for detailed instructions.

## Event Schemas

Both `wallets.transfer.in` and `wallets.transfer.out` events share a common structure with some key differences based on the transfer direction and outcome.

### Common Fields

All wallet transfer events include the following fields:

| Field                        | Type              | Description                                                                                                                   |
| ---------------------------- | ----------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| `id`                         | string            | Unique identifier for the webhook event                                                                                       |
| `type`                       | string            | Event type: `"wallets.transfer.in"` or `"wallets.transfer.out"`                                                               |
| `data.sender`                | object            | Information about the sender wallet                                                                                           |
| `data.sender.address`        | string            | Blockchain address of the sender                                                                                              |
| `data.sender.chain`          | string            | Chain identifier (e.g., `"ethereum"`, `"polygon"`, `"solana"`, `"stellar"`)                                                   |
| `data.sender.locator`        | string            | Wallet locator in the format `chain:address`                                                                                  |
| `data.sender.owner`          | string (optional) | Owner identifier if the sender is a Crossmint-managed wallet                                                                  |
| `data.recipient`             | object            | Information about the recipient wallet                                                                                        |
| `data.recipient.address`     | string            | Blockchain address of the recipient                                                                                           |
| `data.recipient.chain`       | string            | Chain identifier                                                                                                              |
| `data.recipient.locator`     | string            | Wallet locator in the format `chain:address`                                                                                  |
| `data.recipient.owner`       | string (optional) | Owner identifier for the recipient wallet                                                                                     |
| `data.token`                 | object            | Information about the transferred token                                                                                       |
| `data.token.type`            | string            | Token type, currently only `"fungible"` is supported                                                                          |
| `data.token.chain`           | string            | Chain where the token exists                                                                                                  |
| `data.token.locator`         | string            | Token locator in the format `chain:contractAddress`                                                                           |
| `data.token.amount`          | string            | Human-readable amount (adjusted for decimals)                                                                                 |
| `data.token.rawAmount`       | string            | Raw amount in smallest unit (e.g., wei for ETH)                                                                               |
| `data.token.contractAddress` | string (EVM)      | Token contract address for EVM chains                                                                                         |
| `data.token.mintHash`        | string (Solana)   | Token mint address for Solana                                                                                                 |
| `data.token.contractId`      | string (Stellar)  | Token contract ID for Stellar                                                                                                 |
| `data.token.decimals`        | number            | Number of decimals for the token                                                                                              |
| `data.token.symbol`          | string (optional) | Token symbol (e.g., `"USDC"`, `"ETH"`)                                                                                        |
| `data.status`                | string            | Transfer status: `"succeeded"` or `"failed"`                                                                                  |
| `data.transferId`            | string (optional) | Unique identifier for the transfer, can be used with the [`Get Transaction API`](/api-reference/wallets/get-transaction)      |
| `data.completedAt`           | string            | ISO 8601 timestamp when the transfer was completed. Timestamp may be off by a few seconds from the actual onchain transaction |

### Type-Specific Differences

**Incoming Transfers (`wallets.transfer.in`)**:

* `data.status` is always `"succeeded"` (only successful transfers are reported)
* `data.onChain` is always present with transaction details

**Outgoing Transfers (`wallets.transfer.out`)**:

* `data.status` can be `"succeeded"` or `"failed"`
* `data.onChain` is present only when `status` is `"succeeded"`
* `data.error` is present only when `status` is `"failed"`

<Note>
  The `transferId` field is only available for transfers initiated through the Crossmint API. It can be used to retrieve the transfer details from the [`Get Transaction API`](/api-reference/wallets/get-transaction).
</Note>

### Event Examples

<Accordion title="Incoming Transfer Example">
  ```json theme={null}
  {
    "id": "whevnt_12324",
    "type": "wallets.transfer.in",
    "data": {
      "transferId": "660e8400-e29b-41d4-a716-446655440002",
      "sender": {
        "address": "0x1234567890123456789012345678901234567890",
        "chain": "ethereum",
        "locator": "ethereum:0x1234567890123456789012345678901234567890"
      },
      "recipient": {
        "address": "0x0987654321098765432109876543210987654321",
        "chain": "ethereum",
        "locator": "ethereum:0x0987654321098765432109876543210987654321",
        "owner": "email:user@example.com"
      },
      "token": {
        "type": "fungible",
        "chain": "ethereum",
        "locator": "ethereum:0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
        "amount": "100.50",
        "rawAmount": "100500000",
        "contractAddress": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
        "decimals": 6,
        "symbol": "USDC"
      },
      "status": "succeeded",
      "completedAt": "2025-10-21T12:34:56.789Z",
      "onChain": {
        "txId": "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
        "explorerLink": "https://etherscan.io/tx/0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"
      }
    }
  }
  ```
</Accordion>

<Accordion title="Incoming Transfer (Stellar) Example">
  ```json theme={null}
  {
    "id": "whevnt_34567",
    "type": "wallets.transfer.in",
    "data": {
      "transferId": "770e8400-e29b-41d4-a716-446655440003",
      "sender": {
        "address": "GDQP2KPQGKIHYJGXNUIYOMHARUARCA7DJT5FO2FFOOUJ3DQMFX7AQZED",
        "chain": "stellar",
        "locator": "stellar:GDQP2KPQGKIHYJGXNUIYOMHARUARCA7DJT5FO2FFOOUJ3DQMFX7AQZED"
      },
      "recipient": {
        "address": "GBZXN7PIRZGNMHGA7MUUUF4GWPY5AYPV6LY4UV2GL6VJGIQRXFDNMADI",
        "chain": "stellar",
        "locator": "stellar:GBZXN7PIRZGNMHGA7MUUUF4GWPY5AYPV6LY4UV2GL6VJGIQRXFDNMADI",
        "owner": "email:user@example.com"
      },
      "token": {
        "type": "fungible",
        "chain": "stellar",
        "locator": "stellar:CAS3J7GYLGXMF6TDJBBYYSE3HQ6BBSMLNUQ34T6TZMYMW2EVH34XOWMA",
        "amount": "100.5000000",
        "rawAmount": "1005000000",
        "contractId": "CAS3J7GYLGXMF6TDJBBYYSE3HQ6BBSMLNUQ34T6TZMYMW2EVH34XOWMA",
        "decimals": 7,
        "symbol": "USDC"
      },
      "status": "succeeded",
      "completedAt": "2025-10-21T12:34:56.789Z",
      "onChain": {
        "txId": "abc123def456abc123def456abc123def456abc123def456abc123def456abc1",
        "explorerLink": "https://stellar.expert/explorer/public/tx/abc123def456abc123def456abc123def456abc123def456abc123def456abc1"
      }
    }
  }
  ```
</Accordion>

<Accordion title="Outgoing Transfer (Success) Example">
  ```json theme={null}
  {
    "id": "whevnt_56789",
    "type": "wallets.transfer.out",
    "data": {
      "transferId": "550e8400-e29b-41d4-a716-446655440000",
      "sender": {
        "address": "0x0987654321098765432109876543210987654321",
        "chain": "ethereum",
        "locator": "ethereum:0x0987654321098765432109876543210987654321",
        "owner": "email:user@example.com"
      },
      "recipient": {
        "address": "0x1234567890123456789012345678901234567890",
        "chain": "ethereum",
        "locator": "ethereum:0x1234567890123456789012345678901234567890"
      },
      "token": {
        "type": "fungible",
        "chain": "ethereum",
        "locator": "ethereum:0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
        "amount": "50.25",
        "rawAmount": "50250000",
        "contractAddress": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
        "decimals": 6,
        "symbol": "USDC"
      },
      "status": "succeeded",
      "completedAt": "2025-10-21T12:34:56.789Z",
      "onChain": {
        "txId": "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
        "explorerLink": "https://etherscan.io/tx/0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890"
      }
    }
  }
  ```
</Accordion>

<Accordion title="Outgoing Transfer (Failed) Example">
  ```json theme={null}
  {
    "id": "whevnt_99999",
    "type": "wallets.transfer.out",
    "data": {
      "transferId": "550e8400-e29b-41d4-a716-446655440001",
      "sender": {
        "address": "0x0987654321098765432109876543210987654321",
        "chain": "ethereum",
        "locator": "ethereum:0x0987654321098765432109876543210987654321",
        "owner": "email:user@example.com"
      },
      "recipient": {
        "address": "0x1234567890123456789012345678901234567890",
        "chain": "ethereum",
        "locator": "ethereum:0x1234567890123456789012345678901234567890"
      },
      "token": {
        "type": "fungible",
        "chain": "ethereum",
        "locator": "ethereum:0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
        "amount": "1000.00",
        "rawAmount": "1000000000",
        "contractAddress": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
        "decimals": 6,
        "symbol": "USDC"
      },
      "status": "failed",
      "completedAt": "2025-10-21T12:34:56.789Z",
      "error": {
        "message": "Transaction reverted",
        "reason": "execution_reverted",
        "revert": {
          "type": "contract_call",
          "reason": "ERC20: transfer amount exceeds balance"
        }
      }
    }
  }
  ```
</Accordion>

### Error Fields (Outgoing Transfers Only)

When an outgoing transfer fails, the following error fields are included:

| Field                      | Type           | Description                                                                        |
| -------------------------- | -------------- | ---------------------------------------------------------------------------------- |
| `data.error.message`       | string         | Error message                                                                      |
| `data.error.reason`        | string         | Error reason (e.g., `"execution_reverted"`, `"program_error"`, `"build_failed"`)   |
| `data.error.revert`        | object         | Revert details from smart contract                                                 |
| `data.error.revert.type`   | string         | Revert type: `"contract_call"`, `"wallet_authorization"`, or `"wallet_deployment"` |
| `data.error.revert.reason` | string         | Revert reason message                                                              |
| `data.error.logs`          | any (optional) | Additional error logs                                                              |

## Best Practices

For comprehensive guidance on implementing reliable webhook handlers, see [Webhook Best Practices](/introduction/platform/webhooks/best-practices). This includes detailed information on:

## Related Resources

* [Add an Endpoint](/introduction/platform/webhooks/add-endpoint) - Configure webhook endpoints
* [Verify Webhooks](/introduction/platform/webhooks/verify-webhooks) - Verify webhook signatures
* [Best Practices](/introduction/platform/webhooks/best-practices) - Webhook implementation best practices
* [Create Wallet](/wallets/guides/create-wallet) - Create wallets to receive transfers
* [Transfer Tokens](/wallets/guides/transfer-tokens) - Initiate token transfers


# Overview
Source: https://docs.crossmint.com/wallets/overview

Create wallets for users, agents, or company operations

Crossmint provides secure, programmable wallet infrastructure powering some of the World's leading fintechs and enterprises, like MoneyGram and Santander Bank.

A single SDK, configurable for any use case — from embedded, invisible wallets for your users, to high-throughput treasury wallets, to wallets for AI agents. All blockchain complexity is abstracted away from you and your users.

The APIs are chain-agnostic and take care of all wallet operations: creation, transaction execution, gas sponsorship, [onramps](/stablecoin-orchestration/onramp/overview), compliance tools, advanced policies and controls, and more; so you can get started in minutes and be ready to scale.

Additionally, Crossmint provides wallet extensions for cards, swapping, staking, prediction markets, tokenized stocks, and other primitives so you can easily connect to the best external tools.

## Where to Start

<CardGroup>
  <Card title="Evaluating Crossmint?" icon="magnifying-glass" href="/wallets/architecture">
    Read **Architecture** to understand the dual-layer model, then **Custody Modalities** for compliance implications.
  </Card>

  <Card title="Ready to build?" icon="code" href="/wallets/quickstarts/react">
    Jump to a **Quickstart** for your platform. You can create a wallet in under 5 minutes.
  </Card>

  <Card title="Choosing signers?" icon="key" href="/wallets/concepts/decision-tree">
    Use the **Decision Tree** to pick the right operational and recovery signer types for your use case.
  </Card>
</CardGroup>

## Next-gen architecture

Most wallet providers couple the private key and the wallet together. Crossmint takes a different approach: wallets are [smart contract wallets](/wallets/why-smart-wallets) with a [modular signer architecture](/wallets/concepts/wallet-signers). You choose the signing method, and you can change it anytime — without changing wallet addresses.

This architecture makes operating wallets cheaper, provides maximum flexibility around custody and use case, and removes vendor lock-in.

For a full technical explanation, see [Architecture](/wallets/architecture).

**Key features:**

* **Seamless UX**: no passphrases, gas fees, or other blockchain gimmicks.
* **Flexible key management**: Choose your preferred signing methods. Rotate or update anytime if your needs change.
* **Operational signers**: Add scoped signers with permissions and limits.
* **Native gas sponsorship**: Crossmint pays for gas fees and bills you in fiat.
* **Built-in onramps**: headless flows to allow users to fund their wallets.
* **Multi-chain**: 50+ [supported chains](/introduction/supported-chains) via one unified API.
* **Reliability engine**: Crossmint operates a reliability layer for transaction submission with multi-RPC failover, queuing, batching, priority fee optimization, and more.
* **Powerful extensions**: Composable features like swaps, staking, cards, and more.
* **Native programmability**: enable functionality only possible with smart accounts, like subscriptions and advanced payment logic.
* **Account recovery**: allow users to retrieve their account, even if they lose access to their main signer.
* **Webhooks**: Real-time notifications for wallet events.
* **No vendor lock-in**: change vendors anytime by taking ownership of the contracts and migrating signers, without having to change wallet addresses or migrate vendors.

<CardGroup>
  <Card title="Test a live demo" icon="bolt" href="https://wallets.demos-crossmint.com">
    Sample demo and repo showcasing basic features
  </Card>
</CardGroup>

## Common use cases

<CardGroup>
  <Card title="Embedded wallets" icon="window" href="/wallets/guides/create-wallet">
    Insert white-label wallets into your app.
  </Card>

  <Card title="Treasury wallets" icon="vault" href="/stablecoin-orchestration/treasury-wallet/overview">
    Manage your company's digital assets.
  </Card>

  <Card title="Agent wallets" icon="robot">
    Give wallets to your AI agents.
  </Card>
</CardGroup>

## Try it Live

Experience creating a wallet with this interactive demo:

<WalletCreationDemo />

## Choose your SDK

<CardGroup>
  <Card title="React" icon="react" href="/wallets/quickstarts/react" />

  <Card title="Node.js" icon="node-js" href="/wallets/quickstarts/nodejs" />

  <Card title="REST API" icon="server" href="/wallets/quickstarts/restapi" />

  <Card title="React Native" icon="mobile-notch" href="/wallets/quickstarts/react-native" />

  <Card title="Swift" icon="swift" href="/wallets/quickstarts/swift" />

  <Card title="Kotlin" icon="android" href="/wallets/quickstarts/kotlin" />
</CardGroup>

## Learn More

* [Architecture](/wallets/architecture)
* [Wallet Signers](/wallets/concepts/wallet-signers)
* [Create a wallet](/wallets/guides/create-wallet)
* [Transfer tokens](/wallets/guides/transfer-tokens)
* [Get balance](/wallets/guides/check-balances)
* [Webhooks](/wallets/guides/webhooks)
* [Glossary](/introduction/glossary)


# Kotlin
Source: https://docs.crossmint.com/wallets/quickstarts/kotlin

Create user wallets from your mobile app in under 5 minutes

This quickstart integrates the Crossmint Kotlin SDK into an Android app to create a non-custodial wallet for a user, fund it with testnet USDC on Base Sepolia, and send USDC to another wallet.

<CardGroup>
  <Snippet />

  <Card title="Android Demo App" icon="github" href="https://github.com/Crossmint/android-quickstart">
    See a full working example with a repository to clone.
  </Card>
</CardGroup>

<Steps>
  <Step title="Install the SDK">
    Add the Crossmint dependencies to your app's `build.gradle.kts` file:

    <Tabs>
      <Tab title="Version Catalog">
        ```kotlin build.gradle.kts theme={null}
        dependencies {
            implementation(libs.crossmint.sdk)
            implementation(libs.crossmint.compose)
        }
        ```

        ```toml libs.versions.toml theme={null}
        [versions]
        crossmint-compose = "0.0.2"
        crossmint-sdk = "0.0.2"

        [libraries]
        crossmint-compose = { module = "com.crossmint:crossmint-compose", version.ref = "crossmint-compose" }
        crossmint-sdk = { module = "com.crossmint:crossmint-sdk", version.ref = "crossmint-sdk" }
        ```
      </Tab>

      <Tab title="Direct">
        ```kotlin build.gradle.kts theme={null}
        dependencies {
            implementation("com.crossmint:crossmint-sdk:0.0.2")
            implementation("com.crossmint:crossmint-compose:0.0.2")
        }
        ```
      </Tab>
    </Tabs>

    ### Requirements

    * Minimum Android SDK: API 24 (Android 7.0+)
    * JDK 11 or newer
    * Jetpack Compose
  </Step>

  <Step title="Configure your API key">
    The Crossmint SDK requires a client API key for authentication. <br />
    [Get your client API key](/introduction/platform/api-keys/client-side) using the Crossmint Console.
  </Step>

  <Step title="Initialize the Crossmint SDK">
    Wrap your app content with `CrossmintSDKProvider` to initialize the SDK. This example uses [Crossmint Auth](/authentication/introduction)
    but you can use [any authentication provider of your choice](/wallets/guides/bring-your-own-auth).

    ```kotlin QuickstartApp.kt theme={null}
    import androidx.compose.runtime.Composable
    import com.crossmint.kotlin.compose.CrossmintSDKProvider

    val CROSSMINT_API_KEY = "ck_staging_your_key_here"

    @Composable
    fun QuickstartApp() {
        CrossmintSDKProvider
            .Builder(CROSSMINT_API_KEY)
            .build {
                // Your app content goes here
                AppContent()
            }
    }
    ```

    <Note>
      The environment (staging vs production) is automatically determined by your API key. Staging keys start with `ck_staging_`, production keys with `ck_production_`.
    </Note>

    ### Access SDK instances

    Inside the `CrossmintSDKProvider`, access SDK functionality using `LocalCrossmintSDK.current`:

    ```kotlin theme={null}
    import com.crossmint.kotlin.compose.LocalCrossmintSDK

    val sdk = LocalCrossmintSDK.current
    val authManager = sdk.authManager
    val wallets = sdk.crossmintWallets
    ```
  </Step>

  <Step title="Authenticate users">
    Actions within the SDK are user-based, so first you need to authenticate a user.
    Choose your authentication method:

    <Tabs>
      <Tab title="Crossmint Auth (OTP)">
        Use Crossmint's built-in OTP authentication for easy, email-based login.

        <Accordion title="OTP Sample Code">
          This is a simple OTP form example you can use for this quickstart.

          ```kotlin theme={null}
          @Composable
          actual fun OTPDialog(
              onOTPSubmit: (String) -> Unit,
              onDismiss: () -> Unit,
          ) {
              var otpCode by remember { mutableStateOf("") }

              AlertDialog(
                  onDismissRequest = onDismiss,
                  title = { Text("Enter OTP Code") },
                  text = {
                      TextField(
                          value = otpCode,
                          onValueChange = { otpCode = it },
                          label = { Text("Enter OTP") },
                          singleLine = true,
                      )
                  },
                  confirmButton = {
                      Button(onClick = { onOTPSubmit(otpCode) }) {
                          Text("Submit")
                      }
                  },
                  dismissButton = {
                      TextButton(onClick = onDismiss) {
                          Text("Cancel")
                      }
                  },
              )
          }        
          ```
        </Accordion>

        <Steps>
          <Step title="Send OTP to user's email">
            ```kotlin theme={null}
            import com.crossmint.kotlin.compose.LocalCrossmintSDK

            val authManager = LocalCrossmintSDK.current.authManager
            when (val result = authManager.sendOtp("user_email")) {
                is Result.Success -> {
                    // OTP sent to email, now display an input for the OTP
                }
                is Result.Failure -> {
                    // Handle error: result.error.message
                }
            }
            ```
          </Step>

          <Step title="Enter the OTP sent to the user's email">
            ```kotlin theme={null}
            import com.crossmint.kotlin.compose.LocalCrossmintSDK

            val authManager = LocalCrossmintSDK.current.authManager
            when (val result = authManager.verifyOtp("user_email", "otp_sent_via_email")) {
                is Result.Success -> {
                    // User is authenticated, proceed
                }
                is Result.Failure -> {
                    // Handle errors
                }
            }
            ```
          </Step>
        </Steps>

        <Note>
          See the [Android Demo App](https://github.com/Crossmint/android-quickstart) repository for a complete UI implementation example with ViewModels and Compose screens.
        </Note>
      </Tab>

      <Tab title="Third-Party Auth (Prod)">
        If you have an existing auth provider (Auth0, Firebase, Supabase, etc.), authenticate users with your provider and pass the JWT to Crossmint.

        ```kotlin theme={null}
        import com.crossmint.kotlin.compose.LocalCrossmintSDK

        val authManager = LocalCrossmintSDK.current.authManager

        // After user authenticates with your provider, get their JWT
        val token = AuthToken(
            jwt = yourProviderJWT,
            refreshToken = yourProviderRefreshToken, // optional
            userId = yourProviderUserId, // optional
            userEmail = userEmail // optional
        )

        when (val result = authManager.authenticateWithToken(token)) {
            is Result.Success -> {
                // User authenticated with Crossmint
            }
            is Result.Failure -> {
                // Handle error: result.error.message
            }
        }
        ```

        <Note>
          Configure JWT authentication in the [Crossmint Console](https://console.crossmint.com) under API Keys → JWT Authentication before using third-party auth. See the [Crossmint Demo App](https://github.com/Crossmint/crossmint-kotlin-sdk/tree/main/crossmintDemoApp) for a complete Supabase integration example.
        </Note>
      </Tab>
    </Tabs>
  </Step>

  <Step title="Create a wallet">
    After authentication, create the user's wallet. This example uses Base Sepolia (Base testnet) but you can chose any [supported chain](/introduction/supported-chains).<br />

    ```kotlin theme={null}
    import com.crossmint.kotlin.compose.LocalCrossmintSDK
    import com.crossmint.kotlin.types.EVMChain
    import com.crossmint.kotlin.types.SignerData

    val crossmintWallets = LocalCrossmintSDK.current.crossmintWallets
    val chain = EVMChain.BaseSepolia
    val signer = SignerData.Email("user_email")
    when (val result = crossmintWallets.getOrCreateWallet(chain, signer)) {
        is Result.Success -> {
            val wallet = result.value // Wallet is ready to use!
        }
        is Result.Failure -> {
            // Handle error: result.error.message
        }
    }
    ```
  </Step>

  <Step title="Send USDC">
    Before sending some USDC, we need to get some into the wallet.

    Get the wallet address:

    ```kotlin theme={null}
    val walletAddress = wallet.address
    ```

    Then, navigate to the [USDC Faucet](https://faucet.circle.com/) to get some USDC into the wallet.
    Make sure to select `Base Sepolia` and insert the wallet address.

    <img alt="Circle faucet — Base Sepolia selected" />

    Now, to send some USDC to another wallet, use the `wallet.send` function.

    ```kotlin theme={null}
    // Create the transaction
    val recipient = "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb"
    val tokenLocator = "base-sepolia:usdc"
    val amount = 0.01
    val sendResult = wallet.send(recipient, tokenLocator, amount)
    if (sendResult is Result.Failure) {
        // handle failure
    }

    // Approve the transaction
    val transaction = sendResult as Result.Success<Transaction>
    when (val approveResult = wallet.approve(transaction.value.id)) {
        is Result.Success -> {
            // Transaction successful, proceed
        }
        is Result.Failure -> {
            // Handle failure
        }
    }
    ```

    The very first time that a wallet sends a transaction on this device, an OTP will be required, sent to the user via email.

    Following transactions sent from the same device won't need OTP verification.

    To facilitate this, here's a simple component you can use for the OTP input:

    <Accordion title="OTP Sample code">
      This is a simple OTP form example you can use for this quickstart.

      ```kotlin theme={null}
      @Composable
      actual fun OTPDialog(
          onOTPSubmit: (String) -> Unit,
          onDismiss: () -> Unit,
      ) {
          var otpCode by remember { mutableStateOf("") }

          AlertDialog(
              onDismissRequest = onDismiss,
              title = { Text("Enter OTP Code") },
              text = {
                  TextField(
                      value = otpCode,
                      onValueChange = { otpCode = it },
                      label = { Text("Enter OTP") },
                      singleLine = true,
                  )
              },
              confirmButton = {
                  Button(onClick = { onOTPSubmit(otpCode) }) {
                      Text("Submit")
                  }
              },
              dismissButton = {
                  TextButton(onClick = onDismiss) {
                      Text("Cancel")
                  }
              },
          )
      }        
      ```
    </Accordion>

    and in `QuickstartApp.kt` where the `CrossmintSDKProvider` was initialized, use it like this:

    ```kotlin QuickstartApp.kt theme={null}
        CrossmintSDKProvider
            .Builder(CROSSMINT_API_KEY)
            .onTEERequired { onOTPSubmit, onDismiss ->
                OTPDialog(
                    onOTPSubmit = onOTPSubmit,
                    onDismiss = onDismiss,
                )
            }
            .build {
                // Your app content goes here
                AppContent()
            }
    ```

    And that's it! You just created a non-custodial wallet for your user and made a USDC transaction on Base Sepolia.
  </Step>
</Steps>

## Launching in Production

For production, the steps are almost identical, but some changes are required:

1. Create a developer account on the [production console](https://www.crossmint.com/console)
2. Create a production client API key on the [API Keys](https://www.crossmint.com/console/projects/apiKeys) page with the API scopes `users.create`, `users.read`, `wallets.read`, `wallets.create`, `wallets:transactions.create`, `wallets:transactions.sign`, `wallets:balance.read`, `wallets.fund`
3. Update your `local.properties` with the production API key
4. **Use your own authentication provider**: For production applications, Crossmint recommends using [third-party authentication](/wallets/guides/bring-your-own-auth) (Option 2 from Step 4) with providers like Auth0, Firebase, or Supabase, rather than Crossmint Auth (OTP). Configure JWT authentication in the [Crossmint Console](https://www.crossmint.com/console/projects/apiKeys) under API Keys → JWT Authentication.


# Node.js
Source: https://docs.crossmint.com/wallets/quickstarts/nodejs

Create user wallets from your backend in under 5 minutes

<CardGroup>
  <Snippet />
</CardGroup>

<Steps>
  <Step title="Install the SDK">
    Run the following command to install the SDK:

    <Snippet />
  </Step>

  <Step title="Create a wallet">
    See all supported chains [here](/introduction/supported-chains).

    ```tsx index.ts theme={null}
    import { CrossmintWallets, createCrossmint } from "@crossmint/wallets-sdk";

    const crossmint = createCrossmint({
        apiKey: "<your-server-api-key>",
    });

    const crossmintWallets = CrossmintWallets.from(crossmint);

    const wallet = await crossmintWallets.createWallet({
        chain: "<your-chain>",
        signer: {
            type: "<signer-type>",
        },
    });

    console.log(wallet.address);
    ```
  </Step>
</Steps>

## Launching in Production

For production, the steps are almost identical, but some changes are required:

1. Create a developer account on the [production console](https://www.crossmint.com/console)
2. Create a production client API key on the [API Keys](https://www.crossmint.com/console/projects/apiKeys) page with the API scopes `users.create`, `users.read`, `wallets.read`, `wallets.create`, `wallets:transactions.create`, `wallets:transactions.sign`, `wallets:balance.read`, `wallets.fund`
3. Replace your test API key with the production key

## Learn More

<CardGroup>
  <Card title="Check Balances" icon="money-bill-transfer" href="/wallets/guides/check-balances">
    Check the balance of a wallet.
  </Card>

  <Card title="Transfer Tokens" icon="coins" href="/wallets/guides/transfer-tokens">
    Send tokens between wallets.
  </Card>

  <Card title="Operational Signers" icon="key" href="/wallets/guides/signers/registering-a-signer">
    Register operational signers on a wallet.
  </Card>
</CardGroup>

## Other Links

<CardGroup>
  <Card title="API Reference" icon="terminal" href="/api-reference/wallets/create-wallet">
    Deep dive into API reference docs.
  </Card>

  <Card title="Talk to an expert" icon="message" href="https://www.crossmint.com/contact/sales">
    Contact our sales team for support.
  </Card>
</CardGroup>


# React
Source: https://docs.crossmint.com/wallets/quickstarts/react

Create user wallets from your frontend in under 5 minutes

<CardGroup>
  <Snippet />

  <Card title="Wallets Quickstart" icon="github" href="https://github.com/Crossmint/wallets-quickstart">
    See a full working example.
  </Card>
</CardGroup>

<Steps>
  <Step title="Install the SDK">
    Run the following command to install the SDK:

    <Snippet />
  </Step>

  <Step title="Add the Crossmint providers to your app">
    Add the necessary Crossmint providers to your app. This example uses [Crossmint Auth](/authentication/introduction)
    but you can use [any authentication provider of your choice](/wallets/guides/bring-your-own-auth).

    With the current setup, a wallet will be created automatically on login.

    <CodeGroup>
      ```tsx next.js theme={null}
      "use client";

      import {
          CrossmintProvider,
          CrossmintAuthProvider,
          CrossmintWalletProvider,
      } from "@crossmint/client-sdk-react-ui";

      export function Providers({ children }: { children: React.ReactNode }) {
          return (
              <CrossmintProvider apiKey="<crossmint-client-api-key>">
                  <CrossmintAuthProvider>
                      <CrossmintWalletProvider
                          createOnLogin={{
                              chain: "base-sepolia",
                              signer: {
                                  type: "email",
                              },
                          }}
                      >
                          {children}
                      </CrossmintWalletProvider>
                  </CrossmintAuthProvider>
              </CrossmintProvider>
          );
      }
      ```

      ```tsx create-react-app theme={null}
      import ReactDOM from 'react-dom/client';

      import './index.css';

      import App from './App';

      import {
          CrossmintProvider,
          CrossmintAuthProvider,
          CrossmintWalletProvider,
      } from "@crossmint/client-sdk-react-ui";

      const root = ReactDOM.createRoot(document.getElementById('root'));

      root.render(
          <React.StrictMode>
              <CrossmintProvider apiKey="<crossmint-client-api-key>">
                      <CrossmintAuthProvider>
                          <CrossmintWalletProvider
                              createOnLogin={{
                                  chain: "base-sepolia",
                                  signer: {
                                      type: "email",
                                  },
                              }}
                          >
                              <App />
                          </CrossmintWalletProvider>
                      </CrossmintAuthProvider>
                  </CrossmintProvider>
          </React.StrictMode>
      );
      ```
    </CodeGroup>

    For detailed configuration options, see the [React SDK Reference](/sdk-reference/wallets/react/providers#crossmintwalletprovider).
  </Step>

  <Step title="Build a wallet component with basic functionality">
    Create a component that handles authentication and basic wallet actions.

    ```tsx wallet-app.tsx theme={null}
    import { useState } from "react";
    import { useAuth, useWallet } from "@crossmint/client-sdk-react-ui";

    export function WalletApp() {
        const { login, logout, jwt, status } = useAuth();
        const { wallet } = useWallet();
        const [usdxmBalance, setUsdxmBalance] = useState<string>("");

        const fundWallet = async () => {
            if (!wallet || !jwt) return;
            await wallet.stagingFund(10);
        };

        const transferTokens = async () => {
            if (!wallet) return;
            
            const recipient = "0xdf8b5f9c19e187f1ea00730a1e46180152244315";
            const token = "usdxm";
            const amount = "1";
            
            await wallet.send(recipient, token, amount);
        };

        const checkBalance = async () => {
            if (!wallet) return;
            const balances = await wallet.balances(["usdxm"]);
            const usdxmBalance = balances.tokens.find(
                (token) => token.symbol === "usdxm"
            )?.amount;
            setUsdxmBalance(usdxmBalance || "0");
        };

        if (status === "initializing") {
            return <div>Loading...</div>;
        }

        if (wallet == null || status === "logged-out") {
            return <button onClick={login}>Login</button>;
        }

        return (
            <div>
                <h2>💼 Wallet: {wallet?.address}</h2>
                <h3>👤 {wallet?.owner}</h3><br />
                <button onClick={fundWallet}>💰 Fund with 10 USDXM</button><br />
                <button onClick={transferTokens}>📤 Send 1 USDXM</button><br />
                <button onClick={checkBalance}>🔍 Check Balance</button><br />
                <button onClick={logout}>🚪 Logout</button>
                {usdxmBalance && <p>💳 USDXM Balance: {usdxmBalance}</p>}
            </div>
        );
    }

    ```
  </Step>

  <Step title="Render the wallet app">
    Render the wallet app in your application.

    ```tsx app.tsx theme={null}
    "use client";

    import { Providers } from './providers';
    import { WalletApp } from './wallet-app';

    export default function Home() {
        return (
            <Providers>
                <WalletApp />
            </Providers>
        );
    }
    ```
  </Step>
</Steps>

## Launching in Production

For production, some changes are required:

1. Create a developer account on the [production console](https://www.crossmint.com/console)
2. Create a production client API key on the [API Keys](https://www.crossmint.com/console/projects/apiKeys) page with the API scopes `users.create`, `users.read`, `wallets.read`, `wallets.create`, `wallets:transactions.create`, `wallets:transactions.sign`, `wallets:balance.read`, `wallets.fund`
3. Replace your test API key with the production key
4. **Use your own authentication provider**: For production applications, Crossmint recommends using [third-party authentication](/wallets/guides/bring-your-own-auth) with providers like Auth0, Firebase, or Supabase, rather than Crossmint Auth. Configure JWT authentication in the [Crossmint Console](https://www.crossmint.com/console/projects/apiKeys) under API Keys > JWT Authentication.

## Learn More

<CardGroup>
  <Card title="Check Balances" icon="money-bill-transfer" href="/wallets/guides/check-balances">
    Check the balance of a wallet.
  </Card>

  <Card title="Transfer Tokens" icon="coins" href="/wallets/guides/transfer-tokens">
    Send tokens between wallets.
  </Card>

  <Card title="Operational Signers" icon="key" href="/wallets/guides/signers/registering-a-signer">
    Register operational signers on a wallet.
  </Card>
</CardGroup>

## Other Links

<CardGroup>
  <Card title="API Reference" icon="terminal" href="/api-reference/wallets/create-wallet">
    Deep dive into API reference docs.
  </Card>

  <Card title="Talk to an expert" icon="message" href="https://www.crossmint.com/contact/sales">
    Contact our sales team for support.
  </Card>
</CardGroup>


# React Native
Source: https://docs.crossmint.com/wallets/quickstarts/react-native

Create user wallets from your frontend in under 5 minutes

<CardGroup>
  <Snippet />

  <Card title="Expo Wallets Quickstart" icon="github" href="https://github.com/Crossmint/wallets-expo-quickstart">
    See a full working example.
  </Card>
</CardGroup>

<Steps>
  <Step title="Install the SDK">
    Run the following command to install the SDK:

    <Snippet />
  </Step>

  <Step title="Add the Crossmint providers to your app">
    Add the necessary Crossmint providers to your app. This example uses [Crossmint Auth](/authentication/introduction)
    but you can use [any authentication provider of your choice](/wallets/guides/bring-your-own-auth).

    With the current setup, a wallet will be created automatically on login.

    See all supported chains [here](/introduction/supported-chains).

    ```tsx providers.tsx theme={null}
    import {
        CrossmintAuthProvider,
        CrossmintProvider,
        CrossmintWalletProvider,
    } from "@crossmint/client-sdk-react-native-ui";

    type ProvidersProps = {
        children: React.ReactNode;
    };

    export default function CrossmintProviders({ children }: ProvidersProps) {

        return (
            <CrossmintProvider apiKey={"<your-client-api-key>"}>
                <CrossmintAuthProvider>
                    <CrossmintWalletProvider
                        createOnLogin={{
                            chain: "<your-chain>",
                            signer: {
                                type: "<signer-type>",
                            }
                        }}
                    >
                        {children}
                    </CrossmintWalletProvider>
                </CrossmintAuthProvider>
            </CrossmintProvider>
        );
    }
    ```

    For detailed configuration options, see the [React Native SDK Reference](/sdk-reference/wallets/react-native/providers#crossmintwalletprovider).
  </Step>

  <Step title="Allow users to login and logout and access their wallet">
    Crossmint Auth in React Native is headless. You will need to implement your own login and logout buttons.

    ```tsx index.tsx theme={null}
    import React, { useEffect, useState } from "react";
    import {
        View,
        Text,
        TextInput,
        TouchableOpacity,
        ActivityIndicator,
        Alert,
    } from "react-native";
    import {
        useCrossmintAuth,
        useWallet,
    } from "@crossmint/client-sdk-react-native-ui";
    import * as Linking from "expo-linking";

    export default function Index() {
        const {
            loginWithOAuth,
            createAuthSession,
            user,
            crossmintAuth,
            logout,
            status,
        } = useCrossmintAuth();
        const { wallet } = useWallet();

        // Login state
        const [email, setEmail] = useState("");
        const [emailId, setEmailId] = useState("");
        const [otpSent, setOtpSent] = useState(false);
        const [otp, setOtp] = useState("");
        const [isPending, setIsPending] = useState(false);

        // Handle OAuth callback
        useEffect(() => {
            const url = Linking.useURL();
            if (url != null) {
                createAuthSession(url);
            }
        }, [createAuthSession]);

        // Login functions
        const sendOtp = async () => {
            if (!email.trim()) {
                Alert.alert("Error", "Please enter a valid email address");
                return;
            }

            setIsPending(true);
            try {
                const res = await crossmintAuth?.sendEmailOtp(email);
                setEmailId(res.emailId);
                setOtpSent(true);
            } catch (error) {
                Alert.alert("Error", "Failed to send OTP. Please try again.");
            } finally {
                setIsPending(false);
            }
        };

        const verifyOtp = async () => {
            if (!otp.trim()) {
                Alert.alert("Error", "Please enter the OTP code");
                return;
            }

            setIsPending(true);
            try {
                const oneTimeSecret = await crossmintAuth?.confirmEmailOtp(
                    email,
                    emailId,
                    otp
                );
                await createAuthSession(oneTimeSecret);
            } catch (error) {
                Alert.alert("Error", "Invalid OTP code. Please try again.");
            } finally {
                setIsPending(false);
            }
        };

        const handleLogout = async () => {
            try {
                logout();
                // Reset login state
                setEmail("");
                setEmailId("");
                setOtpSent(false);
                setOtp("");
            } catch (error) {
                Alert.alert("Error", "Failed to logout. Please try again.");
            }
        };

        // Loading state
        if (status === "initializing") {
            return (
                <View style={{ flex: 1, justifyContent: "center", alignItems: "center" }}>
                    <ActivityIndicator size="large" />
                    <Text>Initializing...</Text>
                </View>
            );
        }

        // Login screen
        if (status === "logged-out") {
            return (
                <View style={{ flex: 1, padding: 20, justifyContent: "center" }}>
                    <Text style={{ fontSize: 24, marginBottom: 20, textAlign: "center" }}>
                        Login
                    </Text>

                    <TextInput
                        style={{ borderWidth: 1, padding: 10, marginBottom: 10 }}
                        placeholder="Enter your email"
                        value={email}
                        onChangeText={setEmail}
                        editable={!otpSent}
                    />

                    {!otpSent ? (
                        <TouchableOpacity
                            style={{
                                backgroundColor: "#05b959",
                                padding: 15,
                                alignItems: "center",
                            }}
                            onPress={sendOtp}
                            disabled={isPending}
                        >
                            {isPending ? (
                                <ActivityIndicator color="#fff" size="small" />
                                ) : (
                                <Text style={{ color: "#fff" }}>Send OTP</Text>
                            )}
                        </TouchableOpacity>
                        ) : (
                        <>
                            <TextInput
                                style={{ borderWidth: 1, padding: 10, marginBottom: 10 }}
                                placeholder="Enter OTP code"
                                value={otp}
                                onChangeText={setOtp}
                            />
                            <TouchableOpacity
                                style={{
                                    backgroundColor: "#05b959",
                                    padding: 15,
                                    alignItems: "center",
                                    marginBottom: 10,
                                }}
                                onPress={verifyOtp}
                                disabled={isPending}
                            >
                                {isPending ? (
                                    <ActivityIndicator color="#fff" size="small" />
                                ) : (
                                    <Text style={{ color: "#fff" }}>Verify OTP</Text>
                                )}
                            </TouchableOpacity>
                            <TouchableOpacity
                                style={{
                                    backgroundColor: "#ccc",
                                    padding: 15,
                                    alignItems: "center",
                                }}
                                onPress={() => setOtpSent(false)}
                                disabled={isPending}
                            >
                                <Text>Back</Text>
                            </TouchableOpacity>
                        </>
                    )}

                    <View style={{ marginVertical: 20 }}>
                        <Text style={{ textAlign: "center", marginBottom: 10 }}>OR</Text>
                        <TouchableOpacity
                            style={{
                                backgroundColor: "#4285f4",
                                padding: 15,
                                alignItems: "center",
                            }}
                            onPress={() => loginWithOAuth("google")}
                        >
                            <Text style={{ color: "#fff" }}>Sign in with Google</Text>
                        </TouchableOpacity>
                    </View>
                </View>
            );
        }

        // Main app screen (logged in)
        return (
            <View style={{ flex: 1, padding: 20 }}>
                <View
                    style={{
                        flexDirection: "row",
                        justifyContent: "space-between",
                        marginBottom: 20,
                    }}
                >
                    <Text style={{ fontSize: 20 }}>Welcome!</Text>
                    <TouchableOpacity onPress={handleLogout}>
                        <Text style={{ color: "red" }}>Logout</Text>
                    </TouchableOpacity>
                </View>

                <View style={{ marginBottom: 20 }}>
                    <Text style={{ fontSize: 16, marginBottom: 5 }}>User Info:</Text>
                    <Text>Email: {user?.email}</Text>
                    <Text>User ID: {user?.id}</Text>
                </View>

                {wallet && (
                    <View style={{ marginBottom: 20 }}>
                        <Text style={{ fontSize: 16, marginBottom: 5 }}>Wallet Info:</Text>
                        <Text>Address: {wallet.address}</Text>
                    </View>
                )}

                <View>
                    <Text style={{ fontSize: 16, marginBottom: 10 }}>App Content:</Text>
                    <Text>You are now logged in and can access your wallet!</Text>
                </View>
            </View>
        );
    }

    ```
  </Step>
</Steps>

## Launching in Production

For production, some changes are required:

1. Create a developer account on the [production console](https://www.crossmint.com/console)
2. Create a production client API key on the [API Keys](https://www.crossmint.com/console/projects/apiKeys) page with the API scopes `users.create`, `users.read`, `wallets.read`, `wallets.create`, `wallets:transactions.create`, `wallets:transactions.sign`, `wallets:balance.read`, `wallets.fund`
3. Replace your test API key with the production key
4. **Use your own authentication provider**: For production applications, Crossmint recommends using [third-party authentication](/wallets/guides/bring-your-own-auth) with providers like Auth0, Firebase, or Supabase, rather than Crossmint Auth. Configure JWT authentication in the [Crossmint Console](https://www.crossmint.com/console/projects/apiKeys) under API Keys > JWT Authentication.

## Learn More

<CardGroup>
  <Card title="Check Balances" icon="money-bill-transfer" href="/wallets/guides/check-balances">
    Check the balance of a wallet.
  </Card>

  <Card title="Transfer Tokens" icon="coins" href="/wallets/guides/transfer-tokens">
    Send tokens between wallets.
  </Card>

  <Card title="Operational Signers" icon="key" href="/wallets/guides/signers/registering-a-signer">
    Register operational signers on a wallet.
  </Card>
</CardGroup>

## Other Links

<CardGroup>
  <Card title="API Reference" icon="terminal" href="/api-reference/wallets/create-wallet">
    Deep dive into API reference docs.
  </Card>

  <Card title="Talk to an expert" icon="message" href="https://www.crossmint.com/contact/sales">
    Contact our sales team for support.
  </Card>
</CardGroup>


# REST API
Source: https://docs.crossmint.com/wallets/quickstarts/restapi

Create and manage user wallets from your backend

In this quickstart you will learn how to create wallets, check balances, and transfer tokens from your backend using the Crossmint Wallets API.

<CardGroup>
  <Snippet />

  <Card title="Wallets Quickstart" icon="github" href="https://github.com/Crossmint/wallets-quickstart">
    See a full working example.
  </Card>
</CardGroup>

## Understanding Wallet Types

Crossmint supports two types of wallets:

* **Smart Wallets**: Account abstraction wallets with configurable signers. You control who can sign transactions (external wallets, passkeys, etc.).
* **MPC Wallets**: Custodial wallets where Crossmint manages the private keys using multi-party computation. Simpler setup with no signer configuration needed. [Contact us](https://www.crossmint.com/contact/sales) for access.

<Steps>
  <Step title="Create a wallet">
    <Tabs>
      <Tab title="EVM Smart Wallet">
        Smart wallets on EVM chains (Base, Polygon, Ethereum, etc.) with configurable signers.

        <CodeGroup>
          ```bash cURL theme={null}
          curl --request POST \
              --url https://staging.crossmint.com/api/2025-06-09/wallets \
              --header 'Content-Type: application/json' \
              --header 'X-API-KEY: <x-api-key>' \
              --data '{
                  "chainType": "evm",
                  "type": "smart",
                  "config": {
                      "adminSigner": {
                          "type": "external-wallet",
                          "address": "<your-wallet-address>"
                      }
                  },
                  "owner": "email:user@example.com"
              }'
          ```

          ```javascript Node.js theme={null}
          const options = {
              method: 'POST',
              headers: {
                  'X-API-KEY': '<x-api-key>',
                  'Content-Type': 'application/json'
              },
              body: JSON.stringify({
                  chainType: "evm",
                  type: "smart",
                  config: {
                      adminSigner: {
                          type: "external-wallet",
                          address: "<your-wallet-address>"
                      }
                  },
                  owner: "email:user@example.com"
              })
          };

          fetch('https://staging.crossmint.com/api/2025-06-09/wallets', options)
              .then(response => response.json())
              .then(data => {
                  console.log('Wallet created:', data.address);
                  console.log('Full response:', data);
              })
              .catch(err => console.error(err));
          ```

          ```python Python theme={null}
          import requests

          url = "https://staging.crossmint.com/api/2025-06-09/wallets"

          payload = {
              "chainType": "evm",
              "type": "smart",
              "config": {
                  "adminSigner": {
                      "type": "external-wallet",
                      "address": "<your-wallet-address>"
                  }
              },
              "owner": "email:user@example.com"
          }
          headers = {
              "X-API-KEY": "<x-api-key>",
              "Content-Type": "application/json"
          }

          response = requests.post(url, json=payload, headers=headers)
          data = response.json()

          print(f"Wallet created: {data['address']}")
          print(f"Full response: {data}")
          ```
        </CodeGroup>

        **Key Parameters:**

        * `chainType`: The blockchain family (`evm` for Ethereum-compatible chains)
        * `type`: Wallet type (`smart` for smart wallets)
        * `config.adminSigner`: The primary signer for the wallet
          * `type: "external-wallet"`: Use an external wallet address you control
          * `type: "api-key"`: Let Crossmint manage signing via API ([contact us](https://www.crossmint.com/contact/sales) for access)
        * `owner`: User identifier in format `email:user@example.com` (optional but recommended)

        <Accordion title="Sample Response (201 Created)">
          ```json theme={null}
          {
              "chainType": "evm",
              "type": "smart",
              "address": "0xABC1234567890DEF1234567890ABCDEF12345678",
              "owner": "email:user@example.com",
              "config": {
                  "adminSigner": {
                      "type": "external-wallet",
                      "address": "<your-wallet-address>",
                      "locator": "external-wallet:<your-wallet-address>"
                  }
              },
              "createdAt": "2025-12-15T10:30:00.000Z"
          }
          ```

          **Save the** `address` **field** - you'll need it to interact with this wallet.
        </Accordion>
      </Tab>

      <Tab title="Solana Smart Wallet">
        Smart wallets on Solana with configurable signers.

        <CodeGroup>
          ```bash cURL theme={null}
          curl --request POST \
              --url https://staging.crossmint.com/api/2025-06-09/wallets \
              --header 'Content-Type: application/json' \
              --header 'X-API-KEY: <x-api-key>' \
              --data '{
                  "chainType": "solana",
                  "type": "smart",
                  "config": {
                      "adminSigner": {
                          "type": "external-wallet",
                          "address": "<your-wallet-address>"
                      }
                  },
                  "owner": "email:user@example.com"
              }'
          ```

          ```javascript Node.js theme={null}
          const options = {
              method: 'POST',
              headers: {
                  'X-API-KEY': '<x-api-key>',
                  'Content-Type': 'application/json'
              },
              body: JSON.stringify({
                  chainType: "solana",
                  type: "smart",
                  config: {
                      adminSigner: {
                          type: "external-wallet",
                          address: "<your-wallet-address>"
                      }
                  },
                  owner: "email:user@example.com"
              })
          };

          fetch('https://staging.crossmint.com/api/2025-06-09/wallets', options)
              .then(response => response.json())
              .then(data => console.log('Wallet created:', data.address))
              .catch(err => console.error(err));
          ```

          ```python Python theme={null}
          import requests

          url = "https://staging.crossmint.com/api/2025-06-09/wallets"

          payload = {
              "chainType": "solana",
              "type": "smart",
              "config": {
                  "adminSigner": {
                      "type": "external-wallet",
                      "address": "<your-wallet-address>"
                  }
              },
              "owner": "email:user@example.com"
          }
          headers = {
              "X-API-KEY": "<x-api-key>",
              "Content-Type": "application/json"
          }

          response = requests.post(url, json=payload, headers=headers)
          print(f"Wallet created: {response.json()['address']}")
          ```
        </CodeGroup>
      </Tab>

      <Tab title="EVM MPC Wallet">
        <Note>[Contact us](https://www.crossmint.com/contact/sales) for access to MPC wallets.</Note>

        Custodial wallets on EVM chains.

        <CodeGroup>
          ```bash cURL theme={null}
          curl --request POST \
              --url https://staging.crossmint.com/api/2025-06-09/wallets \
              --header 'Content-Type: application/json' \
              --header 'X-API-KEY: <x-api-key>' \
              --data '{
                  "chainType": "evm",
                  "type": "mpc",
                  "owner": "email:user@example.com"
              }'
          ```

          ```javascript Node.js theme={null}
          const options = {
              method: 'POST',
              headers: {
                  'X-API-KEY': '<x-api-key>',
                  'Content-Type': 'application/json'
              },
              body: JSON.stringify({
                  chainType: "evm",
                  type: "mpc",
                  owner: "email:user@example.com"
              })
          };

          fetch('https://staging.crossmint.com/api/2025-06-09/wallets', options)
              .then(response => response.json())
              .then(data => console.log('Wallet created:', data.address))
              .catch(err => console.error(err));
          ```

          ```python Python theme={null}
          import requests

          url = "https://staging.crossmint.com/api/2025-06-09/wallets"

          payload = {
              "chainType": "evm",
              "type": "mpc",
              "owner": "email:user@example.com"
          }
          headers = {
              "X-API-KEY": "<x-api-key>",
              "Content-Type": "application/json"
          }

          response = requests.post(url, json=payload, headers=headers)
          print(f"Wallet created: {response.json()['address']}")
          ```
        </CodeGroup>

        <Note>
          MPC wallets don't require a `config` section. Crossmint manages the private keys securely using multi-party computation.
        </Note>
      </Tab>

      <Tab title="Solana MPC Wallet">
        <Note>[Contact us](https://www.crossmint.com/contact/sales) for access to MPC wallets.</Note>

        Custodial wallets on Solana.

        <CodeGroup>
          ```bash cURL theme={null}
          curl --request POST \
              --url https://staging.crossmint.com/api/2025-06-09/wallets \
              --header 'Content-Type: application/json' \
              --header 'X-API-KEY: <x-api-key>' \
              --data '{
                  "chainType": "solana",
                  "type": "mpc",
                  "owner": "email:user@example.com"
              }'
          ```

          ```javascript Node.js theme={null}
          const options = {
              method: 'POST',
              headers: {
                  'X-API-KEY': '<x-api-key>',
                  'Content-Type': 'application/json'
              },
              body: JSON.stringify({
                  chainType: "solana",
                  type: "mpc",
                  owner: "email:user@example.com"
              })
          };

          fetch('https://staging.crossmint.com/api/2025-06-09/wallets', options)
              .then(response => response.json())
              .then(data => console.log('Wallet created:', data.address))
              .catch(err => console.error(err));
          ```

          ```python Python theme={null}
          import requests

          url = "https://staging.crossmint.com/api/2025-06-09/wallets"

          payload = {
              "chainType": "solana",
              "type": "mpc",
              "owner": "email:user@example.com"
          }
          headers = {
              "X-API-KEY": "<x-api-key>",
              "Content-Type": "application/json"
          }

          response = requests.post(url, json=payload, headers=headers)
          print(f"Wallet created: {response.json()['address']}")
          ```
        </CodeGroup>
      </Tab>
    </Tabs>

    See the [API reference](/api-reference/wallets/create-wallet) for all available parameters.
  </Step>

  <Step title="Retrieve a wallet">
    Retrieve wallet information using a <Tooltip>wallet locator</Tooltip>. This is useful when you need to get wallet details without storing the wallet address.

    **Wallet Locator Formats:**

    * By address: `0xABC...` or `GbA2NZ...`
    * By email: `email:user@example.com:evm:smart`
    * By user ID: `userId:507f1f77bcf86cd799439011:solana:mpc`

    <CodeGroup>
      ```bash cURL theme={null}
      curl --request GET \
          --url https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:evm:smart \
          --header 'X-API-KEY: <x-api-key>'
      ```

      ```javascript Node.js theme={null}
      const walletLocator = 'email:user@example.com:evm:smart';
      const options = {
          method: 'GET',
          headers: {'X-API-KEY': '<x-api-key>'}
      };

      fetch(`https://staging.crossmint.com/api/2025-06-09/wallets/${walletLocator}`, options)
          .then(response => response.json())
          .then(data => {
              console.log('Wallet address:', data.address);
              console.log('Owner:', data.owner);
          })
          .catch(err => console.error(err));
      ```

      ```python Python theme={null}
      import requests

      wallet_locator = "email:user@example.com:evm:smart"
      url = f"https://staging.crossmint.com/api/2025-06-09/wallets/{wallet_locator}"

      headers = {"X-API-KEY": "<x-api-key>"}

      response = requests.get(url, headers=headers)
      data = response.json()

      print(f"Wallet address: {data['address']}")
      print(f"Owner: {data['owner']}")
      ```
    </CodeGroup>

    <Accordion title="Sample Response (200 OK)">
      ```json theme={null}
      {
          "chainType": "evm",
          "type": "smart",
          "address": "0xABC1234567890DEF1234567890ABCDEF12345678",
          "owner": "email:user@example.com",
          "config": {
              "adminSigner": {
                  "type": "external-wallet",
                  "address": "<your-wallet-address>",
                  "locator": "external-wallet:<your-wallet-address>"
              }
          },
          "createdAt": "2025-12-15T10:30:00.000Z"
      }
      ```
    </Accordion>

    <Accordion title="More Wallet Locator Examples">
      * `0x1234567890123456789012345678901234567890` - Direct address
      * `email:user@example.com:evm:smart` - Email + wallet type
      * `userId:507f1f77bcf86cd799439011:solana:mpc` - User ID + wallet type
      * `phoneNumber:+12125551234:evm:smart` - Phone + wallet type
      * `twitter:johndoe:evm:smart` or `x:@johndoe:evm:smart` - Twitter/X + wallet type
      * `me:evm:smart` - Authenticated user (client-side only)
    </Accordion>
  </Step>

  <Step title="Check wallet balance">
    Check token balances for a wallet. You can query multiple tokens at once by providing a comma-separated list.

    <CodeGroup>
      ```bash cURL theme={null}
      curl --request GET \
          --url 'https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:evm/balances?tokens=usdc,eth' \
          --header 'X-API-KEY: <x-api-key>'
      ```

      ```javascript Node.js theme={null}
      const walletLocator = 'email:user@example.com:evm';
      const tokens = 'usdc,eth';
      const url = `https://staging.crossmint.com/api/2025-06-09/wallets/${walletLocator}/balances?tokens=${tokens}`;

      const options = {
          method: 'GET',
          headers: {'X-API-KEY': '<x-api-key>'}
      };

      fetch(url, options)
          .then(response => response.json())
          .then(data => {
              console.log('Native token balance:', data.nativeToken);
              console.log('Token balances:', data.tokens);
          })
          .catch(err => console.error(err));
      ```

      ```python Python theme={null}
      import requests

      wallet_locator = "email:user@example.com:evm"
      url = f"https://staging.crossmint.com/api/2025-06-09/wallets/{wallet_locator}/balances"

      params = {"tokens": "usdc,eth"}
      headers = {"X-API-KEY": "<x-api-key>"}

      response = requests.get(url, params=params, headers=headers)
      data = response.json()

      print(f"Native token: {data['nativeToken']}")
      print(f"Token balances: {data['tokens']}")
      ```
    </CodeGroup>

    **Query Parameters:**

    * `tokens` (required): Comma-separated list of token symbols (e.g., `usdc,eth,usdxm`)
    * `chains` (optional): Filter by specific chains when using multi-chain wallets

    <Accordion title="Sample Response (200 OK)">
      ```json theme={null}
      {
          "nativeToken": {
              "symbol": "ETH",
              "decimals": 18,
              "balance": "1500000000000000000",
              "balanceUSD": "4500.00"
          },
          "tokens": [
              {
                  "symbol": "USDC",
                  "decimals": 6,
                  "balance": "1000000000",
                  "balanceUSD": "1000.00",
                  "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
              }
          ]
      }
      ```

      Balances are returned as strings in the token's smallest unit (wei for ETH, lamports for SOL, etc.).
    </Accordion>
  </Step>

  <Step title="Transfer tokens">
    Send tokens from a wallet to a recipient. Smart wallets handle gas fees automatically through Crossmint's paymaster.

    **Token Locator Format**: `{chain}:{symbol}` or `{chain}:{contractAddress}` (e.g., `base-sepolia:eth`, `polygon:usdc`, `base-sepolia:0x123...`)

    <CodeGroup>
      ```bash cURL theme={null}
      curl --request POST \
          --url 'https://staging.crossmint.com/api/2025-06-09/wallets/email:user@example.com:evm/tokens/base-sepolia:eth/transfers' \
          --header 'Content-Type: application/json' \
          --header 'X-API-KEY: <x-api-key>' \
          --data '{
              "recipient": "<recipient-wallet-address>",
              "amount": "0.001"
          }'
      ```

      ```javascript Node.js theme={null}
      const walletLocator = 'email:user@example.com:evm';
      const tokenLocator = 'base-sepolia:eth';
      const url = `https://staging.crossmint.com/api/2025-06-09/wallets/${walletLocator}/tokens/${tokenLocator}/transfers`;

      const options = {
          method: 'POST',
          headers: {
              'X-API-KEY': '<x-api-key>',
              'Content-Type': 'application/json'
          },
          body: JSON.stringify({
              recipient: "<recipient-wallet-address>",
              amount: "0.001"
          })
      };

      fetch(url, options)
          .then(response => response.json())
          .then(data => {
              console.log('Transaction ID:', data.id);
              console.log('Status:', data.status);
          })
          .catch(err => console.error(err));
      ```

      ```python Python theme={null}
      import requests

      wallet_locator = "email:user@example.com:evm"
      token_locator = "base-sepolia:eth"
      url = f"https://staging.crossmint.com/api/2025-06-09/wallets/{wallet_locator}/tokens/{token_locator}/transfers"

      payload = {
          "recipient": "<recipient-wallet-address>",
          "amount": "0.001"
      }
      headers = {
          "X-API-KEY": "<x-api-key>",
          "Content-Type": "application/json"
      }

      response = requests.post(url, json=payload, headers=headers)
      data = response.json()

      print(f"Transaction ID: {data['id']}")
      print(f"Status: {data['status']}")
      ```
    </CodeGroup>

    **Request Parameters:**

    * `recipient` (required): Destination address or AddressLocator. Supports wallet addresses (`0x...`) or identity-based locators like `email:user@example.com`, `phoneNumber:+12125551234`, `userId:abc123`
    * `amount` (required): Amount to transfer in decimal format (e.g., `"0.001"` for 0.001 ETH)
    * `signer` (optional): Signer locator if using operational signers (defaults to recovery signer)

    <Accordion title="Sample Response (201 Created)">
      ```json theme={null}
      {
          "id": "cm47h2m8e0003vn0zf8yz1234",
          "chainType": "evm",
          "walletType": "smart",
          "status": "pending",
          "params": {
              "calls": [...],
              "chain": "base-sepolia",
              "signer": {
                  "type": "evm-keypair",
                  "address": "0x..."
              }
          },
          "onChain": {
              "userOperationHash": "0x...",
              "txId": null
          },
          "sendParams": {
              "token": "base-sepolia:eth",
              "recipient": "<recipient-wallet-address>",
              "amount": "0.001"
          },
          "createdAt": "2025-12-15T10:35:00.000Z"
      }
      ```

      **Transaction Status Values:**

      * `awaiting-approval` - Transaction created, waiting for signer approval
      * `pending` - Transaction submitted to the blockchain
      * `success` - Transaction confirmed onchain
      * `failed` - Transaction failed

      Poll the transaction status using the transaction ID, or set up [webhooks](/wallets/guides/webhooks) for real-time updates.
    </Accordion>

    <Accordion title="Common Token Locators">
      **EVM Chains:**

      * `base-sepolia:eth` - ETH on Base Sepolia testnet
      * `base-sepolia:usdc` - USDC on Base Sepolia
      * `polygon:usdc` - USDC on Polygon mainnet
      * `ethereum:usdt` - USDT on Ethereum mainnet

      **Solana:**

      * `solana:sol` - Native SOL token
      * `solana:usdc` - USDC on Solana

      For contract tokens, use the contract address: `base-sepolia:0x123...`
    </Accordion>
  </Step>
</Steps>

### Using Idempotency Keys

Prevent duplicate wallet creation by using idempotency keys:

```bash theme={null}
curl --request POST \
    --url https://staging.crossmint.com/api/2025-06-09/wallets \
    --header 'Content-Type: application/json' \
    --header 'X-API-KEY: <x-api-key>' \
    --header 'x-idempotency-key: unique-operation-id-123' \
    --data '{
        "chainType": "evm",
        "type": "mpc",
        "owner": "email:user@example.com"
    }'
```

If you retry with the same idempotency key, you'll receive the same wallet without creating a duplicate.

## Launching in Production

Ready to go live? Here's what you need to do:

1. **Create a production account** at [www.crossmint.com/console](https://www.crossmint.com/console)
2. **Create a production API key** with the required scopes:
   * `wallets.create`, `wallets.read`, `wallets:balance.read`, `wallets:transactions.create`
3. **Update your API endpoint** from `staging.crossmint.com` to `www.crossmint.com`
4. **Update your API key** in your code to use the production key

<Warning>
  Never expose your server-side API keys in client-side code or public repositories. Store them securely in environment variables or a secrets manager.
</Warning>

## Learn More

<CardGroup>
  <Card title="Check Balances" icon="money-bill-transfer" href="/wallets/guides/check-balances">
    Check the balance of a wallet.
  </Card>

  <Card title="Transfer Tokens" icon="coins" href="/wallets/guides/transfer-tokens">
    Send tokens between wallets.
  </Card>

  <Card title="Operational Signers" icon="key" href="/wallets/guides/signers/registering-a-signer">
    Register operational signers on a wallet.
  </Card>
</CardGroup>


# Swift
Source: https://docs.crossmint.com/wallets/quickstarts/swift

Create user wallets from your iOS app in under 5 minutes

This quickstart integrates the Crossmint Swift SDK into an iOS app to create a non-custodial wallet for a user, fund it with testnet USDC on Base Sepolia, and send USDC to another wallet.

<CardGroup>
  <Snippet />

  <Card title="iOS Demo App" icon="github" href="https://github.com/Crossmint/crossmint-swift-sdk/tree/main/Examples/SmartWalletsDemo">
    See a full working example with a repository to clone.
  </Card>
</CardGroup>

<Steps>
  <Step title="Install the SDK">
    Add the Crossmint Swift SDK to your project using Swift Package Manager.

    In Xcode, go to **File > Add Package Dependencies** and enter the repository URL:

    ```text theme={null}
    https://github.com/Crossmint/crossmint-swift-sdk
    ```

    Select the `CrossmintClientSDK` product to add to your target.

    ### Requirements

    * iOS 15.0+
    * Xcode 16.0+
    * Swift 5.9+
  </Step>

  <Step title="Configure your API key">
    The Crossmint SDK requires a client API key for authentication.
    [Get your client API key](/introduction/platform/api-keys/client-side) using the Crossmint Console.

    Create a file to store your configuration:

    ```swift CrossmintConfig.swift theme={null}
    import CrossmintAuth
    import CrossmintClient


    let crossmintApiKey = "<YOUR_API_KEY>"
    lazy var crossmintAuthManager: CrossmintAuthManager = {
        do {
            return try CrossmintAuthManager(apiKey: crossmintApiKey)
        } catch {
            fatalError("Invalid Crossmint configuration: \(error)")
        }
    }()
    ```

    <Note>
      The environment (staging vs production) is automatically determined by your API key. Staging keys start with `ck_staging_`, production keys with `ck_production_`.
    </Note>
  </Step>

  <Step title="Initialize the Crossmint SDK">
    Initialize the SDK in your app's entry point and add the non-custodial signer view modifier. This example uses [Crossmint Auth](/authentication/introduction) but you can use [any authentication provider of your choice](/wallets/guides/bring-your-own-auth).

    ```swift YourApp.swift theme={null}
    import SwiftUI
    import CrossmintClient

    @main
    struct YourApp: App {
        var body: some Scene {
            WindowGroup {
                ContentView()
                    .crossmintNonCustodialSigner(
                        CrossmintSDK.shared(
                            apiKey: crossmintApiKey,
                            authManager: crossmintAuthManager
                        )
                    )
            }
        }
    }
    ```

    The `.crossmintNonCustodialSigner()` modifier is required for transaction signing. It embeds a hidden web view that securely manages the signing process.

    ### Access SDK instances

    Inside your views, access SDK functionality using `CrossmintSDK.shared`:

    ```swift theme={null}
    import CrossmintClient

    let sdk = CrossmintSDK.shared
    let authManager = sdk.authManager
    let wallets = sdk.crossmintWallets
    ```
  </Step>

  <Step title="Authenticate users">
    Actions within the SDK are user-based, so first you need to authenticate a user.
    Choose your authentication method:

    <Tabs>
      <Tab title="Crossmint Auth (OTP)">
        Use Crossmint's built-in OTP authentication for easy, email-based login.

        <Steps>
          <Step title="Send OTP to user's email">
            ```swift theme={null}
            import CrossmintClient

            let email = "user@example.com"

            do {
                let status = try await crossmintAuthManager.otpAuthentication(
                    email: email,
                    code: nil,
                    forceRefresh: false
                )

                if case let .emailSent(_, emailId) = status {
                    // OTP sent to email, now display an input for the OTP
                    // Store emailId for the verification step
                }
            } catch let error as AuthManagerError {
                // Handle error: error.errorMessage
            }
            ```
          </Step>

          <Step title="Verify the OTP sent to the user's email">
            ```swift theme={null}
            import CrossmintClient

            let otpCode = "123456" // Code entered by user

            do {
                let status = try await crossmintAuthManager.otpAuthentication(
                    email: email,
                    code: otpCode,
                    forceRefresh: false
                )

                if case .authenticated = status {
                    // User is authenticated, proceed to create wallet
                }
            } catch let error as AuthManagerError {
                // Handle error: error.errorMessage
            }
            ```
          </Step>
        </Steps>

        <Note>
          See the [iOS Demo App](https://github.com/Crossmint/crossmint-swift-sdk/tree/main/Examples/SmartWalletsDemo) repository for a complete UI implementation example with SwiftUI views.
        </Note>
      </Tab>

      <Tab title="Third-Party Auth (Prod)">
        If you have an existing auth provider (Auth0, Firebase, Supabase, etc.), authenticate users with your provider and pass the JWT to Crossmint.

        ```swift theme={null}
        import CrossmintClient

        // After user authenticates with your provider, get their JWT
        let authManager = CrossmintSDK.shared.authManager

        do {
            try await authManager.authenticateWithToken(
                jwt: yourProviderJWT,
                refreshToken: yourProviderRefreshToken // optional
            )
            // User authenticated with Crossmint
        } catch {
            // Handle error
        }
        ```

        <Note>
          Configure JWT authentication in the [Crossmint Console](https://console.crossmint.com) under API Keys > JWT Authentication before using third-party auth.
        </Note>
      </Tab>
    </Tabs>
  </Step>

  <Step title="Create a wallet">
    After authentication, create the user's wallet. This example uses Base Sepolia (Base testnet) but you can choose any [supported chain](/introduction/supported-chains).

    ```swift theme={null}
    import CrossmintClient

    let sdk = CrossmintSDK.shared

    do {
        guard let email = await crossmintAuthManager.email else {
            // User not authenticated
            return
        }

        let wallet = try await sdk.crossmintWallets.getOrCreateWallet(
            chain: .baseSepolia,
            signer: .email(email)
        )

        // Wallet is ready to use!
        print("Wallet address: \(wallet.address)")
    } catch let error as WalletError {
        // Handle error: error.errorMessage
    }
    ```
  </Step>

  <Step title="Check wallet balance">
    Before sending tokens, check the wallet balance:

    ```swift theme={null}
    import CrossmintClient
    import Wallet
    import CrossmintCommonTypes

    // Convert to EVMWallet for EVM-specific operations
    guard let evmWallet = try? EVMWallet.from(wallet: wallet) else {
        return
    }

    do {
        let balance = try await evmWallet.balances([.eth, .usdc, .usdxm])

        // Access native token balance
        print("ETH: \(balance.nativeToken.amount)")

        // Access USDC balance
        print("USDC: \(balance.usdc.amount)")

        // Access other tokens
        for token in balance.tokens {
            print("\(token.token.name): \(token.amount)")
        }
    } catch let error as WalletError {
        // Handle error: error.errorMessage
    }
    ```
  </Step>

  <Step title="Fund the wallet">
    Before sending USDC, you need to get some into the wallet.

    **Option 1: Use the staging fund method (staging only)**

    ```swift theme={null}
    do {
        try await evmWallet.fund(token: .usdxm, amount: 10)
    } catch {
        // Handle error
    }
    ```

    **Option 2: Use the USDC Faucet**

    Get the wallet address and use the [USDC Faucet](https://faucet.circle.com/):

    ```swift theme={null}
    let walletAddress = wallet.address
    print("Fund this address: \(walletAddress)")
    ```

    Navigate to the faucet, select **Base Sepolia**, and enter the wallet address.

    <img alt="Circle faucet - Base Sepolia selected" />
  </Step>

  <Step title="Send USDC">
    Send USDC to another wallet using the `wallet.send` function:

    ```swift theme={null}
    import CrossmintClient
    import Wallet
    import CrossmintCommonTypes

    let recipientAddress = "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb"

    do {
        guard let evmAddress = try? EVMAddress(address: recipientAddress) else {
            // Invalid address
            return
        }

        let result = try await wallet.send(
            token: .usdc,
            recipient: .address(.evm(.baseSepolia, evmAddress)),
            amount: "0.01"
        )

        // Transaction successful
        print("Transaction completed")
    } catch let error as TransactionError {
        switch error {
        case .userCancelled:
            // User cancelled the transaction
            break
        default:
            // Handle error: error.errorMessage
            break
        }
    }
    ```

    The first time a wallet sends a transaction on a device, an OTP verification is required. The SDK automatically handles this by presenting an OTP input view.

    To handle the OTP flow, observe the `isOTPRequired` publisher in your view:

    ```swift theme={null}
    import SwiftUI
    import CrossmintClient

    struct ContentView: View {
        @State private var showOTPView = false

        var body: some View {
            YourMainView()
                .onReceive(CrossmintSDK.shared.isOTPRequired) { required in
                    showOTPView = required
                }
                .sheet(isPresented: $showOTPView) {
                    OTPValidatorView()
                }
        }
    }
    ```

    Following transactions sent from the same device do not need OTP verification.
    And that is it! You just created a non-custodial wallet for your user and made a USDC transaction on Base Sepolia.
  </Step>
</Steps>

## Launching in Production

For production, the steps are almost identical, but some changes are required:

1. Create a developer account on the [production console](https://www.crossmint.com/console)
2. Create a production client API key on the [API Keys](https://www.crossmint.com/console/projects/apiKeys) page with the API scopes `users.create`, `users.read`, `wallets.read`, `wallets.create`, `wallets:transactions.create`, `wallets:transactions.sign`, `wallets:balance.read`, `wallets.fund`
3. Update your configuration with the production API key
4. **Use your own authentication provider**: For production applications, Crossmint recommends using [third-party authentication](/wallets/guides/bring-your-own-auth) with providers like Auth0, Firebase, or Supabase, rather than Crossmint Auth (OTP). Configure JWT authentication in the [Crossmint Console](https://www.crossmint.com/console/projects/apiKeys) under API Keys > JWT Authentication

## Learn More

<CardGroup>
  <Card title="Check Balances" icon="money-bill-transfer" href="/wallets/guides/check-balances">
    Check the balance of a wallet.
  </Card>

  <Card title="Transfer Tokens" icon="coins" href="/wallets/guides/transfer-tokens">
    Send tokens between wallets.
  </Card>

  <Card title="Operational Signers" icon="key" href="/wallets/guides/signers/registering-a-signer">
    Register operational signers on a wallet.
  </Card>
</CardGroup>

## Other Links

<CardGroup>
  <Card title="Swift SDK Reference" icon="https://mintcdn.com/crossmint/vkEd28d04Cga5Exy/images/icons/swift.svg?fit=max&auto=format&n=vkEd28d04Cga5Exy&q=85&s=8d0b63b1f64c6f9066a26a28c769040a" href="/sdk-reference/wallets/swift/classes/wallet">
    Deep dive into Swift SDK reference docs.
  </Card>

  <Card title="Talk to an expert" icon="message" href="https://www.crossmint.com/contact/sales">
    Contact the Crossmint sales team for support.
  </Card>
</CardGroup>


# Why Smart Contract Wallets
Source: https://docs.crossmint.com/wallets/why-smart-wallets

Why Crossmint chose smart contract wallets as the foundation for its wallet infrastructure.

We believe wallets are becoming a foundational primitive for the entire economy — not just for crypto users, but for every person, company, AI agent, and connected device that needs to hold value or authorize payments. At that scale, wallet infrastructure must be extremely cheap to operate, flexible enough to support any custody model, and publicly auditable so that security is a matter of proof, not trust.

## The Problem with Off-Chain Key Storage

Most wallet infrastructure today stores keys off-chain, inside proprietary enclaves or distributed across MPC networks. This means:

* **Provider dependency**: Wallets depend on a specific provider's infrastructure to function.
* **Latency overhead**: Key reconstruction adds latency to every signature.
* **Painful migration**: Moving to a new provider means exporting keys and creating new wallet addresses.

These are reasonable trade-offs for certain use cases — but they are not the right foundation for millions of wallets transacting continuously.

## A Different Approach

Smart contract wallets take a different approach. The wallet is a program deployed on a public blockchain — it does not live in anyone's private infrastructure. The signer is completely separate and can be anything: a passkey on a user's phone, an AWS KMS key in your cloud, or a recovery credential.

The key stays whole. No splitting, no reconstruction, no added latency.

* **Security** is not a promise — it is code you can read.
* **Recovery** is not a key-share coordination problem — it is an onchain signer rotation.
* **Migration** is not an export — it is a signer swap.

## Why We Chose This Architecture

We chose this architecture because it is the only one that scales to the future we are building toward: **wallets as ubiquitous and permanent as email addresses, but programmable, auditable, and owned by no one except the people and systems that use them.**

<CardGroup>
  <Card title="Architecture" icon="layer-group" href="/wallets/architecture">
    See how the dual-layer architecture works in practice.
  </Card>

  <Card title="Wallet Signers" icon="key" href="/wallets/concepts/wallet-signers">
    Explore the signer types that plug into this architecture.
  </Card>
</CardGroup>