An Arc blockchain API can tell you which tokens were created and which ones traded. In five hours on Arc mainnet on September 16, 2026, verified Tolly and RadarDEX contracts created 744 tokens. Only 544 had recorded swaps before the cutoff. If your app lists every new token as an active market, that gap matters.
Arc is Circle’s Layer 1 chain. It supports the EVM and uses USDC for gas. Circle announced its public mainnet launch on September 16. For a token tracker, the work starts with matching launch events to trades. Prices come next, along with a few unit and filtering errors that are easy to miss.
An early trading snapshot on September 16
The measured window runs from 06:00 UTC up to 11:00 UTC on September 16, 2026. It includes the start and excludes the end, covering five full hours. The exact time of public opening was not verified, so these figures do not measure elapsed time since launch.
Across 35,481 blocks with no gaps, Arc recorded 1,762,673 transactions from 90,202 distinct sending addresses. That total includes 161,957 failed transactions. Addresses can belong to bots or the same person; the address count is not a count of users.
The launchpad study has a smaller scope. It includes tokens created during those five hours by verified Tolly or RadarDEX launch contracts, then counts their swaps after creation and before the cutoff.
Source: Bitquery-indexed Arc data, September 16, 2026, 06:00–11:00 UTC; end time excluded. Chart prepared with AI assistance.
Tolly created 613 tokens; 450 had swaps before the cutoff. Those tokens recorded 5,965 swaps from 1,114 distinct sending addresses, with 216,050.69 USDC in gross turnover.
RadarDEX created 131 tokens; 94 had swaps. Its group recorded 881 swaps from 204 distinct sending addresses, with 41,073.35 USDC in gross turnover.
Tolly led this group by launch count and trading volume. Tokens created near the cutoff had less time to trade, though, and both totals include swaps made in the transaction that created a token. Some wallets may have traded on both pads.
Giving each token the same time to trade helps. Among launches with a full hour of data, median turnover during that first hour was 26.40 USDC for Tolly and 13.91 USDC for RadarDEX. Tokens with no swaps counted as zeros. The median token had modest activity despite the larger group totals.
The two groups together recorded 257,124.04 USDC in turnover. All indexed, valid DEX swaps of fungible tokens in the same window recorded about 96.34 million USDC in turnover. The new Tolly and RadarDEX tokens made up about 0.27% of that broader total. Older tokens and other markets sit outside this launch cohort. These figures cannot rank every Arc launchpad.
Turnover counts the USDC amount once per swap. It measures trading flow; it does not measure deposits, profit, or unique capital. Repeated trading can move the same funds many times.
Over time, transactions rose from 273,589 in 06:00–07:00 UTC to 407,408 in 10:00–11:00 UTC. That is a 48.9% increase between the first and last full hours measured. The counts alone do not tell us why.
Source: Bitquery-indexed Arc blocks, checked against transaction records. The five-hour total includes failed transactions. Chart prepared with AI assistance.
Choose the right Circle blockchain API
“Circle blockchain API” is a broad search term. Circle’s wallet and payments services cover tasks that differ from reading Arc market data. A token feed needs a way to search the chain’s events and swaps.
A node RPC is useful for chain state and sending transactions. Arc mainnet uses chain ID 5042; testnet uses 5042002. Check which chain you need before reusing an address or saved query from a testnet app. The Arc RPC guide lists the networks and methods you can call.
An indexed API reduces the work needed to search past events or fetch decoded trades. The examples below use the Bitquery GraphQL endpoint at streaming.bitquery.io/graphql. Send an HTTP POST with a JSON body that holds the query, a JSON content-type header, and your token in the authorization header as a Bearer token. Keep that token on your server.
For recent trades, use Trading.Trades. Use Trading.Tokens for a token’s candles and Trading.Pairs when the price must belong to one pair or pool. Find launches with EVM.Events, since a token launch event and a trade tell you different things.
Leave the dataset setting unset for these Trading examples. Check how much past data your plan can return before promising users a full history. A query that returns a recent row does not prove that you can fetch all prior trades for every market.
There is also a unit trap on Arc. USDC has a native form with 18 decimals and an ERC-20 form with six decimals at 0x3600000000000000000000000000000000000000. Both expose the same balance. Read the decimals for the form you received; do not add the balances as separate assets. Arc explains this in one token, two interfaces.
Find new Tolly token launches
Start with a known contract and the verified signature of its launch event. This query finds the latest 20 matching Tolly events from the previous 24 hours. It requires success and excludes removed logs and reverted calls.
query {
EVM(network: arc) {
Events(
limit: {count: 20}
orderBy: {descending: Block_Time}
where: {
Block: {Time: {since_relative: {hours_ago: 24}}}
TransactionStatus: {Success: true}
Call: {Success: true, Reverted: false}
LogHeader: {
Address: {in: [“0xcad7ee36ac193bf2eddb7b3e2736c5bdb8269c8b”]}
Removed: false
}
Log: {Signature: {SignatureHash: {is: “875522b092d9e19a1de359e4bd218090d582fa521c9733889acf1a5ff1941255”}}}
}
) {
Block {Number Time}
Transaction {Hash From}
LogHeader {Address Index}
Log {Signature {SignatureHash}}
Topics {Hash}
}
}
}
The factory address was matched against the mainnet settings served by Tolly’s own site. RadarDEX was checked against the contract settings served by its own site. A matching token symbol would not provide that proof.
In the returned Tolly event, the token address is the final 20 bytes of the second topic, Topics[1] when counting from zero. Keep the emitting contract, transaction hash, and log index with the decoded token address. They let you inspect the source event if a label looks wrong.
Save those rows as new token records, then query each token’s trades to fill in its activity. If the trade query returns nothing, check your filters before deciding what it means. The creation event remains valid even when no matching swaps appear.
Query recent Arc trades and stream new swaps
The next query uses a Tolly token found in the snapshot as an example. Replace its token ID with your target token’s ID, keeping the chain prefix. The filter checks both Token and QuoteToken, and limits this example to the Uniswap protocol family.
query {
Trading {
Trades(
limit: {count: 20}
orderBy: {descending: Block_Time}
where: {
Block: {Time: {since_relative: {hours_ago: 24}}}
Pair: {Market: {NetworkBid: {is: “bid:arc”}, ProtocolFamily: {is: “Uniswap”}}}
any: [
{Pair: {Token: {Id: {is: “bid:arc:0xc17c325c02b65e35827ceed47c2ac581f45c251e”}}}}
{Pair: {QuoteToken: {Id: {is: “bid:arc:0xc17c325c02b65e35827ceed47c2ac581f45c251e”}}}}
]
}
) {
Block {Time}
TransactionHeader {Hash Index}
Trader {Address}
Side
Amounts {Base Quote}
AmountsInUsd {Quote}
PriceInUsd
Pair {
Token {Id Symbol}
QuoteToken {Id Symbol}
Market {Network Protocol}
Pool {Address Id}
}
}
}
}
Keep the pair fields, even if your screen shows only price and time. They help catch a common error: reading a price as though the selected token is always the base. The meaning of Side, base amount, and price depends on that role. If your token appears as QuoteToken, check what PriceInUsd measures before using it as the token’s price.
For a trade quoted in USDC, the executed unit price is the quote amount divided by the base amount. Keep the full decimal values when working with amounts. A rounded display price should not become the input to a volume total.
The Trading Trades guide explains the response fields. One transaction can contain several trades, so its hash alone is not a safe key for merging trade rows. Keep the source details needed to tell swaps apart and inspect repeated rows before dropping them.
For incoming Arc trades, use this subscription. It has a broader scope than the HTTP example: it filters the Arc network but does not restrict the protocol family. Check the returned market fields before treating every result as a Uniswap trade.
Open the live Arc trade subscription
subscription {
Trading {
Trades(where: {Pair: {Market: {Network: {is: “Arc”}}}}) {
Block { Time }
TransactionHeader { Hash }
Trader { Address }
Side
Amounts { Base Quote }
AmountsInUsd { Quote }
Price
PriceInUsd
Pair {
Market { Network Protocol ProtocolFamily }
Pool { Address Id }
Token { Id Address Symbol }
QuoteToken { Id Address Symbol }
}
}
}
}
Use the secure WebSocket endpoint, wss://streaming.bitquery.io/graphql, with the token setup in the Bitquery WebSocket guide. The test for this draft used the graphql-transport-ws protocol. Supply your token, send connection_init, wait for connection_ack, then send the query in a subscribe message.
On September 16, all four printed examples passed schema checks and returned data. The live feed sent 32 rows during the short test, after connection_ack. That confirms data delivery during the test; it does not promise a fixed event rate or future uptime.
A live app also needs to recover when the link drops. Store the last block time you processed, wait briefly, then connect again. Query a recent time range that overlaps the data you hold. Match the replay with stored trades before updating totals. A fresh link by itself gives no proof that the missing interval was filled.
Build Arc token price charts
For a token price chart, this query requests up to 120 rows of 60-second USD candles from the previous 24 hours.
query {
Trading {
Tokens(
limit: {count: 120}
orderBy: {descending: Block_Time}
where: {
Token: {Id: {is: “bid:arc:0xc17c325c02b65e35827ceed47c2ac581f45c251e”}, NetworkBid: {is: “bid:arc”}}
Block: {Time: {since_relative: {hours_ago: 24}}}
Interval: {Time: {Duration: {eq: 60}}}
Price: {IsQuotedInUsd: true}
}
) {
Token {Id Symbol}
Interval {Time {Start End Duration}}
Price {IsQuotedInUsd Ohlc {Open High Low Close}}
Volume {Base Usd}
}
}
}
The test returned 27 rows. A limit of 120 is only a ceiling; it does not promise two full hours of prices. Check for gaps and repeated intervals before plotting, and confirm how much past data the query can return.
Use the interval start to place each point on the time axis. Sort the response from oldest to newest for a chart. Inspect rows with the same token and interval before merging them, and allow the current candle to change as new trades arrive.
These prices draw on trades across pools. A chart for one specific pool needs a query at the pair level. Keep both pool address and pool ID to track a market; a shared contract address alone may not tell its pools apart. The token price guide explains the fields.
A practical first build is one token page: its creation event, followed by the trades it attracts. Add a price chart after the token IDs and units agree. Those checks will still matter as new pads and tokens appear in the feed.
Start from the Arc mainnet API docs for current examples.
Arc blockchain API: query Circle’s chain with Bitquery was originally published in Coinmonks on Medium, where people are continuing the conversation by highlighting and responding to this story.