How to Get Arc Chain Token Prices and Market Data With an API

Circle, the company behind USDC, launched Arc, a Layer-1 blockchain built for stablecoin finance. Developers now need a reliable way to access Arc token prices, market caps, and liquidity data programmatically.

This guide shows you how to use the CoinGecko and GeckoTerminal APIs to retrieve price and market data for any token deployed on Arc, whether it is a stablecoin, DeFi token, or future native network asset.

Note: CoinGecko has unified its API with the GeckoTerminal API, so standard market data and onchain DEX data are now accessible through a single CoinGecko API key. You don't need a separate account or API key.

Prerequisites

You'll need a CoinGecko API key. If you don't have one, follow the guide to get a free Demo API key. The Demo plan provides everything you need to follow this guide and run the examples.

Your API key type must match the base URL and authentication header used in your requests. All examples in this guide use the Demo configuration. For paid plans, use the Paid configuration instead.

To run the full script included at the end of this guide, you'll need Python 3.8+. Install the official SDK and requests:

💡 Prefer less setup? You can call these endpoints with CoinGecko's official Python SDK or TypeScript SDK instead of raw HTTP requests. The SDK handles the base URL, headers, and authentication for you, so there is less boilerplate to write.

How to Identify a Token on Arc Chain by Contract Address

CoinGecko API and GeckoTerminal API provide two ways to look up a token on Arc Chain by contract address. Both calls use Circle Wrapped BTC (cirBTC) as the example token.

Coin Data by Token Address

/coins/{asset_platform_id}/contract/{contract_address} returns full metadata once a token has been reviewed and listed.

Here’s what the response looks like:

