# Credit, request, weight, symbol: why API quotas don't compare

Crypto data APIs meter weight, calls, data points, assets, compute or instruments, so one job costs a different number on each. How to convert it.

*https://cryptomarkets.tools/guides/why-api-quotas-dont-compare · background to Crypto Market Data APIs*

**Answer:** Crypto data providers do not meter the same thing. Binance counts request weight per IP per minute, CoinGecko one credit per successful call, CoinMarketCap and CoinAPI a credit per hundred data points, Glassnode credits per asset, Dune credits for compute it prices only after a query runs, and Amberdata and Kaiko sell access per exchange or instrument. One job converts into a different number in each unit, so the only comparable figure is your own workload, priced call by call.

Every data API in this catalogue publishes a quota, and almost every one of them counts something
different. The ceilings themselves — per key or per IP, per second or per month — are covered under
[rate limit](https://cryptomarkets.tools/glossary/rate-limit). This page is about the unit underneath the ceiling: what one
credit, one call or one point of weight actually buys, why the same job produces a different number
on every provider, and how to turn those numbers into something you can compare.

## How it works

Strip the branding off and there are five things a vendor can count, plus a sixth arrangement that
is not a meter at all.

**The request.** One call, one unit, whatever comes back. CoinGecko deducts one credit from your
monthly balance for each successful call, and Kaiko allows 6,000 requests a minute per API key on
its standard REST API. Planning against a request meter is simple: count calls.

**Weight.** Still one call, but the vendor sets its price per endpoint and sometimes per parameter.
The [Binance API](https://cryptomarkets.tools/tools/binance-api) charges 2 for a candle request and 250 for a full-depth order
book, out of 6,000 a minute per IP. [Nansen](https://cryptomarkets.tools/tools/nansen) does the same with credits: most
profiler and token endpoints cost 1, Smart Money endpoints 5, an address lookup for common labels
100, the premium-labels endpoint 500, and an expert-mode agent question 750. A monthly Nansen
balance means little until you know which endpoints will spend it.

**Data volume.** The unit is how much comes back rather than the call that fetched it.
[CoinMarketCap](https://cryptomarkets.tools/tools/coinmarketcap-api) charges one credit per 100 OHLCV data points, rounded up.
[CoinAPI](https://cryptomarkets.tools/tools/coinapi) charges one credit per call, except that a call using the `limit`
parameter costs one credit per 100 data points returned, rounded up, with 1 as the floor.
[CryptoQuant](https://cryptomarkets.tools/tools/cryptoquant) says only that the more rows come back, the more a call costs, and
that different data types cost different amounts. It publishes no rate card.

**The asset.** [Glassnode](https://cryptomarkets.tools/tools/glassnode) charges per asset per request: 1 credit for Bitcoin, 2
for any other asset. A bulk request is charged per asset requested, and the number of exchanges in
it does not change the price. The same series costs twice as much for Ether as for Bitcoin.

**Compute.** [Dune](https://cryptomarkets.tools/tools/dune) charges credits for the CPU, data scanned and engine time a query
uses, and states that it publishes no per-query formula: "You'll see costs after execution." Reading
the result is billed separately, in data points. So one query costs two things, and only the second
one can be worked out in advance.

**The entitlement.** Here the vendor sells the right to ask for a slice of data. The meter is still
there, but it is not what decides the price. [Amberdata](https://cryptomarkets.tools/tools/amberdata) sells self-serve
subscriptions one exchange and one market at a time. Its own documentation gives the example of a
subscription for Coinbase spot (named `gdax` in the API): a tickers call that names the exchange
succeeds, and the same call without the exchange parameter is rejected. So is a call naming Kraken,
and so is a futures call naming the same venue. [Kaiko](https://cryptomarkets.tools/tools/kaiko) builds each quote
from the number of assets or instruments, the data type, the granularity, whether you need history
or live data, and usage. On both, the symbol is part of the contract, not an argument you can
change.

Scope shows up on the exchange side too. [OKX](https://cryptomarkets.tools/tools/okx-api) counts its funding-rate and
open-interest endpoints against your IP and the instrument together. Polling fifty contracts gives
you fifty separate small budgets, not one large one.

## One job, seven meters

Take one small job and price it everywhere: a year of daily prices for 20 assets, fetched once.
Each row below uses the cheapest documented way to do it and the vendor's own published cost for
that endpoint.

| Provider | How the job is fetched | What it costs, in the vendor's unit |
|---|---|---|
| Binance | One candle request per pair, 365 daily bars, within the 1,000-bar cap | 20 calls × weight 2 = 40 weight, out of 6,000 that refill every minute |
| CoinGecko | One historical-chart call per coin; past 90 days the granularity is daily | 20 credits, out of 10,000 a month on Demo |
| CoinMarketCap | One OHLCV history call per coin, 365 points each | 4 credits per coin (365 ÷ 100, rounded up) = 80 credits |
| CoinAPI | One OHLCV history call per symbol with `limit=365` | 4 credits per symbol = 80 credits, out of 1,000 a day on Startup |
| Glassnode | One close-price request per asset | 1 for Bitcoin + 2 × 19 others = 39 credits |
| Dune | One SQL query over a price table, result read over the API | Execution: unknown until it runs. Read: 7,300 rows × 3 columns = 21,900 data points, about 22 credits on Analyst |
| Amberdata | Calls naming one exchange, for pairs on that exchange | Nothing per call beyond the rate limit; the cost is the subscription for that exchange and market |

Read down the last column and nothing lines up: 40, 20, 80, 80, 39, "unknown plus about 22", and
a subscription. None of these is a cheap or an expensive result, and the order changes as soon as
the job does. Ask for hourly bars instead of daily ones and the data-volume meters grow 24-fold,
because they charge for points. Binance barely moves, because a request still returns up to 1,000
bars for weight 2. Glassnode's credit count does not change at all, because it charges per asset per
request rather than per point, although finer resolutions sit on dearer plans. Swap the 20 majors for 20 small tokens and Glassnode nearly doubles, because only
Bitcoin costs 1.

The Dune row has a second problem. Dune's pricing FAQ prices API exports at 1,000 data points per
credit on Analyst and 5,000 on Plus. Its API billing page prices the same exports at 10 credits per
megabyte on Analyst and 2 on Plus, and does not say how a result smaller than a megabyte is rounded.
Both pages were live when this guide was checked. Until Dune reconciles them, measure the read cost
on your own account rather than assuming either figure.

The Amberdata row fails the comparison in a different way. The subscription covers one venue. If
the 20 assets need two exchanges, that is two subscriptions. The job's cost moves with where the
data comes from, not with how much of it you take.

## What it costs

A unit is also defined by when it comes back and by what happens when it runs out, and those rules
differ as much as the units do.

**How long a unit lives.** Binance weight refills every minute and cannot be saved. CoinAPI's
included credits are daily. CoinGecko, CoinMarketCap, CryptoQuant and Dune grant credits monthly.
Neither CryptoQuant nor Dune carries unused credits into the next month. Nansen's Pro plan tops the
included balance back up to 2,000 on the first of each month, but only if it has fallen below 2,000.
That makes it a floor rather than a grant. Nansen's free plan gets 100 credits once and then a daily
top-up back to 10.

**What happens at the limit.** On Binance you get a 429, and an IP that keeps calling after that is
banned automatically for two minutes to three days, with the ban growing for repeat offenders.
CryptoQuant returns a `402 payment_required` once both its plan credits and any purchased credits
are used up. CoinAPI does not stop you: usage beyond the plan quota is billed on a daily tiered
scale, from $5.26 per 1,000 credits for the first 1,000 of the day down to $0.03 per 1,000 above 25
million, and the tiers reset every day. Dune bills extra credits at $1.875 per 100 on monthly Analyst and $1.596 on
monthly Plus, up to a limit you set yourself. It has no free fallback: since 10 September 2026 a
free Dune account is view-only after a 14-day trial of 2,500 credits, and free accounts cannot buy
extra credits.

**What a top-up buys.** CryptoQuant sells 100,000 credits for $5, only on its Advanced and
Professional plans, and the balance stays valid for 12 months from the last purchase. Nansen's purchased credits expire
one year after purchase and are spent only after the included ones. Binance's public endpoints
have no price list, so there is no top-up to buy.

So "credits" can mean a monthly balance that never rolls over, a floor that refills on the first
of the month, or a daily quota with metered overage behind it. Before any of those figures can be
compared, each has to be multiplied out to your job and to the period you are billed in.

## What you can do about it

**Write the job down as calls before you open a pricing page.** List the endpoints, the parameters
and how often each runs: symbols, resolution, history depth, refresh interval. Then price each line
with the vendor's published cost for that endpoint, not the headline allowance. That is the
"one job, seven meters" table above, done for your job, and it takes an afternoon. It will also
catch the parameter that multiplies the cost. On Binance, leaving the symbol off a 24-hour ticker
request raises its weight from 2 to 80. On CoinMarketCap, each `convert` currency beyond the first
adds a credit.

**Put the job in the unit you are billed in.** If the plan is monthly, multiply the per-minute or
per-day figure out to a month before comparing it with a monthly allowance. If it is metered, price
the overage rather than the allowance, because the overage is what a busy month costs.

**Run it on a trial, and read the meter the vendor exposes.** Binance returns the running total in
an `X-MBX-USED-WEIGHT-1M` header on every response. Dune reports `execution_cost_credits` for each
execution on its status endpoint, which is the only way to learn what a query cost. CryptoQuant
shows each call's deduction in its usage history. On a paid plan, CoinGecko's `/key` endpoint
reports monthly and remaining credits. CoinAPI warns that its `X-RateLimit-Remaining` and `X-RateLimit-Reset` headers are
left off some responses on purpose, so a client that budgets from them has to cope when they are
missing.

**Cap the compute meters before you automate them.** On Dune, set the per-execution cost cap and
the monthly extra-credit limit before a scheduled query or an agent can run on its own. Nothing else
bounds a meter whose price is published only after the query runs.

**For entitlement pricing, list the scope before asking for a quote.** For Amberdata or Kaiko, bring
exchanges, markets and instruments by name, plus granularity and history depth. Then check the one
behaviour that breaks code you already have. On an Amberdata exchange subscription, any call that
does not name the subscribed exchange is rejected, even if the same call worked on a trial key with
access to every endpoint.

**Ask five questions that the pricing page rarely answers.** What does one credit buy on the
endpoint I will call most? Is it charged per call, per row, per asset or per unit of compute? Do
failed calls cost anything? Does unused allowance roll over? What happens at zero: a 429, a 402, an
overage bill or a ban? Two vendors that answer all five can be compared. Two that quote only a
monthly number cannot.

For what the same providers let you do with the data once you have it, see
[what exchange API terms actually let you do](https://cryptomarkets.tools/guides/exchange-api-terms). The price and market-data
APIs among them are listed under [market data APIs](https://cryptomarkets.tools/categories/market-data-apis).

## Tools this bears on

- [Dune](https://cryptomarkets.tools/tools/dune.md) — SQL and an API over 100+ indexed chains, metered in credits. Free access is view-only.
- [Nansen](https://cryptomarkets.tools/tools/nansen.md) — A labelled view of the chain — who is buying, not just which address.
- [Amberdata Market Data API](https://cryptomarkets.tools/tools/amberdata.md) — Spot, futures and options data — and one exchange's feed you can buy with a card.
- [CoinAPI Market Data API](https://cryptomarkets.tools/tools/coinapi.md) — One symbol scheme over 400+ venues, metered in REST credits and WebSocket gigabytes.
- [CoinMarketCap API](https://cryptomarkets.tools/tools/coinmarketcap-api.md) — Prices, rankings, DEX and derivatives data, metered by rows returned rather than by call.
- [CryptoQuant](https://cryptomarkets.tools/tools/cryptoquant.md) — Exchange reserves, miner flows and MVRV for four chains, as charts, alerts and an API.

## FAQ

### Why can't I compare 10,000 credits a month with 6,000 weight a minute?

Because they count different things over different windows. The CoinGecko Demo plan's 10,000 monthly credits are spent one per successful call; Binance's 6,000 weight refills every minute and a daily candle request costs 2 of it. Convert both into the calls your job makes before looking at either number.

### Can I find out what a call costs before I make it?

For most per-call meters, yes, because the cost is published per endpoint. Binance, CoinMarketCap, CoinAPI, Glassnode and Nansen all document it. Dune and CryptoQuant do not. Dune states that it publishes no per-query formula and that you see the cost after execution, and CryptoQuant says the deduction depends on how much data comes back and on its type.

### Is a credit at least the same unit within one vendor?

Rarely. CoinMarketCap charges a credit per 250 coins on its latest-listings endpoint, a credit per 100 data points on its history endpoints, and nothing for its ID map. CoinGecko charges 1 credit per REST call, 0.1 per WebSocket response and 10 per webhook delivery. Nansen's endpoints run from 0 credits to 750.

### Do failed requests cost anything?

It depends on the vendor. CoinGecko does not deduct credits for 4xx or 5xx responses but still counts them against the per-minute limit. CryptoQuant charges only when data is returned. Dune does not charge for SQL errors, but a query that times out, hits your cost cap or is cancelled can still consume credits for the compute it already used.

## Sources

1. [Market data endpoints, Spot REST API (request weights per endpoint)](https://developers.binance.com/docs/binance-spot-api-docs/rest-api/market-data-endpoints) — Binance, read 2026-09-26
2. [API v5 reference, Market Data and Public Data rate-limit rules](https://www.okx.com/docs-v5/en/) — OKX, read 2026-09-26
3. [Authentication, Usage Credits](https://docs.coingecko.com/reference/authentication) — CoinGecko, read 2026-09-26
4. [Coin Historical Chart Data by ID, auto-granularity](https://docs.coingecko.com/demo/reference/coins-id-market-chart) — CoinGecko, read 2026-09-26
5. [API changelog, WebSocket and webhook credit charges](https://docs.coingecko.com/changelog) — CoinGecko, read 2026-09-26
6. [API reference, Cryptocurrency endpoints (credit use per endpoint)](https://coinmarketcap.com/api/documentation/pro-api-reference/cryptocurrency) — CoinMarketCap, read 2026-09-26
7. [Market Data API pricing, REST credits](https://www.coinapi.io/products/market-data-api/pricing) — CoinAPI, read 2026-09-26
8. [Market Data API FAQ, credit consumption and the limit parameter](https://www.coinapi.io/products/market-data-api/faq) — CoinAPI, read 2026-09-26
9. [Data Credits](https://docs.glassnode.com/basic-api/api-credits) — Glassnode, read 2026-09-26
10. [How Credits Work](https://docs.dune.com/resources/credits-billing/how-credits-work) — Dune, read 2026-09-26
11. [Pricing FAQs](https://docs.dune.com/learning/how-tos/pricing-faqs) — Dune, read 2026-09-26
12. [API billing](https://docs.dune.com/api-reference/overview/billing) — Dune, read 2026-09-26
13. [Product updates, August 2026 (free plan moves to a 14-day trial)](https://docs.dune.com/docs/changelog) — Dune, read 2026-09-26
14. [Credits & Pricing Guide](https://docs.nansen.ai/getting-started/credits) — Nansen, read 2026-09-26
15. [API Fundamentals, Rate Limits and On-Demand Order Subscriptions](https://docs.amberdata.io/http/http-api-fundamentals) — Amberdata, read 2026-09-26
16. [Rate limiting](https://docs.kaiko.com/rest-api/general/getting-started/rate-limiting) — Kaiko, read 2026-09-26
17. [Pricing and contracts](https://www.kaiko.com/about-kaiko/pricing-and-contracts) — Kaiko, read 2026-09-26
18. [API Credits](https://docs.cryptoquant.com/guides/api-credits) — CryptoQuant, read 2026-09-26

*Last updated 2026-09-26. A reference page, corrected in place — not a dated post.*