Token API FAQ

Get fast answers to easily integrate and scale with The Graph’s high-performance Token API.

General

Which blockchains are supported by the Token API?

Currently, the Token API supports Ethereum, BNB Smart Chain (BSC), Polygon, Optimism, Base, Unichain, Avalanche, Arbitrum One, and Solana. A full list of supported networks can be found under the Token API column here.

Does the Token API support NFTs?

Yes, The Graph Token API currently supports ERC-721 and ERC-1155 NFT token standards, with support for additional NFT standards planned. Endpoints are offered for ownership, collection stats, metadata, sales, holders, and transfer activity.

Do NFTs include off-chain data?

NFT endpoints currently only include on-chain data. To get off-chain data, use the IPFS or HTTP links included in the NFT item response.

How do I authenticate requests to the Token API, and why doesn’t my API key from The Graph Market work?

Authentication is managed via API tokens obtained through The Graph Market⁠. If you’re experiencing issues, make sure you’re using the API Token generated from the API key, not the API key itself. An API token can be found on The Graph Market dashboard next to each API key. JWT tokens issued by Pinax⁠, a core developer of The Graph, are also supported.

How current is the data provided by the API relative to the blockchain?

The API provides data up to the latest finalized block. This time varies depending on the blockchain. Improvements to provide data closer to the chain head are planned, and feedback is welcome on Discord⁠.

How do I retrieve token prices?

Token prices are available with the Open-High-Low-Close (OHLC) endpoints. For a given time period, "open" represents the price at the start of the time period, "high" represents the highest price during the time period, "low" represents the lowest price, and "close" represents the price at the end of the time period.

Does the Token API support historical token data?

The Token API supports historical token balances with the /historical/balances/evm/{address} endpoint. You can query historical price data by pool at /ohlc/pools/evm/{pool} and by contract at /ohlc/prices/evm/{contract}. Historical balances have a similar OHLC format, but return token balances instead of prices.

What exchanges does the Token API use for token prices?

The Token API currently tracks prices on Uniswap v2, v3, and v4, along with Jupiter, Raydium, and Pump.fun on Solana, with plans to support additional exchanges in the future.

Does the Token API provide a client SDK or client library?

While an official client SDK is not currently available, please share feedback on any SDKs or integrations you would like to see on Discord⁠. Community contributions are welcome to use the OpenAPI document⁠ to build and share their own client libraries.

Are there plans to support additional blockchains in the future?

Yes, more blockchains will be supported in the future. Please share feedback on desired chains on Discord⁠.

Are there plans to support additional use cases?

The Graph ecosystem is actively determining the roadmap for additional use cases. Please provide feedback on specific features you would like prioritized on Discord⁠.

MCP / LLM / AI Topics

Is there a time limit for LLM queries?

Yes. The maximum time limit for each LLM query is 10 seconds.

Is there a known list of LLMs that work with the API?

Yes, Cline, Cursor, and Claude Desktop integrate successfully with The Graph’s Token API + MCP server.

Beyond that, whether an LLM “works” depends on whether it supports the MCP protocol directly (or has a compatible plugin/adapter).

Where can I find the MCP client?

You can find the code for the MCP client in The Graph’s repo⁠.

MCP integration with Claude/Cline/Cursor shows errors like “ENOENT” or “Server disconnected”. How do I fix this?

For “ENOENT” errors, ensure Node.js 18+ is installed and the path to npx/bunx is correct (consider using full paths in config). “Server disconnected” usually indicates authentication or connectivity issues – verify your ACCESS_TOKEN is set correctly and your network allows access to https://token-api.mcp.thegraph.com/sse.

Do I need to use MCP or tools like Claude, Cline, or Cursor?

No, these are optional. MCP is an advanced feature allowing AI assistants to interface with the API via streaming. For standard usage, simply call the REST endpoints with any HTTP client using your JWT. Claude Desktop, Cline bot, and Cursor IDE integrations are provided for convenience but aren’t required.

Advanced Topics

I keep seeing a smart contract with addresses like 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee and 0x000000000000000000000000000000000000. What is this?

The address 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee is a sentinel (placeholder) address used to represent native tokens in EVM smart contracts. Since native tokens (ETH, BNB, AVAX, etc.) exist at the protocol level rather than as smart contracts, DeFi protocols need a placeholder address when their code expects contract addresses for all tokens. This address represents the native token of whatever chain you’re on: ETH on Ethereum and its L2s (Base, Arbitrum, Optimism), BNB on BSC, AVAX on Avalanche, and so forth.