{

  "id": "circle-wrapped-btc",

  "symbol": "cirbtc",

  "name": "Circle Wrapped BTC",

  "asset_platform_id": "ethereum",

  "platforms": {

    "arc": "0x171a4217b86a807a64eb94757db6849fb4bdbaa0",   

    "ethereum": "0x72dfb2e44f59c5ad2bafe84314e5b99a7cd5075e"

  }

Token Data by Token Address

/onchain/networks/{network}/tokens/{address} automatically indexes tokens once they have an active liquidity pool.

Here’s what the response looks like:

{

  "data": {

    "id": "arc_0x171a4217b86a807a64eb94757db6849fb4bdbaa0",

    "type": "token",

    "attributes": {

      "address": "0x171a4217b86a807a64eb94757db6849fb4bdbaa0",

      "name": "Circle Wrapped BTC",

      "symbol": "cirbtc",

      "decimals": 8,

      "coingecko_coin_id": "circle-wrapped-btc",

      "price_usd": "75748.9838130729",

      "fdv_usd": "9156840.63875057",

      "market_cap_usd": null

    }

  }

}

How to Get a Coin's ID and Metadata on Arc Chain

The token's id comes from the Coin Data by Token Address response in the previous section. In this example, the id is circle-wrapped-btc. This id is used with other endpoints that require a coin ID. The contract address should not be used in place of the id, and the id should be resolved from the contract address rather than hardcoded.

Coin Data by ID

/coins/{id} returns the token's metadata, including the platforms field, which lists the chains where the token is deployed. USDC, which is used to pay gas fees on Arc is deployed on 30+ chains:

The API returns the following:

{

  "id": "usd-coin",

  "symbol": "usdc",

  "name": "USDC",

  "platforms": {

    "ethereum": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",

    "base": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",

    "solana": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",

    "arc": "0x3600000000000000000000000000000000000000"

  }

}

Token Info by Token Address

/onchain/networks/{network}/tokens/{address}/info provides an independent way to verify whether a token has been reviewed and listed on CoinGecko using its contract address.

It also includes the image object (logo thumbnails), description, websites, social links, categories, and holder distribution, providing the metadata needed to build a fuller token profile beyond price and market data.

The API returns the following:

{

  "data": {

    "attributes": {

      "name": "Circle Wrapped BTC",

      "symbol": "cirbtc",

      "coingecko_coin_id": "circle-wrapped-btc",

      "gt_score": 71.58,

      "gt_verified": true

    }

  }

}

How to Fetch Real-Time Price and Market Cap for Tokens on Arc Chain

For tokens already listed on CoinGecko, use /simple/token_price/{id} to retrieve current price and market cap. For tokens that aren't listed yet, use /onchain/simple/networks/{network}/token_price/{addresses} to access onchain price and market data

Coin Price by Token Addresses

/simple/token_price/{id} where {id} is the asset platform ID.

Here’s what the response looks like:

{

  "0x171a4217b86a807a64eb94757db6849fb4bdbaa0": {

    "usd": 75772,

    "usd_market_cap": 0,

    "usd_24h_vol": 6210950.34,

    "usd_24h_change": null

  }

}

Token Price by Token Addresses

/onchain/simple/networks/{network}/token_price/{addresses} for tokens with active onchain markets.

Here’s what the response looks like:

{

  "data": {

    "attributes": {

      "token_prices": {

        "0x171a4217b86a807a64eb94757db6849fb4bdbaa0": "75748.9838130729"

      },

      "market_cap_usd": {

        "0x171a4217b86a807a64eb94757db6849fb4bdbaa0": "0.0"

      }

    }

  }

}

How to Retrieve Historical Price Data for Arc Chain Tokens

CoinGecko API provides two endpoints for historical token data, depending on whether you need time-series data or OHLC data.

For line charts, dashboards, or alerts: Coin Historical Chart Data by Token Address ( /coins/{asset_platform_id}/contract/{contract_address}/market_chart) returns simple [timestamp, value] pairs for price, market cap, and volume.

The API returns the following:

{

  "prices": [

    [1789524000000, 75639.72013073205],

    [1789527600000, 75744.87899694742],

    [1789531200000, 75680.90709845201]

  ]

}

Even though days=7 was requested, the response only contains 16 hourly points spanning roughly 14 hours (from 02:00 UTC to 16:15 UTC on September 16, 2026) — because that's all the trading history that exists. This is exactly the shorter-history behavior newly launched Arc tokens will show until more trading history accumulates.

Each timestamp is in milliseconds. Convert it to a readable date and time before plotting or printing it. Here’s the prices array in code and as a chart:

For candlestick charts or technical-analysis indicators: Coin OHLC Chart by ID (/coins/{id}/ohlc) returns [timestamp, open, high, low, close]per interval. The candle interval is determined by the requested date range: 30-minute candles for 1–2 days, 4-hour candles for 3–30 days, and 4-day candles for 31+ days.

The API returns the following:

[

  [1789531200000, 75640.0, 75883.0, 75632.0, 75684.0],

  [1789545600000, 75681.0, 75906.0, 75587.0, 75632.0],

  [1789560000000, 75620.0, 76054.0, 75283.0, 76053.0],

  [1789574400000, 76053.0, 76087.0, 75413.0, 75791.0]

]

Each candle represents the open, high, low, and close (OHLC) for that interval, rather than a single price point:

If you need an exact date range with a fixed interval instead of auto-selected granularity, use Coin OHLC Chart within Time Range by ID (/coins/{id}/ohlc/range). It requires the Analyst plan or above.

For newly launched tokens on Arc Chain, historical data will build up as trading activity begins. If only a few hours or days of data are available, the response will reflect that shorter history. With auto-selected granularity, the API automatically adjusts the candle interval to match the requested date range, giving you finer-grained data when the available history is still limited.

💡 Token not listed on CoinGecko yet? The endpoints above use a CoinGecko id for listed tokens. For unlisted tokens, Pool OHLCV Chart by Pool Address and Token OHLCV Chart by Token Address let you retrieve candlestick data using a pool or token address.

How to Find Liquidity Pools for Tokens on Arc Chain

Top Pools by Token Address (/onchain/networks/{network}/tokens/{token_address}/pools) returns the pools where a token trades, ranked by liquidity. Price data typically comes from these liquidity pools on decentralized exchanges.

The endpoint returns:

{

  "data": [

    {

      "attributes": {

        "name": "cirbtc / USDC 0.01%",

        "address": "0x82916bee18fcef517b26c72d7cb5f13694e1db41",

        "reserve_in_usd": "10941775.8789",

        "fdv_usd": "9178493.07404261"

      }

    }

  ]

}

If you need to filter pools across a network by liquidity, volume, age, or other criteria, Pool Megafilter (/onchain/pools/megafilter) lets you filter across thousands of pools in a single request. It requires the Analyst plan or above.

This can be useful when evaluating newly launched tokens, where liquidity may be limited and prices can vary between pools. The checks parameter supports additional screening, including no_honeypot, which excludes pools flagged by GoPlus and De.Fi Scanner, and good_gt_score, which requires a GT Score of at least 75.

The GT Score ranges from 0 to 100 and combines market activity and liquidity with security and supply signals, including honeypot status, buy and sell taxes, unverified contracts, mint or freeze authority, and supply concentration. The score is calculated at the pool level, so the same token can have different scores across pools.

These capabilities help developers quickly identify pools that meet specific liquidity, market activity, and security criteria, making Megafilter useful for monitoring newly launched tokens across multiple networks.

What to Do If a Token on Arc Chain Isn't Indexed Yet

If a token isn’t listed on CoinGecko, the API response is different from a standard token lookup. Here’s a real example using a currently unlisted token on Arc to show the actual response.

A contract-address lookup using CoinGecko's API returns a 404 when the token isn't listed:

The endpoint returns:

{

  "error": "coin not found"

}

The same token already exists on GeckoTerminal because its onchain indexing doesn't require a review. Tokens are indexed automatically once a pool exists:

The endpoint returns:

{

  "data": {

    "attributes": {

      "name": "Arc Inu",

      "symbol": "AI",

      "image_url": null,

      "websites": [],

      "description": null,

      "coingecko_coin_id": null,

      "gt_score": 39.8,

      "gt_verified": false,

      "is_honeypot": "unknown"

    }

  }

}

The gt_score and gt_verified fields provide additional context about a token without affecting whether it is indexed. Tokens remain queryable for price and pool data regardless of their gt_score or gt_verified value. GeckoTerminal automatically indexes tokens and syncs basic information from onchain and third-party sources when they launch, making it useful for accessing market data for newly launched tokens before they are listed on CoinGecko.

A gt_verified: true value means CoinGecko has verified the submitted token information, including its website, social links, and contract address. This confirms the information provided by the project but does not represent an endorsement or guarantee the project's safety. See GT Verified Badge for details.

For Arc Inu, image_url, websites, and description return null because no token information has been submitted or synced yet. Other unverified tokens may already have automatically synced information in these fields. The is_honeypot provides an additional security signal and may return "unknown" when there is no definitive result. To exclude pools flagged as honeypots, use Megafilter endpoint's checks=no_honeypot parameter.

How to Build a Reusable Token Lookup Script

The official CoinGecko Python SDK combines the steps above into a single workflow. Pass in a contract address and network to retrieve token identification and metadata. You can also retrieve price, historical data, and pool information for tokens on Arc Chain.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

import os
from coingecko_sdk import Coingecko

client = Coingecko(
    demo_api_key=os.environ["COINGECKO_DEMO_API_KEY"],
    environment="demo",
)

def lookup_token(asset_platform_id: str, network_id: str, contract_address: str) -> None:
    """Look up a token by contract address across CoinGecko and GeckoTerminal."""

    # Step 1: try CoinGecko's curated database first
    try:
        coin = client.coins.contract.get(contract_address, id=asset_platform_id)
        coingecko_id = coin.id
        print(f"Listed on CoinGecko as '{coingecko_id}' ({coin.name})")
    except Exception:
        coingecko_id = None
        print("Not yet listed on CoinGecko's curated database.")

    # Step 2: always check GeckoTerminal, which indexes independently and faster
    onchain_info = client.onchain.networks.tokens.info.get(
        contract_address, network=network_id
    )
    token_attrs = onchain_info.data.attributes
    print(f"Onchain as '{token_attrs.symbol}': GT Score {token_attrs.gt_score:.1f}, "
          f"honeypot status: {token_attrs.is_honeypot}")

    # Step 3: current price and market cap
    if coingecko_id:
        price = client.simple.token_price.get_id(
            asset_platform_id,
            contract_addresses=contract_address,
            vs_currencies="usd",
            include_market_cap=True,
        )
        print("Price (CoinGecko):", price)
    else:
        onchain_price = client.onchain.simple.networks.token_price.get_addresses(
            contract_address, network=network_id, include_market_cap=True,
            mcap_fdv_fallback=True,
        )
        print("Price (GeckoTerminal, FDV fallback):", onchain_price.data.attributes.token_prices)

    # Step 4: historical data, only if listed on CoinGecko
    if coingecko_id:
        history = client.coins.contract.market_chart.get(
            contract_address, id=asset_platform_id, vs_currency="usd", days="7",
        )
        print(f"{len(history.prices)} historical price points over the last 7 days")

    # Step 5: pools and liquidity
    pools = client.onchain.networks.tokens.pools.get(
        contract_address, network=network_id, include="base_token,quote_token",
    )
    for pool in pools.data[:3]:
        print(f"Pool: {pool.attributes.name}: ${float(pool.attributes.reserve_in_usd):,.0f} liquidity")

if __name__ == "__main__":
    # Circle Wrapped BTC (cirBTC) on Arc Chain — Circle's institutional
    # wrapped-BTC asset, live on Arc since launch.
    lookup_token(
        asset_platform_id="arc",
        network_id="arc",
        contract_address="0x171a4217b86a807a64eb94757db6849fb4bdbaa0",
    )

Running this script produces output like the following:

Listed on CoinGecko as 'circle-wrapped-btc' (Circle Wrapped BTC)

Onchain as 'cirbtc': GT Score 71.6, honeypot status: unknown

Price (CoinGecko): {'0x171a4217b86a807a64eb94757db6849fb4bdbaa0': TokenPriceGetIDResponseItem(last_updated_at=None, usd=75784.0, usd_24h_change=None, usd_24h_vol=None, usd_market_cap=0.0)}

16 historical price points over the last 7 days

Pool: cirbtc / USDC 0.01%: $10,942,823 liquidity

Pool: PIZZA / cirbtc: $18,318 liquidity

Pool: cirbtc / USDC: $29,393 liquidity

Conclusion

CoinGecko API gives you the tools to identify tokens on Arc Chain, retrieve their metadata, and access current and historical market data. When a token isn't listed on CoinGecko yet, the onchain endpoints can still return its price, market cap, and historical data directly from onchain sources. Pool data provides additional context for evaluating the reliability of prices for newly launched tokens.

You can also track newly created pools across Arc Chain and 260+ other networks in real time, check token holder concentration as an additional signal when evaluating new tokens, or check out our API troubleshooting guide to handle common errors and edge cases.

Ready to start building? Sign up for a free Demo API plan and start building with CoinGecko. As your application grows, upgrade to a paid API plan for higher rate limits, more call credits, access to more data delivery methods like Webhooks and WebSocket, and exclusive endpoints such as Pool Megafilter for advanced pool discovery and filtering.