CoinMarketCap Keyless Public API: A Developer Guide

Quick answer

• What it is: a curated subset of 35+ live CMC endpoint paths callable with no account and no API key.
• Base path: prefix supported requests with /public-api.
• Coverage: 18 Standard API routes and 17 DEX API routes in the dedicated Keyless Public API reference.
• Response: the same standard response-envelope structure used by the authenticated Pro API.
• Best for: prototyping, response-shape evaluation, agent testing and quick one-off queries.
• Production: remove the /public-api prefix, add your API key header and keep your parsing - normalizing minor field-type differences such as status.error_code.

No API key needed - just try it

Skip the signup. Skip the key. Make a real request against live CoinMarketCap data with zero setup. This one-liner is the same first call CoinMarketCap's own llms.txt index recommends to AI agents: current USD prices for Bitcoin (CMC ID 1) and Ethereum (CMC ID 1027).

# No API key header or account required. Real response.
curl "https://pro-api.coinmarketcap.com/public-api/v1/simple/price?ids=1,1027&convert=USD"

The same call in Python, standard library only:

import json, urllib.request

url = "https://pro-api.coinmarketcap.com/public-api/v1/simple/price?ids=1,1027&convert=USD"
with urllib.request.urlopen(url) as r:
    print(json.load(r))

Example response shape for this request:

{
  "data": [
    { "id": 1, "price": 65434.10259676130 },
    { "id": 1027, "price": 1927.042499464181 }
  ],
  "status": { "error_code": "0", "credit_count": 1 }
}

The key point for developers is the envelope structure: a status object plus endpoint-specific data. Do not hard-code error_code as only one primitive type - some endpoints return "0" as a string, while others may return 0 as a number. Normalize before checking success.

The keyless base URL

All keyless requests start with a single path prefix. No API-key header or authentication is required. The /public-api path signals a keyless call; supported routes accept GET requests without the X-CMC_PRO_API_KEY header.

https://pro-api.coinmarketcap.com/public-api

The endpoint path after the prefix stays the same for supported routes. Use …/public-api/v1/simple/price for evaluation, and …/v1/simple/price once you add an API key. The migration is a base-path change plus an API-key header.

Three live requests to try first

A useful API test starts with responses that could power an actual feature. These three requests cover ranked assets, market-wide context and a CMC-native market indicator.

1. Latest cryptocurrency listings

Ranked cryptocurrency market data for price tables, discovery screens and portfolio experiments.

curl -G "https://pro-api.coinmarketcap.com/public-api/v3/cryptocurrency/listings/latest" \
  --data-urlencode "start=1" --data-urlencode "limit=10" \
  --data-urlencode "convert=USD" -H "Accept: application/json"

2. Global cryptocurrency market metrics

Total market cap, 24-hour volume, Bitcoin dominance, Ethereum dominance and additional market-wide values.

curl -G "https://pro-api.coinmarketcap.com/public-api/v1/global-metrics/quotes/latest" \
  --data-urlencode "convert=USD" -H "Accept: application/json"

3. CMC Crypto Fear and Greed Index

A CoinMarketCap-native market sentiment signal: latest index value, classification and update time.

curl -G "https://pro-api.coinmarketcap.com/public-api/v3/fear-and-greed/latest" \
  -H "Accept: application/json"

What a keyless response looks like

Keyless endpoints return the same standard response-envelope structure as authenticated Pro API endpoints. Build once, and your parsing logic carries directly into authenticated access: a status object, endpoint-specific data and the same high-level success/error envelope.

{
  "status": {
    "timestamp": "2026-07-24T06:53:56.501Z",
    "error_code": "0",
    "error_message": null,
    "elapsed": 31,
    "credit_count": 1
  },
  "data": { /* endpoint-specific payload */ }
}

