Crypto Bubbles API: where the data really comes from and how to build your own board

Straight answer

Does Crypto Bubbles have a public API?

Let's start with what most people came here for. The official cryptobubbles.net site does not advertise a public, documented developer API. There's no developer portal, no request pricing, no endpoint documentation. Crypto Bubbles is a consumer product — a visualization covering more than a thousand coins, refreshed automatically, available in the browser and in mobile apps (that's how its own site presents it) — not a data warehouse.

We say that plainly because the web is full of tutorials implying otherwise, or worse, of pages posing as "the official Crypto Bubbles API" with keys for sale. Treat those the way you'd treat a sideloaded APK from a forum: somebody is trying to sell you something the maker doesn't offer. The rule from our app download guide applies here too — the only source of truth about the official product is cryptobubbles.net.

And now the good news: you don't need any particular app's API to build your own bubble board. Bubbles are just a way of drawing data the market publishes anyway. You need four numbers per coin and about forty lines of code. The rest of this page is about exactly that.

How bubble apps get their data: a three-link chain

Every market visualization — from bubbles to the heatmaps we cover in the market map guide — sits on the same supply chain:

• Link 1: exchanges. The original source of every price is a specific exchange's order book. That's where trades actually happen, and "the price of bitcoin" is in reality dozens of prices from dozens of venues, differing by fractions of a percent.
• Link 2: aggregators. Data services collect quotes from hundreds of exchanges, average them (usually volume-weighted), add circulating supply, and publish finished metrics: market cap, rank, percentage changes over standard time windows.
• Link 3: applications. Visualizations like a bubble board pull normalized JSON from aggregators and convert numbers into geometry and color. All the "magic" happens in the user's browser.

That split has a practical consequence for your project: you can tap in at any link. An aggregator gives you convenience — one endpoint, thousands of coins, market caps already computed. An exchange gives you freshness — data straight from the book, no intermediary and no averaging lag, but only for pairs listed on that one venue. Mature projects often combine both: the aggregator for ranking and market cap, the exchange for real-time prices.

Workshop

Mini tutorial: your own bubble board in one evening

Below is a JavaScript skeleton — deliberately simplified pseudocode, to be completed with your chosen API's address. The logic has three stages: fetch tickers, turn market cap into a radius and percentage change into a color, then draw.

// 1. Fetch the data (REST, refresh every 60 s)
async function fetchCoins() {
  const res = await fetch(API_URL + '/tickers?limit=100'); // API key in the header, never in the code
  const coins = await res.json();
  return coins.filter(c => c.volume24h > 1_000_000); // cut out the dead coins
}

// 2. Scaling: radius ~ square root of market cap
//    (the eye compares the AREA of circles, not the radius!)
function radius(cap, maxCap) {
  const R_MAX = 90, R_MIN = 6;
  return Math.max(R_MIN, R_MAX * Math.sqrt(cap / maxCap));
}

// 3. Color: green for gains, red for losses,
//    saturation grows with the absolute change
function color(changePct) {
  const sat = Math.min(Math.abs(changePct) / 15, 1); // full saturation from ±15%
  return changePct >= 0
    ? `rgba(34, 197, 94, ${0.35 + 0.65 * sat})`
    : `rgba(239, 68, 68, ${0.35 + 0.65 * sat})`;
}

// 4. Drawing: canvas + a simple repulsion simulation
setInterval(async () => {
  const coins = await fetchCoins();
  const maxCap = Math.max(...coins.map(c => c.marketCap));
  draw(coins.map(c => ({
    label: c.symbol,
    r: radius(c.marketCap, maxCap),
    fill: color(c.change24h)
  })));
}, 60_000);

Two notes that go beyond the skeleton. First, layout physics: to stop bubbles overlapping, use an off-the-shelf force simulation — in d3 that's the d3-force module with collisions (forceCollide); on raw canvas a loop that pushes intersecting circles apart is enough. Second, the square root in the radius function is not a stylistic choice: the area of a circle grows with the square of the radius, so scaling the radius linearly would make a coin 100 times larger occupy 10,000 times more screen. Half the amateur boards on the web make exactly this mistake and visually lie about market proportions — and proportions are the entire point of this visualization, as we discuss at length in the guide to what Crypto Bubbles is.

A third note for whoever ships this to real users: cap the work, not just the data. A thousand animated circles at 60 frames per second will melt a mid-range phone if every frame recomputes collisions from scratch. The usual fixes are unglamorous and effective — run the force simulation at 20 ticks per second while drawing at 60, freeze the simulation once positions stop moving, and stop the loop entirely when the tab is hidden via the Page Visibility API. Users notice battery drain long before they notice your color scale.

Choosing a data API: six criteria

A separate word about exchange APIs as a first-class source: if your project touches trading — backtesting, a bot, monitoring your own orders — an exchange API isn't an alternative so much as a requirement, because only it gives you the order book, trade history and the ability to place orders. Documentation from mature exchanges offers REST and WebSocket, sandboxes for testing, and client libraries in the popular languages. It's also the shortest route from the theory on this page to a real data stream.

Information about the official Crypto Bubbles app's features (coin coverage, platforms, refresh frequency) is attributed to cryptobubbles.net (as of July 2026).

Caching and rate-limit hygiene

The fastest way to get throttled is to treat an API like a local database. Three habits keep you well inside any free tier. Fetch once, fan out many: if your page has three widgets that need ticker data, fetch it once into a shared store rather than three times. Put a cache between you and the provider: even a 30-second in-memory cache on your own tiny backend collapses a hundred visitors into one upstream request — and it means your board keeps rendering when the provider has an outage. Back off on errors: when you get a 429 or a 5xx, retry with exponential backoff and jitter, never in a tight loop. A retry storm from your own client looks exactly like an attack from the provider's side, and gets treated as one.