CoinAPI is a high-performance platform that provides a unified API to access both real-time and historical cryptocurrency market data. It integrates data from a wide range of cryptocurrency exchanges, offering developers and institutions:
- A single access point for multiple exchange feeds
- Both raw and normalized (preprocessed) data
- Support for REST, WebSocket, FIX, and Flat File delivery
- Low-latency infrastructure for time-sensitive applications
CoinAPI simplifies access to digital asset data, making it easier for users to build trading algorithms, analytics platforms, and enterprise-grade applications without needing to manage separate exchange integrations.
Currently, CoinAPI does not provide a dedicated API endpoint for tracking usage metrics. The best way to monitor your usage is through the Customer Portal's dashboard, which offers real-time tracking and historical views of:
- API credits used
- Data transferred (Tier 1 & Tier 2 for WebSocket)
- Flat Files usage
- Billing activity
We recommend logging in to your Customer Portal and navigating to the Usage Metrics or Billing sections for the most accurate and up-to-date information.
Yes, CoinAPI offers custom subscription plans tailored to meet specific data requirements and business needs. If your organization requires specialized data sets, higher rate limits, or unique integration support beyond the standard subscription offerings, you can reach out to our sales team to discuss a customized solution.
Yes, subscription payments are executed automatically on your primary payment method when the subscription remains active.
We have this in the product roadmap, but no date has been disclosed yet.
We currently don't have this feature. The majority of exchanges don't provide that information and because of that we can't make viable aggregation, but we are monitoring this opportunity.
Yes. Check the documentation for the output_format API parameter at https://docs.coinapi.io/market-data/rest-api#output-data-format (https://docs.coinapi.io/market-data/rest-api#output-data-format)
Yes, it's possible to have multiple API keys for the same subscription. In the Customer Portal, navigate to API Keys > Create Standard API Key. It is important to note that the existence of each additional API Key for a subscription (enabled or disabled) above the plan quota is charged 1 USD per day, with a minimum of one day.
Using multiple API keys helps improve security and manageability by allowing separation between environments (e.g., development, testing, production), tracking usage per product or service, isolating potential issues, and simplifying key rotation without impacting unrelated systems.
Yes, you may have multiple subscriptions.
Multiple subscriptions are commonly used when:
- The software is shipped to multiple third-party's by the customer (eg. self-hosted software)
- To separate environments inside the company (development, testing, staging, production)
- To separate multiple independent production sites (EUROPE, ASIA, etc)
- To separate multiple teams inside the company working on different features or products
Yes, please do!
- Sign in on the GitHub
- Fork our main GitHub repository: https://github.com/api-bricks/api-bricks-sdk (https://github.com/api-bricks/api-bricks-sdk)
- Work on the changes and push them into your forked repository
- When you are ready to share the changes with us. Create "Pull Request” to our main repository with a short description of the changes.
Yes, CoinAPI can be used commercially.
As per our legal policy, the following is a non-exhaustive list of practices that would not be considered "Legitimate Use":
- Using our services for unreasonable workloads we determine (in our sole discretion) to be unrelated to the deployment and maintenance of your own services;
- Re-selling our services or parts thereof to another party;
- Using our services in a manner we determine (in our sole discretion) could cause harm to our services or another party; or
- Unusual usage patterns inconsistent with those we reasonably consider as normal use when compared to other customers.
More information can be found in our legal information here: https://www.coinapi.io/legal (https://www.coinapi.io/legal)
Yes, you can use our data to display graphs, charts, or tables. The simplest way is to plug our data into any third-party charting library, for example:
- https://www.highcharts.com/ (https://www.highcharts.com/)
- https://www.amcharts.com/ (https://www.amcharts.com/)
- https://www.vobcocharts.com/demos/getting-started (https://www.vobcocharts.com/demos/getting-started)
- https://plot.ly/javascript/box-plots/ (https://plot.ly/javascript/box-plots/)
- https://canvasjs.com/javascript-charts/candlestick-line-chart/ (https://canvasjs.com/javascript-charts/candlestick-line-chart/)
- http://techanjs.org/ (http://techanjs.org/)
- (http://recharts.org/)http://recharts.org (http://recharts.org)
- https://uber.github.io/react-vis/examples/showcases/plots (https://uber.github.io/react-vis/examples/showcases/plots)
- https://developers.google.com/chart/interactive/docs/gallery (https://developers.google.com/chart/interactive/docs/gallery)
Yes, CoinAPI provides a dedicated Flat Files product that allows users to access and download large-scale historical crypto market data. This includes data such as trades, quotes, and limit order books (L2) from all supported exchanges. Files can be accessed via our S3-compatible API and downloaded in bulk by date, symbol, and exchange. Enterprise users can also request data delivery to their own Amazon S3 buckets.
Yes, we have a Status Page at: https://status.coinapi.io (https://status.coinapi.io/)
Yes, we do provide asset icons via REST API under the Metadata. More information can be found in our documentation here: https://docs.coinapi.io/market-data/rest-api/metadata/list-all-asset-icons (https://docs.coinapi.io/market-data/rest-api/metadata/list-all-asset-icons)
We do not support custom timezones, data is always processed in the UTC.
If you need to operate in the custom timezone then input and output values should be converted on the client-side before a request is sent to us or output data processed.
In the corner cases like OHLCV data on the higher than 1HRS periods (eg. 1DAY), you should execute queries only to the 1HRS period at the maximum and assemble higher periods like 1DAY on the client-side, as our 1DAY always starts and ends at the UTC midnight.
Yes, CoinAPI provides Service Level Agreements (SLAs) tailored specifically for enterprise clients. These SLAs define key performance and reliability metrics to support mission-critical applications, including:
- Guaranteed uptime and availability targets
- Maximum response time thresholds
- Dedicated support availability and escalation paths
- Incident response and resolution timelines
SLAs are structured to meet the needs of high-throughput trading platforms, institutional users, and large-scale data consumers who rely on consistent and predictable API behavior.
To discuss SLA options and terms, please contact our sales team at:
https://www.coinapi.io/contact-us (https://www.coinapi.io/contact-us)
You can generate an API Key via the Customer Portal. Once you have your API key, you can begin making requests immediately.
The actual integration time depends on the complexity of your project:
- For simple use cases, setup can take as little as 5 minutes
- For more complex systems (e.g., production-grade trading platforms or data pipelines), integration may take several days
Our SDKs, documentation, and sample code are designed to help accelerate the process, regardless of your environment or programming language.
Start here: (https://docs.coinapi.io/)https://docs.coinapi.io (https://docs.coinapi.io)
To stay informed about service status, outages, or scheduled maintenance, CoinAPI provides a dedicated status page:
Status Page: (https://status.coinapi.io/)https://status.coinapi.io (https://status.coinapi.io)
We recommend subscribing to email notifications directly on the page to receive real-time alerts.
If you encounter an issue that is not reflected on the status page or disagree with its current content, please report it using our support form:
Submit a request: https://support.apibricks.io/hc/en-us/requests/new (https://support.apibricks.io/hc/en-us/requests/new)
Yes, CoinAPI provides a standard Service Level Agreement (SLA) for all paid plans. This covers key performance metrics such as uptime, availability, and support responsiveness.
If your organization requires a custom SLA, this is available through our Enterprise Plan. Custom SLAs can include specific commitments around latency, incident response times, and dedicated infrastructure options.
To discuss custom SLA requirements, please submit a request here:
https://www.coinapi.io/contact-us (https://www.coinapi.io/contact-us)
Yes, your company should file a support ticket whenever an issue occurs. This is essential even if the problem seems temporary or intermittent.
Here’s why:
- Your support SLA (if applicable) is only activated when a ticket is submitted.
- Without a formal ticket, we cannot guarantee prioritization, investigation, or tracking of the issue.
- If your plan does not include a service-level SLA, we do not monitor or proactively respond to issues unless they are reported.
For customers with custom SLAs, we track specific metrics and build infrastructure to meet those guarantees. For all other users, we rely on incoming tickets to understand what matters to your business.
Our process:
- We continuously monitor infrastructure and act on system-level issues.
- However, without ticket input, we may not detect or be accountable for individual cases that affect your workflow.
- If needed, we expand monitoring and internal metrics based on patterns in submitted tickets.
CoinAPI delivers a comprehensive range of cryptocurrency market data across multiple formats and timeframes. The data includes both raw and aggregated market information from hundreds of supported exchanges.
Available data types:
- Metadata – Full metadata on supported trading pairs and instrument identifiers
- Exchange and asset information – Details about connected exchanges and tradable assets
- Quotes (Level 1) – Best bid/ask prices and sizes
- Order books (Level 2) – Full depth of market including all visible bids/asks
- Trades – Executed transaction data with price, size, and timestamp
- Exchange rates – Aggregated volume-weighted rates across markets
- OHLCV – Aggregated Open, High, Low, Close, and Volume data for timeframes starting at 1 second
This coverage supports a wide range of use cases—from algo trading and analytics to compliance, portfolio valuation, and backtesting.
Yes, CoinAPI offers integration assistance as part of our Enterprise Tier for the Market Data API and other services. This support can be tailored to your technical architecture, workflow requirements, and business objectives.
If you’re interested in hands-on onboarding, architecture reviews, or guided implementation, please contact our team to discuss the best setup for your use case.
CoinAPI provides one of the most comprehensive archives of cryptocurrency market data available, with records dating back to:
- Start Date: 2014-02-24 17:43:05.0000000
- Earliest Source: Data collection began during the Mt. Gox era
This historical dataset includes tick-level trades, quotes, and order book data (where available), and is continuously expanded across hundreds of supported exchanges.
CoinAPI provides a wide range of cryptocurrency market data types, designed to support everything from real-time trading to historical analytics. Available data types include:
- Trade Data – Executed transactions with price, size, and timestamp
- Order Book Data
- Level 1 (L1) – Best bid and ask (Quotes)
- Level 2 (L2) – Full depth of visible orders
- Level 3 (L3) – Individual order-level data (where available)
- Quotes – Best Bid and Asks
- OHLCV – Time-aggregated Open, High, Low, Close, Volume metrics
- Metrics - Quantitative measurements used to evaluate the performance and activity of cryptocurrency exchanges.
- Exchange Rates - Last 24 hour (rolling window over time) Volume Weighted Average Price across multiple data sources listed on our platform.
This rich dataset powers a wide range of use cases, including algorithmic trading, compliance monitoring, and market research.
To see how many SPOT symbols we support for an exchange, pull the exchange’s active symbols and count those with symbol_type == "SPOT".
CoinAPI monitors a wide range of quantitative and structural metrics to evaluate exchange performance, market health, and trading activity. These include:
- Trading volume - measures liquidity and overall activity
- Market depth - assesses available liquidity at various price levels
- Order book analysis - evaluates book imbalance, quote updates, and order concentration
- Spread calculation - tracks bid-ask spread efficiency across trading pairs
- Price chart interpretation - uses OHLCV data to generate price movement insights
- Market capitalization - reflects relative value across assets and exchanges
- Trading pairs evaluation - reviews the diversity and liquidity of listed pairs
- User metrics analysis - proxy indicators like volume per user or active asset ratios (when available)
- Trading fees overview - considers cost structures that impact trade behavior
- Security metrics - evaluates exchange trustworthiness based on uptime, incidents, and API stability
These metrics are used internally to assess data quality and externally by clients for analytics, modeling, and exchange benchmarking.
The volume_1day_usd value from CoinAPI’s /v1/assets endpoint represents the aggregated 24-hour trading volume across all supported market types, including:
- Spot markets (SPOT)
- Perpetual contracts (PERPETUAL)
- Futures contracts (FUTURES)
- Options (OPTIONS)
In contrast, platforms like CoinGecko typically report spot-only volume, which results in significantly lower totals. CoinAPI’s broader aggregation provides a more complete picture of an asset's true liquidity and trading activity.
Additional Tips:
- This behavior is not impacted by your subscription tier. It applies even on the free or trial plans.
- If you need volume segmented by market type, use the /v1/ohlcv, /v1/exchangerate, or /v1/symbols endpoints and filter by instrument type or exchange.
The volume_1day field in the /v1/symbols endpoint represents the trading volume over the past 24 hours measured in the base asset's unit.
Example:
- For the symbol BINANCE_SPOT_BTC_USDT:
- asset_id_base = BTC
- So, volume_1day is expressed in BTC
- Meanwhile, volume_1day_usd gives the same volume converted to USD
This applies to any symbol returned by the endpoint—the unit of volume_1day always matches the base asset of that trading pair.
Use this to distinguish between raw asset volumes and their fiat-equivalent representations.
Yes, CoinAPI provides a comprehensive mapping of exchange-specific identifiers to our standardized symbol IDs and asset IDs through the following endpoints:
- /v1/symbols: Retrieves all available symbols, including their exchange, instrument type, and asset identifiers.
- /v1/assets: Returns a list of all standardized asset IDs used across our platform.
These endpoints allow you to find and reference the aggregated symbol IDs used for data queries (such as BTC_USD, ETH_USD, etc.) across supported venues. You can also filter by exchange or asset to narrow your search.
You can use the /v1/symbols endpoint to filter trading symbols by exchange, market type, or specific crypto assets. The API supports multiple query parameters:
Examples:
- Symbols for Coinbase exchange:https://rest.coinapi.io/v1/symbols?filter_exchange_id=COINBASE
- Symbols for Chainlink (LINK):https://rest.coinapi.io/v1/symbols?filter_asset_id=LINK
- Binance Spot market only:https://rest.coinapi.io/v1/symbols?filter_symbol_id=BINANCE_SPOT_
- Binance Spot BTC base markets:https://rest.coinapi.io/v1/symbols?filter_symbol_id=BINANCE_SPOT_BTC_
- ETH/BTC pairs across all exchanges:https://rest.coinapi.io/v1/symbols?filter_symbol_id=_ETH_BTC
- Spot market pairs like XRP/USD:https://rest.coinapi.io/v1/symbols?filter_symbol_id=_SPOT_XRP_USD
For symbol formatting and ID patterns, refer to:
In rare cases where multiple markets result in the same symbol_id, CoinAPI appends an additional identifier—prefixed with an underscore (_)—to ensure uniqueness.
This occurs when:
- Exchanges list duplicate or deprecated markets
- API changes lead to symbol re-registration
- Multiple market feeds represent the same trading pair under different APIs
Example:
- Original: OKEX_FTS_ETH_USD_190927
- Duplicate-resolved: OKEX_FTS_ETH_USD_190927_5656B6
This additional suffix helps distinguish markets and ensures accurate symbol mapping in your integration.
Full explanation and symbol schema available here:
CoinAPI provides both aggregated and raw data types, depending on the endpoint or product you are using.
- Aggregated data types include:These are aggregated over fixed time intervals. The smallest supported aggregation period is 1 second.
- OHLCV (Open, High, Low, Close, Volume)
- Exchange Rates
- Raw data types include:These are provided in real-time, with every individual market event captured and made available through both real-time streams and historical API access.
- Trades
- Quotes
- Order Book
Trade volume in CoinAPI is calculated directly from raw trade data collected via APIs provided by each exchange. We do not rely on pre-aggregated volume figures published by the exchanges themselves.
Instead:
- Every individual trade is recorded with its quantity and price
- Aggregation (e.g., for OHLCV or volume summaries) is done internally based on this raw data
- This ensures consistency across sources and high accuracy
This method guarantees that volume metrics are built from the ground up using actual trade events, providing a reliable and transparent foundation for analysis.
CoinAPI supports a wide range of financial instruments across multiple cryptocurrency markets. Each symbol type corresponds to a distinct class of market data and is structured using a consistent identifier format.
Supported Symbol Types:
Symbol Identifier Patterns
Useful Resources
- List all symbols:https://rest.coinapi.io/v1/symbols
- Symbol identifier format reference:https://docs.coinapi.io/market-data/rest-api/metadata#symbol-identifier
CoinAPI primarily provides exchange-specific market data for transparency and granularity. Here's how aggregation works across different data types:
Kline (OHLCV), Order Book, and Trades:
- These datasets are not aggregated across exchanges
- Data is available per symbol and per exchange, such as BINANCE_SPOT_BTC_USDT or COINBASE_SPOT_ETH_USD
- If you need aggregated views, you'll need to implement that logic on your end
Aggregated Exchange Rates:
- The Exchange Rates API is an exception
- It provides volume-weighted average prices (VWAP) across multiple venues, delivering an accurate and blended view of the market
- Ideal for fair pricing, reporting, and portfolio valuation
Market Sentiment:
- For macro-level insights, use the Indexes API
- It aggregates news, social signals, and behavioral data into sentiment indicators and thematic indexes
CoinAPI primarily provides market data — such as ask_price, bid_price, volume, and symbol metadata — but also offers extended blockchain insights through the Node as a Service (NaaS) platform.
Here’s how your use cases are supported:
- Verifying Blockchain and Token Details
- The /v1/assets endpoint in the Market Data API provides metadata such as chain_id, network_id, and blockchain asset identifiers.
- For more advanced token-level verification (e.g., contract inspection), CoinAPI's Node as a Service supports blockchain queries, especially for Ethereum and EVM-compatible chains.
- Deposit and Withdrawal Availability
- CoinAPI does not currently provide real-time availability of deposits/withdrawals for assets on exchanges.
- This status usually requires direct API access or scraping of each exchange’s operational notices.
- Deposit/Withdraw Address Validation
- Not available directly via CoinAPI.
- However, NaaS Ethereum methods can retrieve blockchain transaction data, which can assist in indirectly verifying address activity and correctness.
- Token Contract Address Verification
- Use /v1/assets for active asset metadata.
- Use /v1/symbols to map tokens to specific exchanges, with symbol_id_exchange and related metadata.
To check how far back coverage goes, use symbol metadata (coverage varies by exchange+symbol+datatype).
Call: GET /v1/symbols?filter_exchange_id=EXCHANGE_ID
It returns per-symbol fields like:
• data_trade_start / data_trade_end
• data_quote_start / data_quote_end
• data_orderbook_start / data_orderbook_end
(often also data_start / data_end).
For a specific market, the earliest timestamp is the relevant data___start field. For “exchange-level earliest”, take the minimum data___start across that exchange’s symbols.
Yes, so long as the symbol is supported when it was introduced, we will still keep the historical data for inactive/delisted symbols.
You may list all the previously supported inactive/delisted symbols using this endpoint: https://rest.coinapi.io/v1/symbols/:exchange_id/history
Liquidation metrics are available for the following exchanges. They are only available in Market Data via the Metrics endpoint.
- DERIBIT
- BITFINEX
- BITMEX
- KRAKENFTS
- BINANCEFTS
- BINANCEFTSC
Funding rate data is available for the following exchanges, with the corresponding start dates. It is only available in Market Data via the Metrics endpoint.
- ASTERFINANCE - 2025-05-21
- BINANCEFTS - 2021-01-01
- BINANCEFTSC - 2021-01-01
- BITFINEX - 2021-01-01
- BYBIT - 2021-01-04
- BYBITUSDC - 2022-04-01
- DELTAEXCHANGE - 2022-03-10
- DERIBIT - 2021-01-01
- DYDX - 2023-11-03
- EXTENDED - 2025-05-21
- FTX - 2022-03-17
- HBDM - 2022-03-10
- HYPERLIQUID - 2025-05-08
- KRAKENFTS - 2022-03-18
- KUCOINFTS - 2022-03-28
- OKEX - 2022-03-23
- PHEMEX - 2022-03-10
- TAPBITFTS - 2025-05-21
We support the DERIVATIVES_OPEN_INTEREST metric for the following exchanges. It is only available in Market Data via the Metrics endpoint.
- DERIBIT
- HUOBIFTS
- HBDM
- KRAKENFTS
- BYBIT
- EXTENDED
Metadata provides reference information about supported assets, exchanges, symbols, and available datasets within the API. It helps users discover what market data is available before requesting historical or real-time data.
Metadata helps developers and trading platforms:
- Identify supported exchanges and symbols
- Discover available market datasets
- Validate integrations
- Build automated workflows
- Keep internal systems synchronized with current market coverage
- The API provides metadata for:
- Assets
- Exchanges
- Symbols
- Metric IDs
- Market coverage information
This allows users to explore the full structure of supported market data.
- expiry → available
- strike → available
- call/put → available
- instrument identifiers → available
- contract size → available
- settlement currency → available as{asset_id_quote}(via/v1/symbols)
Yes. Metadata is available through dedicated REST API endpoints. Developers can retrieve updated information programmatically instead of maintaining static lists manually.
Metadata is updated regularly to reflect changes such as:
- Newly added exchanges
- New trading pairs or symbols
- Updated market coverage
- Additional metrics and datasets
This helps users stay aligned with the latest supported data.
A metric_id identifies a specific market metric available through the API. Examples include:
- Funding rates
- Open interest
- Liquidation data
- Index prices
- Mark prices
Metric IDs help users discover which datasets may be supported for a given exchange or symbol.
No. Metadata is provided as a reference layer and does not guarantee that every dataset is actively updated or available for every symbol. Actual coverage may vary depending on the exchange and market conditions.
The best way to verify current coverage is by querying the metadata endpoints directly. These endpoints provide the most up-to-date information about supported exchanges, symbols, and datasets.
At the moment, we don’t provide OHLCV data in Flat Files. You can access OHLCV via our Market Data API, which allows you to query historical and real-time bars in different resolutions. Here’s the list of available periods. If you specifically need Flat Files:
- One option is to pull the raw trades data from our Flat Files, and then aggregate it into OHLCV (and BID/ASK) on your side.
- However, this requires additional processing work on your end.
The simplest and most efficient way is to use our Market Data API directly, as it will provide OHLCV bars out of the box without requiring you to build your own aggregation. With the Market Data API, you can also use output_format=csv as an additional parameter to get the output directly in CSV. Here’s the documentation you can refer to: Output Data Format Documentation
Yes, CoinAPI delivers all market data in a fully normalized format. This means the structure, field names, and data conventions are standardized across all supported exchanges and providers.
Normalization ensures:
- Consistent data structure regardless of exchange origin
- Easier integration and parsing
- Reduced risk of errors due to inconsistent formats
Whether you're consuming trades, quotes, OHLCV, or order book data, the format remains unified, so your application logic doesn't have to account for exchange-specific differences.
This is particularly useful for multi-exchange trading systems, analytics, or historical data aggregation.
For technical details, see:
CoinAPI sources historical raw market data directly from exchange infrastructure using the most efficient methods available:
- Primary Source – WebSocket APIsWhen available, real-time data is ingested from exchange WebSocket feeds, which offer high-frequency, low-latency access to trades, quotes, and order book updates.
- Fallback – REST APIs For exchanges or data types not supported via WebSocket, CoinAPI uses periodic polling of REST APIs to ensure continuous data coverage.
This combination ensures that even in cases where exchanges offer limited protocols, CoinAPI still collects and stores the most complete raw dataset possible for historical access.
The volume of historical data you can retrieve in a single API request depends on several factors:
- Endpoint-Specific Limits
Most endpoints support a limit parameter that controls how many records you can request. For example, REST API endpoints typically allow up to 100,000 data points per request.
- Subscription Plan Constraints
Your plan may include restrictions on the number of requests per day or the rate of requests. Higher-tier plans support greater throughput.
- Pagination and Rate Limiting
If you need more data than a single request allows, use pagination by issuing sequential requests with adjusted time_start and time_end parameters. Be mindful of rate limits to avoid throttling (HTTP 429).
- Data Type and Granularity
Endpoints like OHLCV with high granularity (e.g., 1-second intervals) return more records than those at hourly or daily intervals. This affects how much time range fits within the maximum limit.
High-frequency historical data refers to tick-level market data collected and stored at the maximum granularity that each exchange's real-time WebSocket feed allows.
Key points:
- Tick-level granularity includes individual trades, order book updates, and quote changes
- Granularity varies by exchange, depending on the capabilities and limitations of their APIs
- For some exchanges, high frequency may capture multiple updates per millisecond, while others may be limited to 1-second or slower intervals
CoinAPI ensures that all data is collected at the highest possible resolution to support use cases like backtesting, market microstructure analysis, and algorithmic strategy development.
The choice of data source significantly impacts data quality, granularity, and analytical value. CoinAPI prioritizes real-time WebSocket feeds as the primary method of data collection for the following reasons:
- Maximum GranularityWebSocket APIs provide tick-level updates, including every trade, quote change, and order book update—data often not available through REST endpoints.
- Market Microstructure VisibilityReal-time streams capture sub-second price movements, queue shifts, and order flow dynamics, enabling in-depth analysis and modeling.
- Lower Latency & Real-Time DeliveryWebSocket connections push data as events happen, without the polling delays inherent in REST APIs.
- Richer Event CoverageCertain events—like order cancellations or depth changes—may be entirely missing from REST APIs but are visible via WebSocket.
While WebSocket feeds can be more fragile (e.g., occasional disconnects or exchange-side issues), they provide a more complete and real-time view of market behavior, which is essential for algorithmic trading, research, and high-frequency applications.
This is expected behavior. CoinAPI's WebSocket stream sends incremental OHLCV updates for the currently open time interval to provide real-time accuracy as new trades arrive.
Key points:
- Multiple messages may be delivered for the same time window (e.g., 15-second, 1-minute interval)
- These updates share the same time_period_start and time_period_end timestamps
- Each message reflects an updated aggregation of OHLCV metrics as new data enters the system
- Once the interval ends, a final update is sent to indicate the closed candle
If you need only finalized OHLCV values:
Use the REST API /ohlcv/latest endpoint, which returns the most recent completed (closed) candles per symbol and period.
Here’s what’s available through CoinAPI:
OHLCV & Trades
- Yes, CoinAPI provides OHLCV (Kline) data based on the Trades dataset.
- Access via: /v1/ohlcv/{symbol_id}/history
- Raw trades are available through: /v1/trades
Turnover
- Not directly provided as a standalone metric.
- However, you can calculate turnover manually using the price × volume from trade records.
Market Capitalization
- Not available by default.
- However, total supply (SUPPLY_TOTAL) for Ethereum tokens is available via the Metrics API, which can assist in computing market cap.
Funding Rates
- Yes, Funding rate data is available via the Metrics API for select exchanges.
If you're using the /v1/symbols endpoint and only receiving SPOT market data, it's likely due to not filtering by the correct exchange_id.
To access PERP (perpetual futures) symbols from Binance:
Use these specific exchange_id values:
- BINANCEFTS → Binance USD-M Futures (e.g., USDT-margined contracts)
- BINANCEFTSC → Binance COIN-M Futures (e.g., BTC-margined contracts)
You can append filters or parse your results accordingly to isolate PERP instruments from these exchanges.
Need to explore all supported exchanges?
Use the /v1/exchanges endpoint.
In certain scenarios, CoinAPI's responses do not include the X-RateLimit-Remaining and X-RateLimit-Reset headers. This behavior is intentional to ensure fast response times and low latency. Since not all clients rely on these headers and including them can introduce performance overhead, we opt to exclude them in some cases.
Key Points:
- The X-RateLimit-Request-Cost header is always included, allowing you to monitor the cost of each API call.
- However, there is no way to force the inclusion of X-RateLimit-Remaining and X-RateLimit-Reset in every API response at this time.
How to Track Usage:
To monitor your API credit consumption, you can:
- Log in to the Customer Portal.
- Use the metric: Market Data API REST Credits (credits)
For more information, refer to our official documentation:
Why limit headers are not always shown
If you have additional needs or feedback about API response headers, feel free to contact our support team.
When using the Historical OHLCV endpoint, the API response does not include the total number of data rows in the result set. If your dataset spans a large time range, it’s important to manually manage pagination using the limit, time_start, and time_end parameters.
Best Practices for Efficient Data Retrieval:
To fetch a full mnth of hourly OHLCV data (e.g., January 2025), use:
bashGET https://rest.coinapi.io/v1/ohlcv/BINANCE_SPOT_BTC_USDT/history?period_id=1HRS&time_start=2025-01-01T00:00:00&time_end=2025-02-01T00:00:00&limit=1000&output_format=csv
This example uses a limit=1000, which covers more than the 744 hours in a 31-day month. The result should include all hourly data for January 2025 in one request, provided the data exists.
Pagination Strategy:
If the time window is longer or limit is smaller:
- Break your time range into multiple requests using adjusted time_start and time_end.
- Use the last time_period_end from each response as the new time_start in the next request.
Credit Usage Reminder:
- Each 100 data points returned = 1 REST API credit.
- For example, fetching 800 rows will consume 8 credits, even in a single request.
For more info on API credit usage:
If you have further questions or need help structuring your queries, feel free to contact our support team.
We define a "request" based on the amount of data you’re retrieving, not just the number of times you call the API.
- If your API call doesn’t use a limit parameter, or if that parameter isn’t available for the endpoint, then each API call counts as one request.
- If you use a limit parameter, then every 100 data points returned counts as 1 credit.
For example, if you're calling:
bashhttps://rest.coinapi.io/v1/ohlcv/exchanges/COINBASE/history?period_id=1HRS&time_start=2021-01-01&time_end=2021-01-02
And you receive 3,000 data points, that would consume 30 Market Data Credits (3000 / 100 = 30).
More Info:
- Learn more about API limits and billing metrics
- Review credit inclusions per plan on our Pricing Page
If you're unsure how many credits your specific call will use, feel free to reach out to support with your query details.
Exchanges use different methods to aggregate OHLCV candles, which may include delayed, averaged, or custom logic. CoinAPI standardizes OHLCV aggregation across all exchanges using a unified method based on real-time trade streams and reception timestamps. This ensures consistency, but values may differ slightly from the exchange’s native chart.
When using the REST API to access OHLCV data, each request must target a specific symbol (e.g., BINANCE_SPOT_BTC_USDT). There is currently no bulk query option for filtering OHLCV data across multiple symbols or exchanges in a single API request.
For example:
- To get 1-minute candles for multiple coins on a specific exchange, you must loop over each symbol individually
- This applies regardless of whether you're filtering by asset or exchange.
When using the REST API to request OHLCV data, the response is structured as a collection (e.g., JSON array). If no data is available within the specified time range, the response will be an empty array rather than an error.
This behavior is by design and reflects a valid response where:
- The requested time range exists
- The response structure is intact
- No trade activity occurred during the period (resulting in no OHLCV values)
In contrast, an HTTP 550 error is returned when requesting a specific object—such as a current exchange rate (e.g., BTC/USD)—and the requested value does not exist. Since a singular object is expected in that case, the lack of data results in a failed request.
Special note on OHLCV with no trades:
If there are no trades in a given period, no OHLCV record will be generated because open, high, low, and close values are undefined.
However, you can use the include_empty_items=true parameter to return time periods with no trade activity. In such cases, only the time_period_start and time_period_end will be present in the response.
Relevant documentation:
Yes. For historical tick-level data (Quotes, Trades, Order Books), timestamps can have sub-second precision. For many exchanges, timestamps are provided at millisecond level, and in some cases microsecond level. This depends on the venue.
Yes. Historical L2 order books can occasionally show crossed spreads (bid ≥ ask) due to how some exchanges queue and match orders. These overlaps reflect the raw data as received and may result from internal exchange engine design or update timing.
We collect order book data in both formats:
- Snapshot mode: Get static limit order book snapshots for specific points in time, ideal for backtesting and historical analysis.
- Streaming mode: Access real-time order book updates via our WebSocket feed for live trading and monitoring.
CoinAPI specializes in high-resolution, tick-level historical Order Book data for all supported cryptocurrency exchanges. Currently, our APIs (REST and Flat Files) deliver raw tick-level Order Book data only and do not offer native support for time-based aggregated data such as OHLC or interval-based order book snapshots.
However, if you're looking for Order Book time-aggregated data:
- You can generate it client-side using our SDKs or data processing tools
- Libraries in our GitHub repository include functions to build OHLCV and similar datasets from raw order book data.
This approach gives you full control over the granularity, aggregation intervals, and custom logic applied during processing.
For SDKs and examples, visit:
CoinAPI provides order book snapshots through both the HTTP API and downloadable flat files, depending on your use case and required granularity.
Available snapshot methods:
- Daily Snapshots via HTTP API
- Historical order book data includes a snapshot at 00:00 UTC each day
- Useful for daily reference points or position marking
- Custom Snapshots via Client Libraries
- You can generate custom order book snapshots at any desired interval (milliseconds, seconds, minutes, hours)
- These are computed client-side using raw tick-level data (trades, quotes, book changes) obtained from the HTTP API
- Supported in our open-source client libraries
- Flat Files / CSV Downloads
- Tick-by-tick order book data and snapshots are available as downloadable files
- Ideal for large-scale historical analysis, backtesting, and local storage
This approach gives you the flexibility to work with lightweight snapshots for fast lookup or reconstruct detailed order books with full depth for precise modeling.
CoinAPI delivers full order book data via the WebSocket API using a combination of snapshots and incremental updates. To maintain an accurate state, follow this process:
- Initial Snapshot
When you subscribe to the order book, the first message you receive will have is_snapshot = true. This contains the full depth of the order book and should be used to initialize your local book.
- Apply Updates
Once the snapshot is processed, apply all subsequent messages with is_snapshot = false to maintain the real-time state.
- Mid-Connection Snapshots
You receive another snapshot while already connected (another is_snapshot = true), invalidate your current book state, and replace it with the new snapshot to stay in sync.
This approach ensures that your order book is always consistent, even in cases of reconnection or partial data loss.
L2 (Level 2) order book data, also known as market-by-price, provides aggregated bids and asks at each price level. This data enables deeper market analysis beyond the top-of-book and is commonly used to:
- Measure order book imbalance — compare total bid vs ask volume
- Estimate average execution cost — especially for larger orders across multiple price levels
- Evaluate liquidity away from the midpoint — understand how deep the book is beyond best bid/ask
- Track average spread — monitor bid-ask dynamics over time
- Detect hidden interest — identify patterns suggestive of iceberg orders or spoofing behavior
L2 data is essential for traders, quants, and researchers conducting microstructure analysis, slippage modeling, or execution strategy backtesting.
L3 (Level 3) order book data, or market-by-order, includes granular event-level data such as:
- Individual order additions
- Modifications
- Cancellations
- Matches (executions)
This detailed view of the order book enables advanced analysis, including:
- Order resting time — measure how long orders remain unfilled
- Order fill probability — estimate execution likelihood based on position in queue
- Queue dynamics — analyze how the order queue evolves, including cancellations and re-prioritization
L3 data is essential for high-frequency trading, order flow modeling, latency-sensitive strategy development, and regulatory research. L3 is only available for selected exchanges: BITSO and COINBASE.
No, the period_id parameter is not supported on the /v1/orderbooks/{symbol_id}/history endpoint.
Why:
- Order book data is event-driven, not time-based.
- Updates are pushed whenever there's a change in market depth—not at regular intervals like 1-minute or 5-minute periods.
- As a result, CoinAPI does not provide time-aggregated order book snapshots (e.g., OHLCV-style summaries for bids/asks) via REST API.
Instead, the endpoint returns a chronological sequence of raw snapshots and depth updates, allowing you to reconstruct the order book state over time.
If you need time-aggregated depth views, you can:
- Build custom snapshots client-side by aggregating raw order book data
- Use CoinAPI’s Flat Files for efficient historical order book processing at scale
This endpoint may respond slowly for high-volume symbols like
due to the massive number of order book updates that occur throughout the day.
Reasons for slower response:
- The system must read the entire day's data (from 00:00 to 23:59 UTC) before generating a response, regardless of the specific time slice you're interested in.
- The time_start parameter has been deprecated, and you are encouraged to specify only the date parameter for full-day queries.
- This approach ensures data consistency and completeness, especially for reconstructing accurate order book states.
Best practice:
- Download the entire daily dataset
- Store and filter locally for performance and scalability
- Use CoinAPI’s Flat Files product if you require large-scale, efficient historical processing
Yes, CoinAPI provides comprehensive historical bid and ask data, including order book snapshots and top-of-book quotes from Binance and other supported exchanges.
Available Data Types:
- Order Book (Full Limit Order Book)
- Offers detailed historical order book snapshots and updates.
- Ideal for reconstructing the order book at any specific timestamp.
- Quotes
- Provides historical best bid and ask prices.
Access Methods:
- Market Data API
- Retrieve current and historical bid/ask and order book data using flexible REST endpoints.
- Suitable for integration with applications needing filtered, live, or historical access.
- Flat Files API
- Access historical market data as downloadable CSV or JSON files.
- Ideal for backtesting, deep analysis, and bulk ingestion at scale.
Yes, you can retrieve this data for the past year (or more, depending on exchange support). Flat Files are typically best for downloading large historical datasets, while the Market Data API is ideal for application integrations and real-time updates.
If you're looking for detailed historical bid/ask data—including order book snapshots at specific times, CoinAPI has two key options:
Option 1: Flat Files (Best for Historical Access & Bulk Analysis)
- Full Limit Order Book (LOB) Data
- Captures every change in the Binance order book.
- Allows you to reconstruct the full order book at any point in time.
- Quotes Data
- Provides top-of-book data (best bid/ask prices) over time.
- Lightweight and efficient for quick backtests or spread analysis.
Option 2: Market Data API (For Programmatic Access)
- All predefined plans include historical and live bid/ask and order book data.
- Choose based on your preferred access protocol:
- REST API: Good for historical and filtered data
- WebSocket: Best for real-time streaming
- FIX API: Ideal for institutional trading setups
Recommendation:
- Use Flat Files for downloading a complete historical dataset.
- Use Market Data API if you want to integrate real-time bid/ask data with selective historical queries into your app or trading system.
Currently, CoinAPI does not offer a direct endpoint to retrieve aggregated liquidity for mid-price ±X% over extended periods.
However, you can work around this by:
- Using the OHLCV Historical Data endpoint to get price time series.
- Manually calculating mid-price and defining liquidity bands (e.g., ±1%, ±5%).
- Aggregating data over time intervals (e.g., hourly, daily) on your side.
While our Metrics endpoint provides rich market activity insights, it does not support mid-price band liquidity queries at this time.
The /v1/orderbooks/:symbol_id/history endpoint does not currently support retrieving order book data for the current day. This behavior is expected, although not yet explicitly documented.
Workarounds and Real-Time Alternatives:
- To fetch the current order book:Use the GET /v1/orderbooks/:symbol_id/current endpoint
- For real-time updates:Use the WebSocket API, which supports real-time streaming of order book updates.
Additional Notes:
- The time_start and time_end parameters are not supported for the /current endpoint.
- Real-time data is available, but intra-day historical data for the current day is not accessible through the historical REST endpoint at this time.
- Adding support for near-real-time historical data for the current day is on our roadmap, but we do not have a specific timeline.
Recommendation: For continuous tracking of order book data throughout the day, leverage the WebSocket API and store the data on your end for later analysis.
CoinAPI provides raw Level 2 (L2) Order Book data on a per-symbol and per-exchange basis. This means:
- There is no aggregation across exchanges.
- Centralized and decentralized exchange data are kept separate.
- Each Order Book reflects the state of a single trading pair on a single exchange (e.g., BINANCE_SPOT_BTC_USDT or UNISWAP-V3-ETHEREUM_SPOT_ETH_USDT).
If you need aggregated Order Book views, you’ll need to implement that logic client-side by combining multiple Order Books using your preferred methodology.
For further details, visit the Order Book endpoint documentation.
CoinAPI delivers raw, unaggregated Order Book data as provided by each individual exchange. Since we do not aggregate Order Book data across exchanges, we also do not reconcile differences in tick sizes between trading venues.
Tick sizes can vary significantly between exchanges and trading pairs. If your application requires a harmonized view of price levels, including reconciling different tick sizes, this logic must be implemented on your side as part of a custom aggregation strategy.
We believe that aggregated Order Books are generally not meaningful in the crypto space due to varying market structures, liquidity depth, and tick sizes.
For technical guidance, you can explore our Order Book API documentation.
No, CoinAPI does not currently offer aggregated Order Book data across exchanges, including combinations of centralized exchanges (CEXs) and decentralized exchanges (DEXs).
Each order book is venue-specific, meaning that synthetic liquidity sources like Uniswap or Curve are maintained separately from centralized exchanges. This ensures accuracy and preserves the unique structure of each exchange’s market data.
If you require an aggregated view that includes both CEX and DEX data, you’ll need to implement that logic on your side using the raw data we provide.
You can explore detailed Order Book structures in our Order Book API documentation.
This does not apply, as CoinAPI does not aggregate Order Book data across exchanges, whether centralized or decentralized.
Order Book data is provided in its raw, venue-specific format, maintaining the original structure, price levels, and tick sizes of each source. Therefore, normalization or bucketing across different exchange types is not performed by CoinAPI.
If you require normalized depth across multiple venues, this would need to be handled on your end by processing and standardizing the raw data we supply. Learn more about our order book structure in the Order Book API documentation.
Estimating liquidity and slippage across exchanges and quote currencies is a complex challenge due to discrepancies in quote asset pricing (like USDC vs. USDT). CoinAPI does not aggregate order book liquidity across exchanges or normalize it into a unified feed like BTC_USD.
At this time:
- There is no built-in aggregation of liquidity data across centralized and decentralized exchanges.
- Normalization across quote currencies and liquidity bucketing must be handled on your side, depending on your analysis methodology.
- CoinAPI provides raw Quotes and Order Book data (both via REST API and Flat Files), which include precise snapshots and updates per symbol per exchange.
If you're looking to analyze liquidity over time or estimate slippage, you'll need to implement your own data normalization logic and aggregation based on the raw market data we provide.
CoinAPI currently provides L3 Order Book data (also known as Full Depth Order Book or Level 3 data) for the following exchanges:
- BITSO
- COINBASE
This data includes the most granular view of the order book, allowing access to individual order placements, modifications, and deletions. For technical details on this data type, refer to the Flat Files Limit Book Documentation or WebSocket L3 Order Book.
Yes, you can purchase daily full-limit order book data for specific trading pairs such as AERGO-USD from the Coinbase exchange via our Flat Files product. This allows you to download bulk historical data without having to loop through API calls.
Alternatively, if you prefer using the Market Data API, you can access historical order book data using the date parameter. However, please note:
- If you're looking to retrieve data over a range of dates, each day must be requested individually—this applies to both API calls and Flat Files downloads.
- For API access, using the date parameter ensures the complete dataset for that specific day is retrieved.
For larger date ranges or bulk needs, Flat Files offer a more efficient and cost-effective approach.
Yes, we support real-time streaming via WebSocket for all the mentioned data types:
- Trades – Stream live executed transactions for selected symbols.
- Quotes – Get real-time updates for best bid and ask prices.
- L2 Order Book (Depth) – Access full market depth updates with live order book snapshots and changes.
For a complete list of supported data types and more technical details, please refer to our WebSocket API documentation.
Let us know if you need help setting up your WebSocket feed or managing subscriptions.
Crossed order books can occur when exchanges match trades in batches (e.g., every 100ms) or accept orders under high load before matching them. CoinAPI delivers raw data as received, which may include such cases.
We deliver the raw market data exactly as it comes from each exchange, including the live bid and ask prices. We don’t provide the bid/ask spread directly in the response. The spread can be easily calculated on your side as the difference between the best bid and best ask.
Example:
If the best bid = 29,999.50 and the best ask = 30,000.10,
then spread = ask – bid = 30,000.10 – 29,999.50 = 0.60 USD
No, we do not manipulate spreads. We only provide the raw data directly from exchanges. The spread cannot be changed from our side.
Spreads are not fixed. They depend entirely on real-time liquidity and trading activity on each exchange.
L3 (Level 3) order book data, or market-by-order, includes granular event-level data such as:
- Individual order additions
- Modifications
- Cancellations
- Matches (executions)
This detailed view of the order book enables advanced analysis, including:
- Order resting time — measure how long orders remain unfilled
- Order fill probability — estimate execution likelihood based on position in queue
- Queue dynamics — analyze how the order queue evolves, including cancellations and re-prioritization
L3 data is essential for high-frequency trading, order flow modeling, latency-sensitive strategy development, and regulatory research. L3 is only available for selected exchanges: BITSO and COINBASE.
Yes, some exchanges occasionally send trade data with duplicate timestamps and prices. CoinAPI doesn’t filter these but includes a unique guid per trade, so you can identify and deduplicate them easily in your system.
Yes, occasionally you may observe trades in the WebSocket stream that have a size: 0. These are not actual executed trades but rather markers—commonly used to indicate data points such as index ticks or indicative prices.
Key Points:
- A size: 0 trade does not represent a real volume exchange.
- These trades should not influence OHLCV calculations (open, high, low, close, volume).
- They are intended to mark price points, often for indexing purposes or internal synchronization.
Documentation Reference: Message Variables — CoinAPI WebSocket
If you are generating candlestick charts or volume-based analytics, we recommend filtering out these entries to maintain data accuracy.
Trades with size: 0 in CoinAPI’s data—regardless of whether they pertain to an index or a standard trading pair like BITRUE_SPOT_XAUT_USDT—do not represent actual asset exchanges. These are non-transactional markers used for internal data signaling.
What do size: 0 trades mean?
- They act as reference points or flags within the data stream.
- They may be used for:
- Maintaining stream synchronization
- Keep-alive events
- Signaling the end of a trading batch
- Miscellaneous event tagging (e.g., market open/close, reset)
Important: These entries should be excluded from your trade analysis, volume aggregation, and OHLCV candle generation.
If you’re unsure how to programmatically filter them, feel free to contact our support team for sample logic or SDK guidance.
Yes! You can gain valuable insight into market trades and limit orders by leveraging two key data types:
- Trades Endpoint:
This provides details on executed transactions, which includes price, volume, and timestamp. These are actual trades that occurred between market participants. Use this to analyze trade flow and execution.
- Order Book Endpoint (L2/L3):
This gives you a passive view of the market — specifically, all the outstanding limit orders on both the bid and ask sides. It helps you understand market depth, liquidity, and the context in which trades occur.
The amount of historical options data we provide depends on the specific symbol. Options are treated as a type of symbol in our system, and the historical depth varies per contract. You can check this directly using our symbol list via API or in the Flat Files documentation, where you’ll see the start date for each option's symbol.
Yes, CoinAPI offers historical data for crypto futures across major derivatives exchanges like Binance Futures, Bybit, BitMEX, Deribit, OKX, and more. This includes contract specs, prices, volumes, and open interest. Ideal for backtesting and analytics.
Yes, CoinAPI offers historical options data from exchanges like Deribit and Binance. This includes strike prices, expiration dates, implied volatility, and trading volumes. Data is available via REST API and Flat Files for options market analysis, backtesting, and strategy development.
The main difference lies in expiration and price alignment mechanisms:
- Futures Contracts
- Have a fixed expiration date (e.g., quarterly or monthly)
- Price typically converges toward the spot price as the contract nears expiry
- Used for hedging, speculation, and arbitrage over defined timeframes
- Perpetual Swap Contracts (aka "perps", "swaps", or "perpetual futures")
- Has no expiration date
- Use funding rates to align their price with the spot market
- Funding is exchanged between long and short positions periodically (e.g., every 8 hours)
Both instruments are supported by CoinAPI and follow different symbol ID patterns in our system.
Yes, we provide data for BTC/USDT and ETH/USDT trading pairs—as long as they are active and available on the exchanges we support. These pairs are covered extensively in our Market Data API across spot, futures, and options markets.
We also support futures market data for a wide range of symbols. You can explore all the available futures symbols and supported exchanges through our Metadata Tables, which offer downloadable datasets for comprehensive review:
Metadata Tables - Supported Exchanges and Symbols
These tables will help you identify all supported trading venues and the available instrument types (including PERP, FUTURES, and OPTIONS), ensuring you get exactly the data you need.
For more insights into how we serve institutional-grade data coverage—including for exotic and futures pairs—check out how Wyden scaled their operations using CoinAPI’s infrastructure.
In some cases, SPOT and PERP symbols are listed under separate exchange IDs, even if they belong to the same exchange. This distinction is made because the exchange itself exposes SPOT and PERP markets through separate APIs, and we reflect that structure in our own system.
Example: Exchanges with separated PERP symbols
- BINANCEFTS – Binance USD-M Futures (USDT/fapi)
- BINANCEFTSC – Binance COIN-M Futures (Coin/dapi)
- KRAKENFTS – Kraken Futures
- BITGETFTS – Bitget Futures
Example: Exchanges with unified symbol listings
- OKEX
- DERIBIT
To retrieve PERP symbols, make sure you're querying the appropriate exchange ID using the /v1/symbols endpoint with a filter_exchange_id parameter.
For Quotes, Trades, and Order Books, we return updates exactly as they were emitted by the exchange.
If updates occurred at:
00:00:00.001
00:00:00.004
00:00:00.007
then those are the only timestamps available. We do not generate artificial records for missing milliseconds.
If you require evenly spaced 1 ms intervals, you would need to resample or aggregate the data on your side.
For OHLCV and Exchange Rates, the most granular supported period is 1 second (1s).
The best approach is to use a free trial account and test the historical endpoints directly. This allows you to:
• Query specific exchanges and instruments
• Inspect the timestamps returned
• Confirm whether the precision meets your requirements
If you provide a list of exchanges, we can also help assess expected timestamp granularity.
Yes. Expired instruments are included if they were listed and collected while active.
It’s difficult to provide an exact estimate of real-time data usage due to high variability in trading activity and exchange behavior. Here’s why:
Key Variables That Affect Usage:
- Asset Activity: Some cryptocurrencies trade constantly, others may stay idle for hours.
- Exchange Behavior: Update frequency varies — some exchanges push updates every millisecond, others less frequently.
- Market Conditions: Volatile periods or major announcements can spike activity and data volume.
- Update Type: Prices, quotes, and order book changes all have different data sizes.
Even with 100 coins and 24 updates/day, actual data usage can fluctuate significantly depending on market dynamics.
Recommendation:
Start with the Pay-as-You-Go (metered) plan. Monitor your real-world usage, and if your needs grow or stabilize, consider switching to a fixed subscription for better predictability and savings.
The /v1/symbols endpoint contains a very large dataset, covering all active markets across hundreds of exchanges. This can lead to timeouts, especially if your client or tool has a strict timeout setting.
Workarounds & Optimization:
To reduce the response size and avoid timeouts:
- Use filtering parameters:
- filter_exchange_id
- filter_symbol_id
- filter_asset_id
Example:
https://rest.coinapi.io/v1/symbols?filter_exchange_id=BINANCE
This retrieves only the symbols from Binance, significantly reducing data load and response time.
Pro Tip:
If you're only using symbols to validate requests, pre-filter to just the exchanges or assets you're actively integrating with. This ensures faster responses and less overhead.
No, it is not required to send an explicit unsubscribe message before closing your WebSocket connection.
When you terminate a WebSocket session, the server automatically cleans up all active subscriptions. This design ensures that no data will continue to be sent after your connection is closed.
Optional: Explicit Unsubscribe
- You may still choose to send an unsubscribe message before disconnecting if:
- You want clear confirmation of subscription termination
- You manage multiple concurrent streams and need to selectively disconnect
Risk of Post-Closure Data?
- The risk of receiving residual data after closing without unsubscribing is very low.
- The server’s internal mechanisms are designed to terminate all data flows immediately upon connection close.
Yes, you can connect to the main WebSocket DS endpoint:
cppwss://[lowercase-exchange-name].ws-ds.md.coinapi.io/
This connection is fully supported for use across multiple environments, including production, development, and staging. It allows for multiple WebSocket sessions from different IPs or systems without issue.
Additional Notes:
- This endpoint supports real-time and historical data.
- For more technical details, refer to the WebSocket DS Documentation.
Rate Limit Reminder:
CoinAPI enforces a limit of:
- 10 hello/subscribe messages per 10 seconds.
As long as your environment respects this threshold, you can safely open multiple connections without disruption.
For further customization or troubleshooting, reach out to our support team.
Yes, we do provide access to LMAX Digital data. This is available as an add-on that can be included with any Market Data subscription.
If you need assistance enabling this feature or want more details on coverage, feel free to contact our support team.
Yes, CoinAPI operates a datacenter in London, and we automatically route you to the closest available server to ensure minimal latency.
If you specifically require a London-based endpoint with dedicated routing and a latency SLA, this is available through our Enterprise plan (starting at $1260/month). This plan includes:
- Dedicated API endpoints
- Latency SLA
- Custom routing configuration
For more details or to upgrade, please contact our support team.
Our infrastructure is optimized for low latency, but some delays may occur depending on factors like your geographic location, internet provider, and system configuration.
You can easily test the latency performance yourself using our free API key, which includes $25 in credits—enough to experiment with various exchanges and endpoints.
If the latency you experience with the standard setup doesn’t meet your needs, consider upgrading to our Enterprise plan, which offers:
- Dedicated API endpoints
- Latency SLA
- Custom routing for optimized speed
Explore more on our Pricing Page or reach out to our support team for personalized guidance.
The Usage Metrics Dashboard provides insights into how much data and how many credits you're consuming across CoinAPI products. Here’s a breakdown of how to interpret it: Understanding the Tiers:
Tier 1 Data
Represents the amount of high-volume market data (like trades, quotes, and order book data) transferred via the WebSocket API. This is typically used for real-time trading applications and market monitoring.
Tier 2 Data
Refers to low-volume data such as metadata, OHLCV (candlestick data), and exchange rates delivered via the WebSocket API.
How to Activate Tier 1 or Tier 2:
No manual activation is needed. Tiers are automatically enabled based on your subscription plan. For example, if you're on the Professional Plan, your daily quota includes:
100,000 REST Credits
512 GB of Tier 1 WebSocket Data
64 GB of Tier 2 WebSocket Data
FIX API access
To filter symbols when subscribing via WebSocket, use the subscribe_filter_symbol_id parameter. Here's how it works:
- Prefix Match (Default):The parameter filters symbols that start with the listed value(s).For example, "subscribe_filter_symbol_id": ["BINANCE_SPOT_BTC_"] will match all symbols starting with that prefix, such as BINANCE_SPOT_BTC_USDT.
- Exact Match:If you append a character to the end of a symbol ID, the system performs an exact match instead of a prefix match.For example, "subscribe_filter_symbol_id": ["BINANCE_SPOT_BTC_USDT$"] will match only that exact symbol.
The LMAX Digital Exchange provides highly granular, institutional-grade market data. Due to our contractual agreement with LMAX, we are strictly prohibited from offering this data:
- In any free trial capacity
- As sample datasets
- In any aggregated or altered format outside of the full subscription
This level of data quality is a key differentiator for our offering, but it also comes with firm legal restrictions from the exchange itself.
Unfortunately, we are unable to provide test access, even on a limited basis. If you require further details about what’s included in the LMAX add-on or wish to explore alternative data options, our team would be happy to assist.
You connect to the FIX API by establishing a standard FIX session directly with the CoinAPI FIX gateway. This involves configuring your FIX client (initiator) to connect to our designated FIX endpoints. Example endpoint:
🔗 fix.coinapi.io:3303
You can also choose a region-specific endpoint depending on your setup. Full endpoint documentation is available here:
Key Details:
- The FIX API provides real-time market data streaming.
- It does not support historical data retrieval. For historical data, you’ll need to use our REST API instead:📄 REST API Overview
- For real-time data streaming as an alternative to FIX, you can also use our WebSocket API.
If you're looking for ultra-low latency and institutional-grade market access, FIX is ideal. For flexibility or developer-friendly streaming, WebSocket may suit your use case better.
We understand you're looking for metrics such as buy volume, sell volume, and buy/sell percentages. Currently, CoinAPI does not provide this data as pre-aggregated metrics via any endpoint — including under the Startup plan.
However, we do offer comprehensive raw data (Trades, Quotes, Order Book) that enables you to calculate these values independently within your own systems.
You can explore the available data types and endpoints here:
📄 Market Data API Documentation
If you're interested in building this logic internally or need guidance on calculating such metrics from raw data, feel free to reach out to our support team.
REST credit usage depends on the amount of data requested, not just the number of times you call the API. Here’s how it works:
General Credit Rules:
- If no limit parameter is used, 1 API call = 1 REST credit (up to the default limit of 100 records).
- If a limit parameter is used, every 100 data points = 1 REST credit.
- Using the date parameter overrides the limit and returns all data for the day, costing 10 credits max (assuming >1000 records).
Example Scenarios:
- Without limit parameter:
plaintexthttps://rest.coinapi.io/v1/orderbooks/BINANCE_SPOT_BTC_USDT/history?time_start=2025-05-01T00:00:00&time_end=2025-05-01T10:00:00
Usage: 1 REST credit (default limit applies).
- With limit=200:
plaintexthttps://rest.coinapi.io/v1/orderbooks/BINANCE_SPOT_BTC_USDT/history?time_start=2025-05-01T00:00:00&time_end=2025-05-01T10:00:00&limit=200
Usage: 2 REST credits.
- Using the date parameter:
plaintextKopiujEdytujhttps://rest.coinapi.io/v1/orderbooks/BINANCE_SPOT_BTC_USDT/history?date=2025-05-01
Usage: Up to 10 REST credits for full-day data.
For the Startup Plan:
- You receive 1,000 REST credits/day.
- If each daily request consumes 10 credits, you could retrieve data for 100 days per day.
- Keep in mind: other endpoints like Metadata also consume credits and may reduce your daily allowance.
More info: API Limits and Billing Metrics
For precise control, always monitor usage via the Customer Portal.
WebSocket Streaming
- Rate Limit
WebSocket connections are limited to 10 hello messages per 10 seconds. To maximize efficiency and performance, we recommend consolidating all your required subscriptions into a single hello message whenever possible.
- Latency:
WebSocket is optimized for real-time data delivery, offering significantly lower latency than REST. However, actual latency depends on several factor,s including:
- Your physical location
- Network provider and quality
- Exchange location and responsiveness
For example, achieving latency below 100ms between London and Binance may require specialized routing or proximity hosting. The default latency from London to Binance can be around 250ms.
🔧 For mission-critical low-latency setups, our Enterprise Plan offers:
- Your physical location
- Network provider and quality
- Exchange location and responsiveness
- Dedicated infrastructure
- Custom routing configurations
- Latency Service-Level Agreements (SLAs)Learn more about reducing API latency
REST API Polling
- Rate Limits
We strive to accept as many requests as possible, scaling infrastructure dynamically. However, some endpoints might return a 429 Too Many Requests error depending on:
- The nature of the endpoint
- Backend load distribution
- API protocol behavior
- Latency
REST API latency varies more widely than WebSocket. While we aim to minimize delays, response times can be influenced by server load, your query volume, and external factors like your internet connectivity and geographic proximity to our datacenters.
- Credit Usage
A daily credit quota applies based on your subscription tier. Each request consumes credits based on the data volume and endpoint accessed.
For best practices, REST is ideal for on-demand snapshots or historical queries, while WebSocket is recommended for continuous real-time streaming.
A reconnect message is sent by CoinAPI’s WebSocket server when the server is scheduled for a restart or shutdown. It contains a precise timestamp indicating when the connection will be closed.
📨 Example reconnect message:
json{ "type": "reconnect", "within_seconds": 10, "before_time": "2020-08-06T19:19:09.7035429Z"}
How to handle reconnects:
Choose one of the following strategies based on your application's requirements:
- Wait and reconnectAllow the current connection to close, then establish a new one.
- Reconnect immediatelyTerminate the current session and initiate a new WebSocket connection right away.
- Dual connection switch (advanced)Open a second connection and resubscribe to the same data scope. Once the original connection closes, seamlessly switch to the new one—ensuring continuity in data streams.Note: This approach is ideal for systems that rely on snapshot + update message sequencing.
For robust applications, implementing a seamless reconnection logic ensures minimal downtime and uninterrupted data processing.
Running multiple WebSocket connections concurrently—especially with shared credentials—introduces the following risks:
- Key misuse or leakage across environments (e.g., dev/test/prod)
- Triggering hard concurrency limits, which may result in dropped connections or access blocks
- Security vulnerabilities if API keys are not properly isolated
Subscriptions typically allow only one concurrent WebSocket session. For advanced use cases (e.g., multi-region apps), contact our team to discuss upgrading your plan.
Lost messages or delays on the WebSocket stream typically occur when your client cannot keep up with the volume of incoming data. You can detect message loss by observing gaps in the sequence number field on incoming messages.
Common causes include:
- Bandwidth limitations or network bottlenecks
- Lack of separation between message receiving and parsing/processing threads
- No CPU affinity set for the thread handling incoming messages
- CPU resource bottlenecks on the receiving thread
- Infrequent polling of the TCP socket buffer
- Per-message heap allocation causing garbage collection pressure
If your client falls behind, here’s what happens:
- Your system's TCP window closes, signaling you can’t receive more data
- CoinAPI's TCP stack starts queuing outbound messages
- A temporary internal buffer is created to retry message delivery (introducing delay)
- If the client still can’t catch up, CoinAPI will begin dropping messages
How to mitigate:
- Use dedicated threads for reading from the socket
- Avoid unnecessary object creation during message handling
- Ensure consistent and fast parsing to keep up with data flow
- Monitor CPU and memory performance, and scale resources if needed
- Review system tuning techniques related to TCP flow control
More general background can be found by researching: TCP Flow Control
Yes, latency is typically higher for exchanges that offer only REST API access compared to those that support WebSocket feeds.
REST APIs generally introduce more delay because:
- They require polling instead of streaming
- They are subject to stricter rate limits and slower response cycles
- The exchange may throttle data frequency
To minimize latency from these exchanges, CoinAPI uses hundreds of dedicated servers to parallelize requests and bypass REST-specific limitations. This allows us to collect data as fast as technically possible given the constraints of each exchange.
CoinAPI’s WebSocket SDK offers a production-ready implementation of the WebSocket client protocol, designed to reduce your development time and increase performance and reliability.
Key benefits:
- No need to implement or maintain the protocolThe SDK handles all protocol-level logic so you can focus on your business logic.
- Fully tested implementationThe WebSocket protocol is 100% covered with unit tests to ensure long-term stability.
- Built-in reliability featuresAutomatic reconnection, heartbeat monitoring, and error handling are embedded and can be optionally logged via event hooks.
- Zero-allocation JSON parsingDesigned for minimal CPU usage by avoiding unnecessary memory allocations.
- Optimized message processingIncoming messages are queued and handled by a separate thread to prevent TCP backpressure and ensure smooth performance under high load.
- Best practices includedThe SDK follows all recommended standards for high-throughput, low-latency WebSocket communication.
Using the SDK gives you a faster path to production with lower maintenance overhead and better runtime efficiency.
All real-time data is delivered through CoinAPI’s geographically distributed local sites to minimize latency and optimize performance.
Real-time data includes:
- All /current endpoints in the REST API
- The /trades/latest endpoint in the REST API
- The /ohlcv/latest endpoint in the REST API
- All streams from the WebSocket API
- All sessions using the FIX API
These endpoints are latency-sensitive and therefore routed through the nearest available site using GeoDNS, ensuring faster response times and more stable connectivity.
If you notice missing data or gaps in pricing, follow these steps:
- Check Your API Key and Subscription
- Ensure your API key is valid and has access to the data type you're requesting
- Verify your subscription tier supports the asset class or protocol (e.g., tick data, OHLCV, order books)
- Validate Your Request
- Double-check the symbol_id, time_start, time_end, and limit parameters
- Try querying a smaller time range or different exchange to isolate the issue
- Use Metadata Endpoints
- Use /v1/symbols and /v1/assets to confirm that the symbol exists and is currently supported
- Contact Support
- If the issue persists, submit a ticket at support.coinapi.io
- Include:
- Affected symbol_id(s)
- time_start and time_end
- Your API key (if comfortable)
- Sample response/output if applicable
Some short gaps may occur due to upstream exchange downtimes or API failures. For gap-resistant backfills, consider using Flat Files as a complement to API requests.
CoinAPI's REST Market Data API is optimized for low latency and high reliability, making it suitable for time-sensitive applications such as algorithmic trading and real-time analytics.
Key Performance Insights:
- Typical Latency: 100–200 milliseconds for small to medium-sized requests under normal network conditions
- Large Requests: May take longer, but initial response times (first-byte-out) remain consistently fast
- Global Infrastructure: CoinAPI operates hundreds of distributed servers worldwide to minimize latency and ensure optimal routing
Best Practices for Low-Latency Applications:
- Use parallel requests across multiple threads to reduce total wait time
- For ultra-low latency needs, consider switching to WebSocket or FIX API, which are designed for real-time data streaming
- Place servers geographically closer to CoinAPI’s endpoints or request AWS VPC peering (available under the Enterprise plan)
Learn more in our Performance Testing Guide or contact our support team for help with latency optimization.
We don’t use usernames or passwords for authentication in the FIX API.
Authentication is handled via your API Key, which you provide in the Logon message.
Details can be found here: FIX Logon Message Documentation.
Full configuration guidelines are available here: FIX API Configuration.
Full configuration guidelines are available here: FIX API Configuration.
- server IP = SocketConnectHost
- port = SocketConnectPort
Authentication with the FIX API : FIX Logon Message Documentation.
Timestamp precision for historical tick-level data depends on the native behavior of each exchange.
Information about the request calculation algorithm for the REST API is available here[1], along with the details of how you can measure requests remaining or used after every request.
Utilize the Quotas and Limits[2] section and Usage Explorer[3] sections of the Customer Portal to track your usage.
[1] https://docs.coinapi.io/market-data/rest-api#limits (https://docs.coinapi.io/market-data/rest-api#limits) [2] https://docs.coinapi.io/general/customer-portal/QuotasLimits (https://docs.coinapi.io/general/customer-portal/QuotasLimits) [3] https://docs.coinapi.io/general/customer-portal/UsageMetrics (https://docs.coinapi.io/general/customer-portal/UsageMetrics)
Yes, to use credit-based services like Flat Files or REST API access, you must preload usage credits to your account. Here's how it works:
Preloading Credits
- Once you link your credit card, you’ll need to manually add credits through the Billing > Add Usage Credits section in your dashboard.
- Optionally, you can enable Auto Recharge, which automatically tops up your credits once your balance falls below a defined threshold.
How Charges Work
- Credits are prepaid, meaning you load your account before downloading data.
- The cost of your activity (e.g., API calls, Flat File access) is deducted from your available credit balance.
Processing Time
- Credit top-ups are processed in near real-time.
- Your available balance updates almost immediately after the credit card is charged.
- Only exception: crypto payments may have a short delay (up to 1 hour) due to blockchain confirmation times.
Usage Credits Documentation (https://docs.coinapi.io/general/usage-credits)
If you are finding that you are always requiring more daily requests, one way to circumvent this is by enabling Spend Management and Auto Recharge, wherein you can go above the limit of requests per day.
You may enable Spend Management and Auto Recharge through the Customer Portal (https://console.coinapi.io/).
You may read more about these features here:
- Spend Management (https://docs.coinapi.io/general/customer-portal/billing#spend-management)
- Auto Recharge (https://docs.coinapi.io/general/customer-portal/billing#auto-recharge)
If your CoinAPI subscription has a hard limit, exceeding your daily REST API quota will trigger an HTTP 429 Too Many Requests error response. This means no further requests will be processed until your 24-hour rolling window resets.
For soft-limited plans, we may allow overages temporarily, but we will contact you if usage consistently exceeds your plan limits, prompting an upgrade discussion.
How to Monitor Usage:
- Use our Subscription Management API to track usage and quotas in real-time: View Subscription API Docs (https://docs.coinapi.io/management/subscriptions)
- Review HTTP status codes and errors: Error Handling Reference (https://docs.coinapi.io/market-data/rest-api#http-errors)
The reason why response headers are not always present in the API responses is that, in some cases, we are unaware of their specific usage or requirements. To ensure that we promptly respond to your API calls and avoid unnecessary delays, we choose to provide a response without including the response headers. This decision is made with the intention of optimizing the operation of our API. By selectively excluding the inclusion of response headers in every request, we can enhance the overall performance and efficiency of the API.
It takes a while to verify the current usage as for the very first call for a given client we do not have a rate limit then yet. Once the request is made, we start the rate limit verification process In the background. We may then in the meantime process many requests for this client and at some point we append the result of current usage to the header. All requests that were made during that process are also included in the limit after some time.
For example (each bullet point representing a request made):
- Request (no info about clients usage)
- What's the usage? Starting the verification
- Request
- Request
- 5 requests used today (those 3 above are not counted yet), appended to the header
- Request (5 used)
- Request (5 used)
- Request (5 used)
- Request (5 used)
- Request (10 requests used today)
To provide clarity and transparency regarding the absence of response headers, we have documented this behavior on our official documentation page, which can be found at https://docs.coinapi.io/market-data/rest-api#request-limit--apikey (https://docs.coinapi.io/market-data/rest-api#request-limit--apikey)
You can view your past API usage directly in the CoinAPI Customer Portal:
- Log in at: https://console.coinapi.io/ (https://console.coinapi.io/)
- Navigate to the Usage Explorer tab
- Review your usage breakdown by using the Metrics available on the dropdown and filter by selecting a date range.
Additionally, for real-time tracking, you may refer to the Quotas and Limits section of the Customer Portal.
By default, CoinAPI limits responses to 100 items per request. However, you can increase this by using the limit query parameter.
- The maximum value for limit is 100,000 items
- If you request more than 100 items, every 100 items counts as one request toward your usage quota
Example:
bash
GET /v1/trades?limit=500
This call will return up to 500 trades and count as 5 requests in your quota.
Use this option when you need to retrieve large result sets efficiently, but be mindful of your daily request limits.
REST API usage is measured not by the number of API calls alone, but by request credits, which depend on how much data each call retrieves.
Key points to understand:
- CoinAPI uses a rolling 24-hour window to calculate usage
- Each data request credit counts as one "request"
- Some API endpoints return multiple data points per call
- If the limit parameter is used, every 100 items returned counts as one request credit
Example:
If you make a single call to retrieve 10,000 OHLCV records using limit=10000, that counts as 100 requests (10,000 ÷ 100), not just 1.
So, while your logs may show only 85 API calls in a day, your total usage could reflect over 10,000 request credits—especially when pulling large data batches.
This can lead to exceeding the daily request quota for plans like Streamer, which has a 10,000 daily request limit, and result in HTTP 429 Too Many Requests errors.
For technical details, refer to the API documentation:
https://docs.coinapi.io/market-data/rest-api#request-limit--apikey (https://docs.coinapi.io/market-data/rest-api#request-limit--apikey)
CoinAPI uses a credit-based system for REST API requests. The number of request credits consumed depends on how many data items you retrieve in a single call.
How it works:
- If you do not use the limit parameter, the default is limit=100, which counts as 1 request
- If you do use the limit parameter, every 100 data items returned counts as 1 request
Example:
bash
GET /v1/ohlcv/BINANCE_SPOT_BTC_USDT/history?limit=1500
This call returns 1,500 items, which counts as:
yaml
1500 ÷ 100 = 15 requests
Additional tips:
- limit minimum: 1
- limit maximum: 100,000
Yes, CoinAPI uses a credit-based model, but here's how the request-based billing works with the limit parameter:
How Credit Consumption Works:
- Each successful API request counts as at least 1 request.
- If your request includes the limit parameter:
- Every 100 data points = 1 credit (rounded up).
- Example: limit=200 = 2 credits, limit=1 = still 1 credit.
Even if you only request 1 data point (limit=1), it still triggers a full request and uses 1 credit, because that's the minimum unit for billing.
Yes, as stated on our legal terms under Customer Agreement section 2.4:
"You may terminate your initial Order of the applicable Software or Cloud Services under this Agreement, for no reason or any reason, by providing notice of termination. At your request (which may be made through your Account or by contacting us), we may disable the license key that allowed the Software to operate or disable access to the Cloud Services. All fees paid are non-refundable."
More information can be found here: https://www.coinapi.io/legal (https://www.coinapi.io/legal)
Cancelling your API key's subscription will render it unusable up until the end of your current billing period. If you still want to be able to use your API key, you may instead opt to downgrade to our Pay As You Go tier.
To learn more about the scope of the Pay As You Go tier, please refer to our Pricing page: https://www.coinapi.io/products/market-data-api/pricing (https://www.coinapi.io/products/market-data-api/pricing)
If your subscription was marked for cancelation using the customer portal and your billing period date has not passed, then you can still reactivate it by logging into the Customer Portal (https://console.coinapi.io/ (https://console.coinapi.io/)) and navigating to Subscriptions > Renew Subscription. You will be able to resume the subscription here.
If your subscription was marked for cancelation and your current billing period date has already passed, then you must acquire a new subscription from our Pricing page (https://www.coinapi.io/market-data-api/pricing (https://www.coinapi.io/market-data-api/pricing)).
Subscriptions for the predefined plans are sold through our Pricing page. [1]
Enterprise Plan agreement is custom-tailored to specific project needs. Please contact support or sales to get more information. [2]
References:
[1] https://www.coinapi.io/products/market-data-api/pricing (https://www.coinapi.io/products/market-data-api/pricing)
[2] https://www.coinapi.io/contact-us (https://www.coinapi.io/contact-us)
You may upgrade/downgrade your subscription via the Customer Portal (https://console.coinapi.io/ (https://console.coinapi.io/)). After logging in, please navigate to Subscriptions > Update Subscription > Select the appropriate subscription that you want to switch to > Continue. We can upgrade or downgrade your subscription as well via a support request.
Upgrading and downgrading operations are prorated; the remaining amount on your subscription at the moment of the change will be credited towards future liabilities. Your billing period cycle is not affected by the plan change.
Example 1:
If you have a Streamer subscription with a billing date of 2018-07-15 and it's 2018-07-05 and you want to upgrade your Streamer plan to the Professional, then:
- Unused Streamer subscriptions between 2018-07-05 and 2018-07-15 will be credited
- Professional subscriptions between 2018-07-05 and 2018-07-15 will be debited.
Example 2:
You have the Professional subscription with billing date 2018-07-15, and it's 2018-07-05, and you want to downgrade to the Streamer plan, then:
- Unused Professional subscriptions between 2018-07-05 and 2018-07-15 will be credited
- Streamer subscriptions between 2018-07-05 and 2018-07-15 will be debited.
- The remaining credit will be applied to future invoices
To execute the request, kindly submit a request here: https://support.coinapi.io/hc/en-us/requests/new (https://support.coinapi.io/hc/en-us/requests/new)
Purchasing a subscription is straightforward. Here’s what you need to do:
Steps to Complete Payment:
- Log in to your company's main account on the CoinAPI Customer Portal (https://console.coinapi.io/ (https://console.coinapi.io/))
- After logging in, visit the pricing page to choose your desired subscription: https://www.coinapi.io/products/market-data-api/pricing (https://www.coinapi.io/products/market-data-api/pricing)
- After choosing the subscription, you'll be redirected to a secure Stripe checkout page.
- Enter your credit card details and, if applicable, your VAT ID.
- Once the payment is completed, your subscription will be activated and you'll receive an invoice.
Important Notes:
- Please complete your company information in the Billing section before purchasing. This info is used to generate your invoice.
- VAT ID is required only for companies in the EU, except for the UK and Switzerland.
Need help with Stripe or billing? Contact [email protected] (mailto:[email protected]) or reach out through the portal.
Yes, bank and wire transfers are accepted, but only for annual subscriptions.
For monthly subscription plans, payment must be made via credit card through our secure Stripe checkout.
If you're interested in setting up an annual subscription via wire transfer, please contact our Support Team (https://support.coinapi.io/hc/en-us/requests/new) or Sales for invoicing assistance.
When signing up for a CoinAPI subscription, you may encounter payment errors returned by our payment processor, Stripe. Common examples include:
- balance_insufficient – Not enough funds on the card or account
- card_decline_rate_limit_exceeded – Too many decline attempts
- email_invalid – The email format is incorrect or unsupported by Stripe
How to resolve:
- Refer to Stripe’s official error documentation for guidance:
- Error codes: https://stripe.com/docs/error-codes#email-invalid (https://stripe.com/docs/error-codes#email-invalid)
- Decline reasons: https://stripe.com/docs/declines/codes (https://stripe.com/docs/declines/codes)
- If the error persists or you're unable to resolve it, please contact the CoinAPI support team here: https://support.coinapi.io/hc/en-us/requests/new (https://support.coinapi.io/hc/en-us/requests/new)
We’ll help you investigate and complete your sign-up.
CoinAPI does not offer a traditional free plan, but it does provide a Pay-As-You-Go metered plan that includes:
- $25 in free credits upon signup (generated API Key and verified payment method required)
- Access to both historical and real-time market data
- Support for REST and WebSocket protocols
- Volume-based discounts for higher usage
- Email support included
- No monthly commitment — you only pay for what you use
This plan is ideal for developers and small teams who want to test the platform, explore its capabilities, and scale up as needed. Once the $25 credit is exhausted, usage is billed according to the metered pricing.
You can start here: https://www.coinapi.io/market-data-api/pricing (https://www.coinapi.io/market-data-api/pricing)
Under the metered plan, credits are priced based on daily usage, not accumulated balance. Here’s how it works:
- The first 1,000 credits used in a single day cost $5.26.
- Additional blocks of 1,000 credits used on the same day cost $2.63 each.
Discounted rates only apply to same-day usage.
Examples:
- On Monday, you use 1,000 credits → pay $5.26.
- On Wednesday, you use 1,000 more credits → another $5.26 (new day, standard rate).
- On Friday, you use 2,000 credits →
- First 1,000 = $5.26
- Second 1,000 = $2.63
Unused credits don’t expire; you can use leftover credits (e.g., 500 credits from Friday) anytime later.
Yes, CoinAPI offers proactive monitoring and alerting through its Spend Management System:
- You can set daily usage thresholds and receive email alerts when they’re exceeded.
- You can also configure a webhook URL for real-time programmatic notifications.
- To ensure uninterrupted access, enable Spend Management, which lets you exceed your credit limit at a set daily credit usage budget.
Setup path: Customer Portal > Billing > Spend Management
Upgrading an Annual Subscription
Yes — if you're on an annual plan, you can upgrade at any time:
- Go to Customer Portal > Subscriptions > Update Subscription
- This method ensures you're only billed the difference for the remainder of your annual term.
Important: Do not purchase a new plan from the Pricing page — this will create a second, separate subscription rather than upgrading the current one.
Yes. CoinAPI offers customization through the Enterprise plan, which is fully adaptable to your technical, legal, and operational needs.
Custom options include:
- Dedicated account manager
- Custom onboarding and SLAs
- Premium support (including a dedicated Slack channel for $200/month)
- Flexible limits on API usage, request volume, and exchange coverage
- Tailor-made data delivery (e.g., custom S3 uploads, VPC peering, regional endpoints)
Add-ons:
- Business Plan users can also add a Slack support channel ($200/month)
- Additional data transfer is available at $1.25 per GB beyond the plan’s included 16 GB
To request a customized plan or explore upgrade options, contact CoinAPI Support (https://support.coinapi.io/hc/en-us/requests/new).
To pay an overdue invoice:
- Log in to the Customer Portal (https://console.coinapi.io/)
- Navigate to the Billing > Invoices section
- Select the unpaid invoice and proceed with payment using your saved payment method
If the payment method fails or you encounter issues accessing your account, please contact CoinAPI Support (https://support.coinapi.io/hc/en-us/requests/new) for assistance.
CoinAPI’s billing cycle is monthly by default.
- Monthly plans: You are charged once every month based on your subscription tier.
- Annual plans: You pay for the entire year upfront, but billing and usage limits are still calculated on a monthly basis (e.g., monthly credit quotas, data caps).
You can view your current billing period, invoice history, and usage metrics in the Customer Portal (https://console.coinapi.io/).
We build our own CDN network with nodes directly distributing data between each other via the fastest routes. Any existing CDN solutions are targeted on the caching which is not applicable to financial data.
Your sensitive information is stored inside the service provider, which is constantly audited and certified as a PCI-DSS Level 1 Service Provider. This is the most stringent level of certification available in the payments industry. To retain the certification, a payment provider must use world-class security tools and techniques to maintain a high level of security.
You may delete the compromised key and generate a new one on the API Keys section of the Customer Portal (https://console.coinapi.io/ (https://console.coinapi.io/)). This way, the compromised key will no longer be active for use and will not affect your subscription limits.
If you're experiencing issues logging in to the FIX API, follow these steps to ensure proper configuration:
- Verify access: You must have a PRO plan or FIX access enabled on your API key.
- Use the correct configuration: Download the FIX initiator config and FIX44.xml file from our GitHub SDK repository (https://github.com/api-bricks/api-bricks-sdk/tree/master/coinapi/market-data-api-fix).
- Set the API key correctly: Paste your API key into the SenderCompID field in your initiator configuration.
- Check the timestamp: Ensure that the TAG=52 (logon time) in your message is set in UTC and is closely synchronized with actual server time. Large time drift will cause the logon to fail.
If issues persist, contact our Support Team (https://support.coinapi.io/hc/en-us/requests/new) with your log trace and setup details.
CoinAPI operates a globally distributed infrastructure with low-latency data centers in the following locations:
- AWS Regions: us-east-1, eu-central-1, eu-west-1
- Colocated Sites:
- USA: Chicago, New York
- UK: London
- Poland: Warsaw
- Asia: Tokyo
Latency Behavior:
- Real-time data (via REST /current, WebSocket, FIX) is delivered from the site you’re connected to, routed using GeoDNS to the closest available server.
- Average latency for public endpoints is ~20ms.
- On Enterprise Plans, customers can achieve sub-1ms latency using direct connections or AWS VPC Peering.
Historical data (via REST /history and Flat Files) is consolidated across all regions to produce a single, globally consistent dataset. This reduces geographic discrepancies but can be impacted by replay process constraints.
Learn more about optimizing connectivity or request direct site access by contacting our Support Team (https://support.coinapi.io/hc/en-us/requests/new).
CoinAPI calculates exchange rates using a volume-weighted average price (VWAP) model across multiple exchanges, based on the past 24 hours of trading activity.
To ensure accurate market valuation, we combine both:
- Passive market data (Order book quotes)
- Active market data (Executed transactions)
The algorithm uses a combination of:
- Direct market pairs (e.g., BTC/USD)
- Indirect conversions (e.g., BTC/JPY → JPY/USD) using central bank FX reference rates
We prioritize trusted exchanges with high data quality. If data is unavailable from these sources, we intelligently include additional exchanges to maintain coverage—without compromising accuracy.
🔗 See full exchange rate methodology (https://docs.coinapi.io/market-data/rest-api/exchange-rates)
Certificate validation errors typically occur when your system lacks updated CA (Certificate Authority) certificates. Here’s how to resolve it based on your operating system:
On Windows:
- Ensure your Windows Updates are fully installed, as CA certificates are updated through the standard update process.
On Ubuntu/Debian Linux:
- Run the following command to refresh your certificate store:
sql
sudo update-ca-certificates
Alternative Option:
If updating certificates isn't feasible, you may connect via an unencrypted HTTP endpoint—though this is not recommended for production due to security concerns.
For production environments, we recommend using HTTPS with properly updated CA bundles.
You can integrate CoinAPI with MATLAB using multiple approaches, depending on your preferred development environment:
- Java SDK integration: Use Java libraries from MATLAB – Learn how (https://www.mathworks.com/help/matlab/using-java-libraries-in-matlab.html)
- .NET SDK integration: Call .NET libraries from MATLAB – Guide here (https://www.mathworks.com/help/matlab/using-net-libraries-in-matlab.html)
- Python SDK integration: Use Python libraries (like CoinAPI’s Python SDK) within MATLAB – Instructions (https://www.mathworks.com/help/matlab/call-python-libraries.html)
- Use webread() for direct API access: The webread function can call RESTful APIs and automatically convert JSON into MATLAB objects. – See how (https://www.mathworks.com/help/matlab/ref/webread.html)
This flexibility allows you to access CoinAPI’s market data or exchange rates from within MATLAB for trading strategies, analysis, or research.
CoinAPI is language-agnostic, you can use it with any programming language that supports HTTP requests and JSON parsing.
To make development easier, we provide official SDKs and code examples in our GitHub repository (https://github.com/api-bricks/api-bricks-sdk) for the following languages:
- Python
- R
- MATLAB
- C#.NET
- C++
- Java
- Ruby
- Go
- JavaScript / TypeScript / Node.js
- PHP
- Haskell
- Objective-C
These SDKs cover common integration patterns for REST, WebSocket, and FIX APIs.
All timestamps returned by CoinAPI, across REST, WebSocket, and FIX protocols, are standardized to UTC (Coordinated Universal Time).
This applies to:
- Historical data (e.g., OHLCV, trades)
- Real-time streams
- Metadata and time range filters
For details on time formatting and handling across endpoints, refer to our documentation:
CoinAPI Timezone & Timestamps (https://docs.coinapi.io/market-data#time)
You can explore our official SDKs, integration examples, and client libraries on GitHub:
CoinAPI GitHub Repository (https://github.com/api-bricks/api-bricks-sdk)
The repository includes:
- Sample code for REST, WebSocket, and FIX APIs
- SDKs in multiple programming languages (e.g., Python, Java, C#, Go, etc.)
- Flat Files and EMS Trading API usage demos
This is the best place to get started with real-world examples and accelerate your integration process.
CoinAPI does not block or restrict VPN usage, and in most cases, a VPN should not impact your API connection. However, several factors can influence performance:
What to Consider When Using a VPN:
- VPN Quality
- Low-quality VPNs may block API traffic, limit bandwidth, or introduce instability.
- Server Location & Latency
- The physical distance between you, the VPN server, and CoinAPI’s infrastructure can increase latency.
- In countries with internet restrictions (e.g., China), a VPN may be required to access CoinAPI.
- VPN Configuration
- Ensure your VPN allows outbound HTTPS traffic and isn’t blocking specific ports or protocols used by CoinAPI.
- Your ISP
- Even with a VPN, poor underlying internet quality can cause timeouts or dropped connections.
Troubleshooting Tips:
- Temporarily disable the VPN to check if it’s causing the issue
- Switch VPN servers or providers for better performance
- Update your VPN software to the latest version
- Contact your VPN provider if API traffic is being throttled or blocked
If problems persist, please contact our support team (https://support.coinapi.io/hc/en-us/requests/new) for assistance.
If you're experiencing connection issues with CoinAPI, please follow the steps below before submitting a support request:
- Check CoinAPI's Status Page Confirm there are no ongoing service disruptions at: https://status.coinapi.io/ (https://status.coinapi.io/)
- Verify DNS resolution Use the dig command to check domain name resolution: A correct response includes an ANSWER SECTION with IP resolution like: If the ANSWER SECTION is missing, this indicates a DNS resolution issue.
pgsql
dig [domain name here]
lua
;; ANSWER SECTION:
fix.coinapi.io. IN CNAME api.coinapi.io.
api.coinapi.io. IN CNAME api.coinapi.net.
...
hdc1-enc-02-bay-08.coinapi.net. IN A 185.204.225.28
- Check TCP connectivity Use nc to verify port access: Expected output: If the command fails, analyze the TCP connectivity on your side before contacting support.
cs
nc -v [hostname] -p [port]
css
Connection to fix.coinapi.io 3302 port [tcp/*] succeeded!
- Test encryption behavior Try switching between HTTPS and HTTP endpoints. If the issue appears only with one type, document that in your report—it helps isolate encryption-related errors.
- Capture a PCAP dump for analysis Use tcpdump to capture traffic. Adjust the port according to the API protocol:
- REST or WebSocket API:
bash
tcpdump -i [interface] port 80 or port 443 -w dump.$(date +"%Y%m%dT%H%M%S").cap
- FIX API:
bash
tcpdump -i [interface] port 3302 or port 3303 -w dump.$(date +"%Y%m%dT%H%M%S").cap
- Analyze the PCAP file before submission Ensure:
- CoinAPI is on the other end of the connection
- The problem is not caused by internal proxies, gateways, or firewall misbehavior
- The capture was performed from a system directly connected to the internet (not behind NAT if possible)
- Submit a support request Use the "API Issues" form at: https://support.coinapi.io/ (https://support.coinapi.io/) Include:
- Accurate problem description with UTC timestamps
- Results of the DNS (dig) and TCP (nc) checks
- A PCAP file with analysis details
- Set the issue priority according to impact:
- Urgent – Production system down
- High – Production system impaired
- Normal – Feature/system partially affected
- Low – General guidance or questions
This structured process ensures the support team can respond efficiently and effectively to network-related issues.
If you're receiving an "Invalid API Key" error shortly after generating a new key, this is expected behavior for a brief period.
CoinAPI operates multiple geographically distributed and independent server sites for high availability. Because of this architecture, it may take a few minutes for your new API key to fully propagate across all regions.
What to do:
- Wait a few minutes and retry your request
- Do not regenerate a new key unless the issue persists for more than 5–10 minutes
- If the problem continues, contact support at: https://support.coinapi.io/hc/en-us/requests/new (https://support.coinapi.io/hc/en-us/requests/new)
This short delay is a trade-off for ensuring there is no single point of failure in our infrastructure.
If you encounter errors while using CoinAPI, follow these steps to diagnose and resolve the issue:
- Refer to the Error Documentation Review the CoinAPI HTTP error guide (https://docs.coinapi.io/market-data/rest-api#http-errors) to understand the meaning of status codes like 400, 403, 429, or 550.
- Check Your Request Syntax Ensure your request uses the correct endpoint, method, headers, and query parameters. Invalid symbol IDs, time formats, or unauthorized data types are common causes of failure.
- Monitor CoinAPI Service Status Visit status.coinapi.io (https://status.coinapi.io/) to see if there are any ongoing incidents or outages affecting API performance or data delivery.
- Use Logging and Monitoring Log your request and response data, including timestamps, error codes, and rate limit headers. This helps identify rate limit breaches, invalid keys, or malformed requests.
- Contact Support If you’ve verified your request and service status but the issue persists, contact us through the Support Portal (https://support.coinapi.io/hc/en-us/requests/new) for further investigation.
To access CoinAPI via FIX protocol, you can use a standard Market Data API key. Here's how to generate it:
How to Generate Your API Key
- Log in to your Customer Portal
- In the left-side navigation, go to API Keys
- Click Create Standard API Keys
- Your new API key will be valid for both REST/WebSocket and FIX interfaces
You can also disable or delete keys from the same portal interface as needed.
The WebSocket error code 1006 typically indicates that the connection was closed abnormally, without a proper closing handshake. This can be caused by several external or local factors:
Common Causes:
- Unstable Internet Connection: Temporary drops or packet loss can trigger disconnections.
- Firewall or Proxy: Network security layers may block or interrupt persistent WebSocket connections.
- Client-Side Crashes: Application errors or memory leaks could cause forced shutdowns.
- Timeouts or Rate Limits: Ensure you’re not exceeding subscription limits or timeouts set by your environment.
Troubleshooting Tips:
- Ensure a stable and continuous internet connection.
- Whitelist WebSocket traffic in your firewall or proxy settings.
- Review your application logs for crashes or timeout issues.
- Consider implementing reconnection logic in your WebSocket client to handle disconnects gracefully.
If the issue persists and you're on a corporate network, consult your network administrator or reach out to [email protected] (mailto:[email protected]) for assistance.
CoinAPI Enterprise Plan is built for institutions and businesses that need premium performance, flexibility, and dedicated support. Our approach focuses on collaboration and customization to meet your evolving needs. If your applications rely on CoinAPI at the core of your operations, consider upgrading to our Enterprise Plan.
With Enterprise, you gain:
Easy Collaboration
1.Integration assistance from CoinAPI engineers
2.Dedicated infrastructure and latency optimization (VPC Peering, Cross Connect, Direct Connect)
3.Latency SLA
4.Exchange and asset integrations upon request
5.Optional 24/7 support for mission-critical environments
6.Higher REST, WebSocket and FIX limits
Custom Development
7.Ongoing development support for changes and enhancements
8.Ability to request custom features or API adjustments
9.Additional development time available as needed
Priority Support
10.Fast, prioritized handling of your requests
11.Higher REST, WebSocket and FIX limits
12.Dedicated channels for direct communication with our team
13.Dedicated Customer Success Agent and Slack channel for real-time assistance