Documentation

Developer Guides

Task-based CurrencyCore guides for frameworks, caching, retries, security, testing, observability, product workflows, migration, Postman and support.

These guides start from a job rather than an endpoint. Each one names the endpoints it uses, shows a working request, and links back to the canonical reference. They assume you have a key from the getting started guide and have read authentication.

If you are choosing an integration path, start with the framework quickstart for your stack. If you already ship to production, read in this order:

The OpenAPI reference remains the contract for every path, parameter and error code.

Framework quickstarts

One working request in the language or framework you already use.

Debugging CurrencyCore with curl

Run convert, rates, and history requests from a terminal, read HTTP status and Retry-After, and filter JSON with jq.

JavaScript and the CurrencyCore API

Call the API from a Node.js script or serverless function with fetch, a timeout, a small error class, and no build step.

TypeScript and the CurrencyCore API

Use the official TypeScript SDK for typed convert, rates and history calls, then fall back to raw fetch when you need custom request options.

Express 4 with CurrencyCore

A shared fetch helper, timeout, error middleware, and in-memory cache for a Node.js Express 4 route.

Next.js App Router with CurrencyCore

Add server-only CurrencyCore routes to Next.js, keep the API key off the client, and cache daily reference rates with revalidate.

React with a Backend Proxy

Call CurrencyCore through your own backend so the API key never enters the browser bundle, with loading, error, and abort handling.

Python and the CurrencyCore API

Use the official Python SDK for typed convert and rates calls, with environment-based auth, error handling, and a note on async services.

FastAPI with CurrencyCore and httpx

Add one async FastAPI route that calls CurrencyCore with httpx, validates the response with Pydantic, and applies a timeout.

Django 4.2 with CurrencyCore

A cached Django view that calls CurrencyCore with requests, propagates status, and keeps the key in server settings.

PHP and the CurrencyCore API

Call /v1/convert and /v1/rates from PHP with cURL, an environment variable, a timeout, and error handling.

Laravel and the CurrencyCore API

Add CurrencyCore to Laravel with the Illuminate HTTP client, config/services.php, an environment variable, a timeout, and one controller method.

Go and the CurrencyCore API

Call /v1/convert and /v1/rates from Go with net/http, a context timeout, typed structs, and error handling.

Java and Spring Boot with the CurrencyCore API

Call /v1/convert and /v1/rates from Spring Boot 3 with RestClient, typed records, connect and read timeouts, and status-preserving errors.

Ruby on Rails and the CurrencyCore API

Call /v1/convert and /v1/rates from Rails 7 with Faraday, credentials, explicit timeouts, a named error class, and a date-keyed cache.

C# and .NET with the CurrencyCore API

Call /v1/convert and /v1/rates from .NET 8 with IHttpClientFactory, source-generated JSON records, IMemoryCache, and ProblemDetails.

Flutter and Dart with the CurrencyCore SDK

Use the official Dart SDK in Flutter, pass the key with --dart-define, handle typed responses and Dio errors, and keep mobile key handling honest.

Swift and iOS with the CurrencyCore SDK

Use the official Swift SDK with async/await, configure the key from xcconfig or a backend, decode typed models, and handle ErrorResponse.

Kotlin and Android with the CurrencyCore SDK

Use the official Kotlin SDK on Android, keep the key out of source, call convert from coroutines, and handle ClientException.

Production basics

Caching, retries, key security, testing and logging for a live integration.

Caching Reference Rates

Cache CurrencyCore rates by date and base, use long TTLs for past dates, and keep today's cache within your business tolerance.

Retries and Backoff

Retry only 429 and 5xx responses with exponential backoff and jitter, honor Retry-After, and leave validation errors alone.

API Key Security

Keep CurrencyCore keys server-side, rotate with overlap, proxy browser traffic, and redact secrets from logs.

Testing Against CurrencyCore

Use test keys for integration checks, deterministic fixtures for unit tests, and contract tests against the OpenAPI 3.1 spec.

Observability and Logging

Log endpoint, base, date, status and latency with your own correlation ID, since the API does not return a request ID.

Load Testing a Metered API

Plan load tests from the per-minute rate limit, pace virtual users against it, and account for errors and retries that consume the same budget.

Graceful Degradation for Rate Outages

Use a circuit breaker and a dated last-known snapshot when the API is slow or failing, with a maximum stale age per business use.

Production Readiness Checklist

A concise launch checklist for keys, auth, timeouts, retries, caching, dates, quotas, plan gates, logging, and failure drills.