The address 0x0000000000000000000000000000000000000000 was introduced in Uniswap v4 for the same purpose.

Because these addresses have an obvious repetitive pattern, they are clearly not randomly generated, as are other blockchain addresses. These accounts are not real accounts, just arbitrarily chosen low-entropy addresses that developers agreed to use.

I’m getting 403/401 errors. What’s wrong?

Check that you included the Authorization: Bearer <jwt> header with the correct, non-expired token. Common issues include using the API key instead of generating a new JWT, forgetting the “Bearer” prefix, using an incorrect token, or omitting the header entirely. Ensure you copied the JWT exactly as provided by The Graph Market.

Why am I getting 500 errors?

Networks that are currently or temporarily unavailable on a given endpoint will return a bad_database_response, Endpoint is currently not supported for this network error. Databases that are in the process of ingestion will produce this response.

Are there rate limits or usage costs?

During Beta, the Token API has a generous allowance of free usage. There are no specific rate limits, but reasonable throttling exists to prevent abuse. High request volumes may trigger HTTP 429 errors. Monitor official announcements for future pricing changes after Beta.

What do I do if I notice data inconsistencies in the data returned by the Token API?

If you notice data inconsistencies, please report the issue on our Discord⁠. Identifying edge cases can help make sure all data is accurate and up-to-date.

How do I specify a network?

You can query which networks are available with this endpoint⁠. Take note that the network IDs differ between the Token API and Subgraphs. For EVM networks, use EVM endpoints with the optional network_id parameter (e.g., mainnet, bsc, base, arbitrum-one, optimism, polygon, unichain) to target a specific chain. Without this parameter, the API defaults to Ethereum mainnet.

To query Solana, use the SVM endpoints.

Why do I only see 10 results? How can I get more data?

Endpoints cap output at 10 items by default. Use pagination parameters: limit and page (1-indexed) to return more results. For example, set limit=50 to get 50 results, and increment page for subsequent batches (e.g., page=2 for items 51-100).

It is currently possible for the total number of pages to be inexact. This is because the backend provides only an approximation of the number of records in order to improve response time. To avoid getting confused by this approximation, make sure to continue fetching next pages until there is no more data, or the endpoint returns an error.

How do I fetch older transfer history?

The Transfers endpoint defaults to 30 days of history. To retrieve older events, increase the age parameter up to 180 days maximum (e.g., age=180 for 6 months of transfers). Transfers older than 180 days cannot be fetched in a single call.

What does an empty "data": [] array mean?

An empty data array means no records were found matching the query – not an error. This occurs when querying wallets with no tokens/transfers or token contracts with no holders. Verify you’ve used the correct address and parameters. An invalid address format will trigger a 4xx error.

Why is the JSON response wrapped in a "data" array?

All Token API responses consistently wrap results in a top-level data array, even for single items. This uniform design handles the common case where addresses have multiple balances or transfers. When parsing, be sure to index into the data array (e.g., const results = response.data).

Why are token amounts returned as strings?

Large numeric values (like token amounts or supply) are returned as strings to avoid precision loss, as they often exceed JavaScript’s safe integer range. Convert these to big number types for arithmetic operations. Fields like decimals are provided as normal numbers to help derive human-readable values.

What format should addresses be in?

For EVM addresses, the API accepts hex addresses with either 42 or 40 characters, with or without the 0x prefix. The endpoint is case-insensitive, so both lower and uppercase hex characters work. Ensure EVM addresses are exactly 42 characters, or 40 if you remove the prefix. For contract queries, use the token’s contract address. For balance/transfer queries, use the wallet address.

SVM addresses are base58-encoded strings that are typically 32-44 characters long. They contain a mix of uppercase letters, lowercase letters, and numbers. Unlike Ethereum addresses which are hexadecimal and start with “0x”, Solana addresses don’t have a consistent prefix pattern.

Do I need special headers besides authentication?

While recommended, Accept: application/json isn’t strictly required as the API returns JSON by default. The critical header is Authorization: Bearer <token>. Ensure you make a GET request to the correct URL without trailing slashes or path typos (e.g., use /balances/evm/{address} not /balance).

Is the Token API part of The Graph’s GraphQL service?

No, the Token API is a separate RESTful service. Unlike traditional subgraphs, it provides ready-to-use REST endpoints (HTTP GET) for common token data. You don’t need to write GraphQL queries or deploy subgraphs. Under the hood, it uses The Graph’s infrastructure and MCP with AI for enrichment, but you simply interact with REST endpoints.