One implementation detail matters: normalize status.error_code before checking success. Depending on the endpoint, a successful response can use "0" as a string or 0 as a number, and error_message can be an empty string or null. In JavaScript, compare with String(status.error_code) === "0"; in Python, compare with str(status["error_code"]) == "0". That response-envelope consistency is the main developer advantage of keyless evaluation - inspect live data, confirm the JSON shape, then move into authenticated usage without rebuilding the parser.

All keyless endpoints

The Keyless Public API covers a curated subset of Standard API and DEX API routes: ranked assets, market-wide indicators, index data, DEX pairs, liquidity, swap activity, holders and on-chain chart data.

Standard API - 18 keyless endpoints

DEX API - 17 keyless endpoints

Common keyless workflows

Supported keyless routes cover enough real product territory to validate a working prototype: price checks, ranked exports, market overviews, sentiment displays, token discovery and early agent tests.

1. Fetch current crypto prices

Two endpoints serve this, and the right one depends on how much you need back. /v1/simple/price returns a minimal price response by CoinMarketCap ID, which suits quick checks, lightweight scripts and early prototypes. /v3/cryptocurrency/quotes/latest returns richer market quotes and accepts id, slug or symbol, so use it when you need volume, market cap or supply fields alongside the price.

2. Export the top 100 cryptocurrencies

Ranked listings drive CSV exports, dashboards, market snapshots and scheduled reports. Request the latest listings, select the fields your application needs and write the results to a CSV or database table.

curl -G "https://pro-api.coinmarketcap.com/public-api/v3/cryptocurrency/listings/latest" \
  --data-urlencode "start=1" --data-urlencode "limit=100" \
  --data-urlencode "convert=USD" -H "Accept: application/json"

3. Fetch total crypto market cap

Use /v1/global-metrics/quotes/latest when the question is market-wide rather than asset-level: total crypto market cap, total 24-hour volume, Bitcoin and Ethereum dominance. It gives asset-level prices the context of what the broader market is doing.

4. Add market context with Fear and Greed, CMC100, CMC20 and Altcoin Season

CoinMarketCap's proprietary indicators are keyless, latest and historical, which is the clearest thing the keyless catalog offers that raw price data cannot reproduce.

/v3/fear-and-greed/latest
/v3/fear-and-greed/historical
/v3/index/cmc100-latest
/v3/index/cmc100-historical
/v3/index/cmc20-latest
/v3/index/cmc20-historical
/v1/altcoin-season-index/latest
/v1/altcoin-season-index/historical

A market dashboard can combine global metrics with these signals to show both asset-level performance and broader market conditions in one view.

5. Test selected DEX data

The keyless DEX routes let you evaluate how CoinMarketCap represents on-chain tokens, pools and trading activity before adding a key: DEX pair quotes, token detail and token price by contract address, token liquidity, token pools, security detail, swap list and K-line candles. That makes keyless access a practical starting point for early on-chain market-data prototypes.

6. Use keyless data in early AI-agent tests

An agent can retrieve current prices for selected assets, check global market metrics, add Fear and Greed, CMC100, CMC20 or Altcoin Season context, resolve CoinMarketCap cryptocurrency IDs, test selected DEX token or pair data, and validate response shapes, all before a full authenticated setup exists.

Portfolio valuation prototype

Store selected CMC asset IDs and retrieve latest prices. Stable CMC IDs do not depend on ticker symbols alone, which makes them more reliable for portfolio logic than symbol-only matching. /v1/cryptocurrency/map, /v3/cryptocurrency/quotes/latest, /v1/simple/price

Moving from keyless access to the Pro API

A keyless prototype has a direct migration path into authenticated CoinMarketCap Pro API access. The response format follows the same envelope structure, so the request layer changes but your parsing logic does not need to be rebuilt.

# Keyless
curl "https://pro-api.coinmarketcap.com/public-api/v3/cryptocurrency/listings/latest?start=1&limit=10&convert=USD"

# Authenticated Pro API
curl "https://pro-api.coinmarketcap.com/v3/cryptocurrency/listings/latest?start=1&limit=10&convert=USD" \
  -H "X-CMC_PRO_API_KEY: YOUR_API_KEY"

