How do I get my CryptAPI API key?

After creating and verifying your CryptAPI account, log in to your dashboard. Navigate to the 'Settings' or 'API Keys' section to generate and retrieve your unique API key. Keep this key secure.

What is the purpose of the callback URL in CryptAPI?

The callback URL is an endpoint on your server that CryptAPI uses to send real-time notifications about the status of a cryptocurrency transaction. This allows your application to update its records when a payment is received or confirmed.

Which cryptocurrencies does CryptAPI support?

CryptAPI supports a range of cryptocurrencies. The specific list can be found in their official documentation, but common ones like Bitcoin (BTC) and Ethereum (ETH) are generally included. Always check the API reference for the most current list.

Can I test CryptAPI without real cryptocurrency?

CryptAPI typically offers testnet support for certain cryptocurrencies, allowing developers to simulate transactions without using real funds. Check the CryptAPI documentation for details on how to use testnet endpoints or sandbox environments.

What should I do if my API request returns an error?

First, verify your API key and ensure all required parameters are correctly provided in your request. Check the CryptAPI API reference for the specific endpoint's requirements. If the issue persists, review the error message for clues or consult CryptAPI's support resources.

Are there any volume discounts for CryptAPI transaction fees?

Yes, CryptAPI offers volume discounts on its transaction fees, which start at 0.5%. Details on the tiered pricing structure and how discounts are applied can be found on their official pricing page.

What security measures should I take when integrating CryptAPI?

Key security measures include storing your API key securely (e.g., using environment variables), validating callback requests to ensure they originate from CryptAPI, and implementing robust error handling and logging. Always follow general API security best practices.

CryptAPI Getting Started: Quick Integration Guide (2026)

Getting started overview

Integrating CryptAPI into an application involves a series of steps, starting with account registration and API key generation. The process is designed to enable developers to quickly begin accepting cryptocurrency payments, generating cryptocurrency wallets, and managing fiat settlements. CryptAPI supports various cryptocurrencies and provides SDKs for common programming languages to streamline the development process. The core functionality revolves around creating payment addresses, monitoring transactions, and processing callbacks to update application states upon successful payments.

This guide provides a structured approach to setting up CryptAPI, obtaining necessary credentials, and executing an initial API request. It covers the essential steps required to go from a new account to a functional cryptocurrency payment integration.

Quick reference steps

Step	What to do	Where
1	Create a CryptAPI account	CryptAPI registration page
2	Generate API keys	CryptAPI dashboard settings
3	Install an SDK (optional but recommended)	CryptAPI SDKs and Libraries documentation
4	Construct your first API request	CryptAPI Create Address API reference
5	Handle API response and callbacks	CryptAPI Callbacks and Webhooks guide

Create an account and get keys

Before making any API requests, a CryptAPI account is required. This account serves as the central hub for managing API keys, viewing transaction history, and configuring payment settings.

Account registration

Navigate to the CryptAPI registration page.
Provide the required information, typically an email address and a secure password.
Verify your email address by following the instructions sent to your inbox. This step is crucial for activating your account and ensuring secure access.

Generating API keys

Upon successful registration and login, you will need to generate API keys. These keys authenticate your application's requests to the CryptAPI platform and ensure that only authorized calls are processed.

Log in to your CryptAPI dashboard.
Locate the 'Settings' or 'API Keys' section, typically found in the user profile or account management area.
Follow the prompts to generate a new API key. CryptAPI may provide a public key and a secret key, or a single API key depending on their authentication model. Ensure you record this key securely, as it may only be displayed once.
It is recommended to use environment variables or a secure configuration management system to store your API key rather than hardcoding it directly into your application's source code. This practice aligns with security best practices for handling sensitive credentials, as detailed in the Google Cloud API Key best practices.

Your first request

This section outlines how to make a basic API request to CryptAPI to generate a new payment address for a specific cryptocurrency. This is a fundamental step in accepting cryptocurrency payments.

Choosing an SDK or direct API call

CryptAPI offers SDKs for several programming languages, including PHP, Python, and Node.js. Using an SDK can simplify the integration process by handling authentication, request formatting, and response parsing. Alternatively, you can make direct HTTP requests to the API endpoints.

For this example, we will demonstrate a direct API call using a common command-line tool, curl, and then provide an example using the Python SDK.

API endpoint for creating an address

The primary endpoint for generating a new payment address is typically structured as follows:

https://api.cryptapi.io/{COIN}/create/?address={ADDRESS}&callback={CALLBACK_URL}&api_key={YOUR_API_KEY}

{COIN}: The cryptocurrency ticker (e.g., btc for Bitcoin, eth for Ethereum).
{ADDRESS}: Your wallet address where funds will be forwarded after processing.
{CALLBACK_URL}: A URL on your server that CryptAPI will call to notify you of transaction status updates.
{YOUR_API_KEY}: Your generated CryptAPI API key.

Example direct curl request

To generate a Bitcoin payment address:

curl -X GET \
  "https://api.cryptapi.io/btc/create/?address=YOUR_WALLET_ADDRESS&callback=https://yourdomain.com/cryptapi-callback&api_key=YOUR_API_KEY"

Replace YOUR_WALLET_ADDRESS with your actual Bitcoin wallet address, https://yourdomain.com/cryptapi-callback with your callback URL, and YOUR_API_KEY with your CryptAPI API key.

