Zora's API Returns marketCap: 0 — Here's How to Get a Coin's Real Market Cap

You ask the Zora Coins API for a creator’s coins. Every one comes back with a symbol, a holder count, a live USD price… and a market cap of 0. Not missing, not null. Zero. If you print that on a dashboard, every one of those coins reads as dead on arrival.

They are not dead. The price is right there. The marketCap field just does not cover them, and once you know why, the fix is a single multiplication you can trust.

This matters right now because Zora creator coins are where a lot of onchain tooling is being pointed this year: portfolio views, leaderboards, “which of my followers has a coin” scanners. Every one of those tools reads marketCap, and every one of them will quietly mislabel real coins as worthless unless it handles this.

What the API actually hands you

Call /profileCoins (the coins a profile created) and each coin in the response already carries everything you need, in one request, no extra call:

marketCap                 // the number that lies
tokenPrice.priceInUsdc    // USD price per whole coin
totalSupply               // whole coins in existence
poolCurrencyToken         // what the coin's pool trades against
uniqueHolders, volume24h  // the rest of the row

The price and the supply are the two that matter here. They are populated even when marketCap is not, which is the whole reason a fix exists.

When marketCap comes back zero

Here is the pattern, measured against the live API on the day this was written. Three creators, their coins side by side:

The coin pooled against ZORA reported a market cap of $2,639. The two coins with real prices but non-ZORA pools, one against WETH, one against a creator’s own token, both reported 0. The image above is that exact query. This is not a bug you can wait out: it is how the field is defined, and a huge share of creator and content coins are paired with something other than ZORA.

The fix: compute it yourself

Market cap is price times the number of coins. You have both. So do not read the field, derive it:

marketCap = Number(priceInUsdc) * Number(totalSupply)

Two things that will bite you if you skip them. totalSupply here is in whole coins, not wei, so there is no 10^18 to divide out. And priceInUsdc is the price of one whole coin, so the two units line up and the product is dollars. Get either unit wrong and you will be off by eighteen orders of magnitude, which at least fails loudly.

Does the derived number hold up?

Fair question. It would be a poor fix if it disagreed with Zora’s own figure when that figure exists. So check it against the coins where the field is populated. For the ZORA-paired coin above, the API said $2,639 and price times supply gave $2,708. Same ballpark, a few percent apart.

Be honest about that gap, though. The field and the spot price are not always sampled at the same instant, and on a thinly traded coin the two can drift further apart than a few percent. Treat the derived value as a good estimate, not a settled fact: round it, do not print it to the cent, and never dress up a computed number as if it came from an oracle. The point is to replace a 0 that says “worthless” with a figure that says “about this much”.

What it looks like in code

With our Python client, the whole thing is a fallback chain. Read the field, and when it is empty, derive it:

from zora_coins import ZoraCoins

z = ZoraCoins()  # ZORA_API_KEY optional, higher rate limits with one
for coin in z.iter_profile_coins("someartist"):
    price = float(coin.token_price.price_in_usdc or 0)
    supply = float(coin.total_supply or 0)
    field = float(coin.market_cap or 0)
    mcap = field or (price * supply if price and supply else None)
    print(coin.symbol, f"${mcap:,.0f}" if mcap else "—")

No SDK, just fetch? The shape is the same:

const r = await fetch(
  "https://api-sdk.zora.engineering/profileCoins?identifier=someartist&count=20"
);
const coins = /* the coin nodes from r.json() */ [];
for (const c of coins) {
  const price = Number(c.tokenPrice?.priceInUsdc || 0);
  const supply = Number(c.totalSupply || 0);
  const mcap = Number(c.marketCap) || (price && supply ? price * supply : null);
  console.log(c.symbol, mcap ? `$${Math.round(mcap).toLocaleString()}` : "—");
}

Note the last fallback in both: null, rendered as an em dash, not a zero. Some coins genuinely have no USD price, because their pool currency has no route back to USDC. For those, price times supply is also empty, and the right answer is to say so. “—” is honest. “$0” is a lie about a coin that might be worth real money, just not in a currency the API can price today.

That last case is worth sitting with for a second, because it is the same reason a USDC-funded buyer hits “no route” on so many of these coins. The pool currency is not reachable from USDC, so there is neither a price nor a path to trade. A tool that pretends otherwise is not just wrong on a label; it is wrong about whether you can even act.

None of this is exotic. It is one field that does not mean what its name promises, and a one-line derivation that does. But it is exactly the kind of detail that separates a tool people trust from one that confidently prints $0 next to a coin someone paid for. Read the field, fall back to price times supply, fall back to an honest dash, and your numbers will say what is actually true.

We build software that tells you the real number, not the convenient one. That’s what we do at Rebel Studios.