Bulk Conversion and Concurrency

There is no bulk endpoint. Batch with /v1/convert, fan out /v1/history one currency at a time, and pace a bounded worker pool.

Data Quality and Carried-Forward Rates

Read dense history correctly: carried-forward weekends, absent pre-listing dates, UTC dates, and the difference between a calendar row and a fresh fixing.

Product workflows

Apply the API to pricing, invoicing, dashboards, backtesting and agent workflows.

Sample Apps and End-to-End Patterns

Five small, runnable patterns: checkout quoting, PPP pricing, a dashboard proxy, a backtest, and an MCP agent setup.

Currency Conversion for E-commerce

Show local prices, fix the rate at checkout, charge in your settlement currency, and refund at the original rate with a complete order record.

Local Pricing for SaaS Plans

Turn a USD plan price into a defensible local price with IMF PPP factors, explicit floors and ceilings, and a documented rounding rule.

Multi-Currency Invoicing

Price an invoice at a fixed date, store the rate and response metadata, and reproduce the same calculation for audit.

Currency Dashboards

Build a rate dashboard with a server-side cache, a visible snapshot date, and a stale fallback instead of a request on every render.

Backtesting with Historical Rates

Run a historical simulation on dated observations while controlling look-ahead bias, carry-forward values and uneven currency coverage.

AI Agents and Currency Tools

Choose between the HTTP AI endpoint and MCP tools, and understand how each call is metered.

Historical Rate Coverage

Understand which pairs go back to 1949, which start in 1971 or later, and how per-currency availability affects a query.

Purchasing Power Parity

Read IMF PPP factors correctly, convert an amount at price levels, and keep the result separate from a market exchange rate.

Analytics Endpoints

Choose among the seven Growth+ analytics endpoints and understand what each metric measures.

Exporting Rate Data

Pull a daily series, mark repeated values, write a reproducible CSV, and load it into a warehouse without overcounting carry-forward days.

Migration

Move an existing provider integration with an explicit field and endpoint mapping.

Migrate an Existing Currency API Integration

Move a currency API integration to CurrencyCore: plan choice, bearer auth, currency and history coverage, response mapping, endpoint mapping, and a cutover checklist.

Migrate from Fixer

Move a Fixer integration to CurrencyCore: access_key to bearer auth, latest and convert mapping, timeseries to history, response fields, pricing differences, and caveats.

Migrate from CurrencyLayer

Move a CurrencyLayer integration to CurrencyCore: access_key to bearer auth, live and historical mapping, quotes to rates conversion, 60-second tier comparison, and caveats.

Migrate from ExchangeRate-API

Move an ExchangeRate-API integration to CurrencyCore: URL key to bearer auth, latest and pair mapping, conversion_rates mapping, history depth, pricing, and caveats.

Migrate from Open Exchange Rates

Move an Open Exchange Rates integration to CurrencyCore: app_id to bearer auth, latest and historical mapping, convert and time-series calls, response fields, and cutover checks.

Migrate from CurrencyAPI

Move a currencyapi.com v3 integration to CurrencyCore: apikey to bearer auth, latest, historical, convert and range mapping, response envelope changes, and cutover checks.

Migrate from Frankfurter

Move a Frankfurter v2 integration to CurrencyCore: add bearer auth, map base and quotes to the path, replace client-side multiplication, and decide when Frankfurter is still the better fit.

Reference and community

Tooling, release notes, common questions and how to reach support.

Postman Collection for the CurrencyCore API

Import the generated CurrencyCore Postman v2.1 collection and environment, set baseUrl and apiKey, and use one request per OpenAPI path. No hosted workspace.

Import the OpenAPI Spec into Insomnia and Bruno

Import the CurrencyCore OpenAPI 3.1 spec into Insomnia or Bruno, set baseUrl and apiKey environment variables, send a bearer-authenticated request, and add a CI curl smoke test.

Estimate Your Monthly API Cost

Calculate a CurrencyCore bill from included requests, completed 1,000-request overage blocks, the hard cap, and the separate AI credit pool.

Changelog

CurrencyCore documentation and API changes, starting with the 2026-11-11 developer guide, OpenAPI publication, MCP OAuth fix, docs hub, and API reference.

CurrencyCore FAQ

Answers about getting started, API keys, plans, currency and history coverage, rate limits, MCP, the AI endpoint, migration, and key security.

Support

Contact CurrencyCore support, check the status page first, and include the endpoint, UTC time, status, key prefix, request body, and correlation ID in your report.