• Drop the prefix. Remove /public-api; the base becomes https://pro-api.coinmarketcap.com.
• Add the API key header. Pass X-CMC_PRO_API_KEY with your authenticated key.
• Keep your response handling. The standard CMC response envelope stays consistent - no rebuilding your parsing or data layer. Normalize status.error_code so your code handles both numeric and string success values.
• Scale as needed. Basic is free; paid plans add higher monthly credits, higher rate limits, broader endpoint access, historical data and commercial licensing.

Keyless evaluation, then scale on a keyed plan

The Keyless Public API is free for supported evaluation requests. It is rate-limited and limited to a curated endpoint subset. Keyless calls share an IP-based rate pool with no published per-key numeric limit, so under load you should expect an occasional HTTP 429; back off and retry with exponential backoff rather than hammering the endpoint. For production usage, use an authenticated CoinMarketCap API plan.

A simple retry pattern in Python, standard library only:

import json, time, urllib.error, urllib.request

def get_with_backoff(url, tries=5):
    for attempt in range(tries):
        try:
            req = urllib.request.Request(url, headers={"Accept": "application/json"})
            with urllib.request.urlopen(req, timeout=15) as resp:
                return json.load(resp)
        except urllib.error.HTTPError as e:
            if e.code == 429 and attempt < tries - 1:
                time.sleep(2 ** attempt)
                continue
            raise

Use backoff for scheduled scripts, dashboards, bots and agent workflows that may repeat calls.

CoinMarketCap's public pricing page lists the free Basic tier with 15,000 monthly API credits and 50 requests per minute. At the time of writing, it also lists paid credit buckets at $29/month for 150,000 monthly credits, $79/month for 450,000, $299/month for 2 million, $699/month for 5 million, and Enterprise/custom limits. Check the live CoinMarketCap API pricing page before publishing plan-name, price or credit-limit claims.

How keyless fits AI agents and developer workflows

The Keyless Public API is useful for more than a human developer testing curl. It also gives agents, coding assistants and automated workflows a low-friction way to inspect live CMC response shapes. CoinMarketCap publishes an llms.txt index for exactly this audience, with the keyless first call and documentation map in a machine-readable form.

A developer or agent can start with a keyless endpoint, confirm the fields, test transformations and then move the same endpoint path into authenticated usage. CoinMarketCap's AI Agent Hub also documents MCP, x402, CMC CLI and Skills as separate paths for AI-assisted workflows. That makes keyless access a first step rather than a dead end - immediate testing now, authenticated plans for production limits, commercial licensing and larger endpoint coverage later.

Frequently asked questions

Keyless Public API cheat sheet

• Keyless base URL: https://pro-api.coinmarketcap.com/public-api
• Add /public-api before supported endpoint paths.
• Keyless requests use GET. Do not send an X-CMC_PRO_API_KEY header on keyless calls.
• Use /v1/simple/price for a minimal price response by CoinMarketCap ID.
• Use /v3/cryptocurrency/quotes/latest for richer latest quotes by id, slug or symbol.
• Use /v3/cryptocurrency/listings/latest for ranked cryptocurrency listings.
• Use /v1/global-metrics/quotes/latest for global market metrics.
• Use /v3/fear-and-greed/latest, the CMC100 and CMC20 index routes and /v1/altcoin-season-index/latest for market context.
• Use the selected DEX routes for token, pair, liquidity, holder, security, swap and K-line workflows.
• Normalize status.error_code before checking success; it can be "0" or 0.
• Back off and retry on HTTP 429.
• Add an API key when you need higher limits, more endpoints or production access.

Start building

Your first live response to a supported endpoint is one curl away - no signup needed. When the product moves past evaluation, the migration to an authenticated plan is a prefix change and a header, with the same response envelope structure throughout.

Developer reference · Confirm endpoint access, keyless paths and plan availability in current CoinMarketCap API documentation.