ChangeNOW API Integration
Imagine a wallet with 50,000 users, each wanting to exchange ETH for USDT without registration. A direct integration via CEX requires KYC and takes weeks. According to ChangeNOW API documentation, this crypto exchange API is a ready non-custodial exchanger with 850+ coins, a fixed rate, and exchange time around 4 minutes. We have integrated this API for fifty projects — from small wallets to large exchangers with turnovers of tens of BTC per day. In this article, we break down the process in detail: from registering a ChangeNOW API key to configuring webhook notifications and error handling. You will learn which endpoints to use for getting rates, creating exchanges, and monitoring statuses, as well as how to avoid typical issues with extraId and ChangeNOW minimum amount. For a complete ChangeNOW API example, see our code snippets below.
Benefits of Integration
Liquidity. Instead of building your own reserves, you gain access to deep liquidity through a single API. ChangeNOW aggregates several pools (Binance, Huobi, Kraken), minimizing slippage even for amounts around 5 BTC.
KYC. The non-custodial model means funds are not stored with the provider — compliance risks are reduced. Most exchanges proceed without verification; only amounts above a threshold (e.g., >10 BTC) require checks. This saves up to 40% of user onboarding time.
Volatility. The Fixed Rate mode locks the rate for 2–3 minutes, ideal for arbitrage and large transactions. Standard mode uses the market rate with updates every 5 seconds — suitable for small exchanges with minimal delays.
Development time. ChangeNOW provides a well-documented REST API and SDKs for Python, JS, Go. Using our ready module, integration takes from 3 days to 2 weeks — 2 times faster compared to in-house development. Additionally, this reduces infrastructure costs by about 30% (saving up to $3,000 per month) by eliminating the need for your own liquidity pools. Clients typically save an average of $2,000 per month in operational costs after integration. For instance, one wallet saved $2,500 monthly after adopting our module. The total cost of integration starts at $4,000, and the monthly savings can be up to $3,000, resulting in a payback period of about 2 months.
How We Integrated ChangeNOW API: A Real Case
Let's break down a real case — integration for a multi-currency wallet based on Python (FastAPI) and PostgreSQL. The wallet supported 20 coins and required exchange without registration.
Stack: Python 3.11, httpx 0.25, pydantic for validation, asyncpg for database, celery for background tasks. We used ChangeNOW webhook endpoints to track statuses.
Key points:
- Implemented rate caching with a TTL of 30 seconds to reduce API load — down to 10 requests/second instead of 50.
- For Fixed Rate, created a queue with a timer: if the user doesn't send the deposit within 2 minutes, the rate is recalculated.
- Handled edge cases: insufficient balance, network delays (retry after 30 seconds), refunds on network errors.
Client result: average exchange time — 4 minutes, successful transaction rate — 98.7%. ChangeNOW API processes such transactions 1.5 times faster than the average provider. Our experienced team guaranteed a smooth integration with certified code quality.
Get a consultation on ChangeNOW API integration — we'll estimate the work scope in 1 day. Integration costs start from $4,000, delivering a robust module tailored to your stack.
Standard vs Fixed Rate Comparison
| Parameter | Standard | Fixed Rate |
|---|---|---|
| Rate | Floating, updates every 5 sec | Fixed for 2–3 min |
| Commission | 0.5–1.5% of amount | 0.8–2% of amount |
| Slippage | Possible during high volatility | None within limits |
| Minimum amount | From 0.001 BTC | From 0.01 BTC |
| Suitable for | Small/medium exchanges | Large exchanges, arbitrage |
For most wallet users, Standard is sufficient. This ChangeNOW standard rate mode is recommended for amounts >0.1 BTC or when precision is important.
Monitoring Exchange Status
The key is real-time exchange status monitoring. ChangeNOW returns statuses: waiting, confirming, exchanging, sending, finished, failed, refunded, verifying. Without automation, you won't know when an exchange completes or an error occurs. We configure webhook notifications to your server to automatically update balances and notify users. Monitoring status via webhook reduces incident response time to seconds. For detailed endpoint usage, refer to the official ChangeNOW API documentation.
Additionally, configure alerts for failed and refunded statuses — this reduces incident response time.
Why Choose ChangeNOW API for a Wallet?
ChangeNOW supports 850+ coins, including rare assets. The standard REST API over HTTPS ensures ease of integration. The non-custodial approach eliminates the need for an exchange license. Additionally, the ChangeNOW affiliate program returns 35-40% of the margin — a nice bonus. All this makes ChangeNOW one of the best solutions for adding exchange to a wallet. With our experience, you get a guaranteed result and ongoing support.
Process of Work
- Analysis — We study your architecture, select modes and pairs.
- Design — We develop the integration scheme, define endpoints and caching.
- Implementation — We write code on your stack, handling all edge cases.
- Testing — Test period on ChangeNOW's sandbox environment with error simulation.
- Deploy — Deploy to production, configure monitoring and alerts.
Deliverables
- Analysis of the current architecture and selection of optimal modes (Standard/Fixed Rate).
- Designing the integration scheme, accounting for caching and error handling.
- Implementing the module on your stack (Python, JS, Go, Rust).
- Testing on ChangeNOW's sandbox environment, simulating all statuses.
- Deploying to production with monitoring and webhook notification setup.
- Providing integration documentation and team training.
- Guaranteed 2-week delivery with certified quality assurance.
- Post-deployment support for 30 days.
Contact us for a free evaluation of your project — we'll help design the optimal architecture. Order test access to our ready integration module.
Common Problems
- Missing extraId. For XRP, EOS, STELLAR networks, an additional identifier (memo/tag) is required. Without it, the deposit is not credited.
- Incorrect minimum amount validation. The /v2/exchange/range endpoint returns current limits — don't rely on hardcoded values. Always check the ChangeNOW minimum amount dynamically.
- Ignoring the verifying status. If KYC is required, the exchange won't move to finished without action from the provider.
- Lack of timeout handling. Fixed Rate has a timeout — after sending the deposit, the rate may change if not completed within 2 minutes.
Key ChangeNOW API Endpoints
Get Exchange Rate
import httpx
from decimal import Decimal
class ChangeNOWClient:
BASE_URL = "https://api.changenow.io/v2"
def __init__(self, api_key: str):
self.api_key = api_key
self.headers = {"x-changenow-api-key": api_key}
async def get_estimated_amount(
self,
from_currency: str,
to_currency: str,
from_amount: float,
flow: str = 'standard'
) -> dict:
async with httpx.AsyncClient() as client:
response = await client.get(
f"{self.BASE_URL}/exchange/estimated-amount",
params={
"fromCurrency": from_currency.lower(),
"toCurrency": to_currency.lower(),
"fromAmount": str(from_amount),
"flow": flow,
"type": "direct"
},
headers=self.headers
)
data = response.json()
if "error" in data:
raise ChangeNOWError(f"{data['error']}: {data.get('message', '')}")
return {
"estimated_amount": data["toAmount"],
"rate": data["toAmount"] / from_amount,
"min_amount": data.get("minAmount"),
"max_amount": data.get("maxAmount"),
"network_fee": data.get("networkFee")
}
Create Exchange
async def create_exchange(
self,
from_currency: str,
to_currency: str,
from_amount: float,
to_address: str,
refund_address: str = None,
flow: str = 'standard',
user_id: str = None
) -> dict:
payload = {
"fromCurrency": from_currency.lower(),
"toCurrency": to_currency.lower(),
"fromAmount": str(from_amount),
"address": to_address,
"flow": flow,
"type": "direct",
"extraId": "",
}
if refund_address:
payload["refundAddress"] = refund_address
if user_id:
payload["userId"] = user_id
async with httpx.AsyncClient() as client:
response = await client.post(
f"{self.BASE_URL}/exchange",
json=payload,
headers=self.headers
)
data = response.json()
return {
"order_id": data["id"],
"deposit_address": data["payinAddress"],
"deposit_amount": data["fromAmount"],
"receive_amount": data["toAmount"],
"payin_extra_id": data.get("payinExtraId"),
"status": data["status"]
}
Monitor Status
async def get_exchange_status(self, order_id: str) -> dict:
async with httpx.AsyncClient() as client:
response = await client.get(
f"{self.BASE_URL}/exchange/by-id",
params={"id": order_id},
headers=self.headers
)
data = response.json()
status_map = {
"waiting": "awaiting_deposit",
"confirming": "confirming",
"exchanging": "processing",
"sending": "sending",
"finished": "completed",
"failed": "failed",
"refunded": "refunded",
"verifying": "kyc_required"
}
return {
"status": status_map.get(data["status"], data["status"]),
"payin_hash": data.get("payinHash"),
"payout_hash": data.get("payoutHash"),
"amount_received": data.get("amountReceived"),
"amount_sent": data.get("amountSent"),
"updated_at": data.get("updatedAt")
}
List Supported Currencies
async def get_currencies(self, active: bool = True) -> list[dict]:
async with httpx.AsyncClient() as client:
response = await client.get(
f"{self.BASE_URL}/exchange/currencies",
params={"active": str(active).lower(), "flow": "standard"},
headers=self.headers
)
currencies = response.json()
return [
{
"ticker": c["ticker"],
"name": c["name"],
"network": c.get("network"),
"image": c.get("image"),
"is_stable": c.get("isStable", False)
}
for c in currencies
]
Minimum Amounts and Validation
async def validate_exchange_params(
self,
from_currency: str,
to_currency: str,
from_amount: float
) -> ValidationResult:
range_data = await self.get_range(from_currency, to_currency)
if from_amount < range_data["min_amount"]:
return ValidationResult(
valid=False,
error=f"Amount too small. Min: {range_data['min_amount']} {from_currency.upper()}"
)
if range_data.get("max_amount") and from_amount > range_data["max_amount"]:
return ValidationResult(
valid=False,
error=f"Amount too large. Max: {range_data['max_amount']} {from_currency.upper()}"
)
return ValidationResult(valid=True)
async def get_range(self, from_currency: str, to_currency: str) -> dict:
async with httpx.AsyncClient() as client:
response = await client.get(
f"{self.BASE_URL}/exchange/range",
params={"fromCurrency": from_currency, "toCurrency": to_currency, "flow": "standard"},
headers=self.headers
)
data = response.json()
return {"min_amount": data["minAmount"], "max_amount": data.get("maxAmount")}