Pay with USDC

​

Introduction

This guide will show you how to quickly buy or sell any tokenized asset (NFT) with USDC, using Crossmint’s headless APIs.

​

Prerequisites

​

From Crossmint

1. Create a developer account in the Staging Console.
2. Create a new collection or import yours into the console, and have your collectionId ready.
   • Make sure you follow the maximum prices for collections set in staging outlined here.
3. Create a server-side API key with the orders.create, orders.update, and orders.read scopes enabled. More info on creating API keys here.

​

External prerequisites

​

Create an order and pay with USDC

git clone https://github.com/crossmint/headless-python-payusdc.git

cd headless-python-payusdc
python3 -m venv .venv
source .venv/bin/activate

pip install -r requirements.txt

CROSSMINT_API_KEY="<your-api-key>"
COLLECTION_ID="<your-collection-id>"
PAYER_ADDRESS="<your-payer-address>"
EMAIL_ADDRESS="<your-email-address>"

python src/index.py

​

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.

​

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:

def create_order():
    # Define the order data structure
    order_data = {
        "recipient": {
            "email": os.environ.get("EMAIL_ADDRESS")  # Email where the NFT will be delivered
        },
        "locale": "en-US",  # Language/region setting
        "payment": {
            "method": "base-sepolia",  # Testnet network for USDC payments
            "currency": "usdc",            # Payment currency
            "payerAddress": os.environ.get("PAYER_ADDRESS")  # Wallet address paying USDC
        },
        "lineItems": {
            "collectionLocator": f"crossmint:{os.environ.get('COLLECTION_ID')}"  # Tokenized collection identifier
        }
    }

​

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

    response = requests.post(
        f"{base_url}/orders",
        headers={
            "Content-Type": "application/json",
            "x-api-key": os.environ.get("CROSSMINT_API_KEY")  # Your API key for authentication
        },
        json=order_data
    )

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

    validate(response.ok, f"Failed to create order: {response.reason}")
    json_response = response.json()
    return {
        "clientSecret": json_response["clientSecret"],  # Used for order authentication
        "order": json_response["order"]                 # Contains 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.

​

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:

def get_order(order_id: str, client_secret: str) -> Dict[str, Any]:
    try:
        response = requests.get(
            f"{base_url}/orders/{order_id}",  # Endpoint for specific order
            headers={
                'Content-Type': 'application/json',
                'x-api-key': os.environ.get('CROSSMINT_API_KEY'),  # API authentication
                'Authorization': client_secret                      # Order-specific authentication
            }
        )

        validate(response.ok, f"Failed to get order: {response.reason}")
        return response.json()
    except Exception as error:
        raise error

​

Get order function explained

• Takes order_id and client_secret as parameters
• Makes a GET request to fetch the current state of the order
• Uses both API key and client secret for authentication
• Returns the order details as JSON

def poll_order(order_id: str, client_secret: str) -> Dict[str, Any]:
    while True:
        try:
            order = get_order(order_id, client_secret)
            print(f'Current order status: [bold yellow]{order["phase"]}[/bold yellow]')

            if order['phase'] == 'completed':
                return order
            time.sleep(3)  # Wait 3 seconds before next check

        except Exception as error:
            raise error

​

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.