Example Python SDK request

First, install the CryptAPI Python SDK:

pip install cryptapi

Then, use the following Python code:

from cryptapi import CryptAPI

# Replace with your actual API key and wallet address
API_KEY = "YOUR_API_KEY"
YOUR_WALLET_ADDRESS = "YOUR_WALLET_ADDRESS"
CALLBACK_URL = "https://yourdomain.com/cryptapi-callback"

cryptapi_client = CryptAPI(API_KEY)

try:
    response = cryptapi_client.create_address(
        coin='btc',
        address=YOUR_WALLET_ADDRESS,
        callback=CALLBACK_URL
    )
    print("Generated Address:", response['address'])
    print("Payment ID:", response['payment_id'])
except Exception as e:
    print("Error creating address:", e)

This code initializes the CryptAPI client with your API key and then calls the create_address method to generate a new Bitcoin address. The response will contain the generated address and a payment ID, which can be used to track the transaction.

Understanding the response

A successful response from the create endpoint will typically return a JSON object similar to this:

{
  "status": "success",
  "address": "bc1q...",
  "address_in": "bc1q...",
  "callback_url": "https://yourdomain.com/cryptapi-callback",
  "payment_id": "61a...",
  "coin": "btc",
  "network": "mainnet",
  "pending": 0,
  "confirmations": 0,
  "amount": 0,
  "txid": null,
  "qrcode_url": "https://cryptapi.io/qrcode/btc/bc1q..."
}

The address field is the unique cryptocurrency address generated for the payment. The payment_id is an internal identifier for this transaction, and the qrcode_url provides a convenient way for users to scan and pay.

Common next steps

After successfully generating a payment address, the next steps typically involve integrating the payment flow into your application and robustly handling transaction updates.

Implementing callback handling

CryptAPI relies on webhooks (callbacks) to notify your application about the status of a cryptocurrency transaction. It is crucial to set up an endpoint on your server to receive and process these callbacks. The CryptAPI documentation on callbacks provides detailed information on the parameters sent in a callback request.

A typical callback implementation involves:

Receiving a POST request from CryptAPI to your specified callback URL.
Validating the callback signature or IP address to ensure it originates from CryptAPI and has not been tampered with. This is a critical security measure, similar to webhook security practices recommended by Stripe's webhook security guide.
Parsing the callback data, which includes transaction status, amount, and other relevant details.
Updating your application's database or state to reflect the payment status (e.g., 'pending', 'confirmed', 'paid').

Displaying payment information

For your users, you will need to display the generated payment address, the required amount, and potentially a QR code for easy scanning. The qrcode_url from the create API response can be used directly to display a QR code.

Error handling and retries

Implement robust error handling for API requests and callback processing. This includes handling network issues, invalid API keys, and unexpected responses. Consider implementing retry mechanisms for transient errors with an exponential backoff strategy.

Exploring other API features

Once the basic payment flow is established, you can explore other CryptAPI features such as:

Fiat settlement integration: Converting received cryptocurrency to fiat currency.
Transaction history: Retrieving past transaction details.
Exchange rates: Obtaining real-time cryptocurrency exchange rates.

Refer to the CryptAPI API reference for a comprehensive list of available endpoints and their functionalities.

Troubleshooting the first call

When making your initial CryptAPI call, you might encounter issues. Here are common problems and their solutions:

Invalid API Key

Symptom: API returns an 'Invalid API Key' error or similar authentication failure.
Solution: Double-check that the API key provided in your request exactly matches the one generated in your CryptAPI dashboard. Ensure no leading or trailing spaces are included. If unsure, generate a new API key and update your code.

Incorrect Callback URL

Symptom: Payments are received, but your application does not receive callback notifications.
Solution: Verify that the callback URL parameter in your create_address request is a publicly accessible URL on your server and that it is correctly configured to receive POST requests. Ensure there are no firewall rules blocking incoming connections to this URL. Test the URL independently to confirm it's reachable.

Missing or Invalid Parameters

Symptom: API returns errors indicating missing required parameters or invalid values.
Solution: Review the CryptAPI Create Address API reference to ensure all mandatory parameters (e.g., coin, address, callback, api_key) are included and correctly formatted. Pay attention to data types and expected formats for each parameter.

Network Connectivity Issues

Symptom: Requests time out or fail to connect to CryptAPI's servers.
Solution: Check your internet connection. If running locally, ensure no local firewall or proxy is blocking outbound connections to api.cryptapi.io. If deploying to a server, verify network configurations and security groups allow outbound HTTPS traffic.

Cryptocurrency Address Errors

Symptom: The address parameter (your forwarding wallet) is rejected as invalid.
Solution: Confirm that the wallet address provided for the specified coin is valid and belongs to the correct network (e.g., a Bitcoin mainnet address for 'btc'). Using an address for a different cryptocurrency or network will result in an error or loss of funds.

SDK-Specific Errors

Symptom: Errors originating from the CryptAPI SDK you are using.
Solution: Refer to the specific SDK documentation for troubleshooting. Ensure the SDK is correctly installed and imported, and that you are using the methods as intended by the library. Update the SDK to the latest version to benefit from bug fixes and improvements.