About FreeAPI.watch

FreeAPI.watch is a live-monitored directory of free public APIs, maintained by one developer. Every hour a Cloudflare Worker pings each of the 133 tracked APIs and records whether it responds, how fast, and whether its free tier has quietly changed. The site rebuilds daily with the latest data.

The goal is simple: when a developer searches for a free API in 2026, they should find one that actually works today — not a five-year-old GitHub list with broken links, dead domains, or APIs that have silently moved to paid plans.

The origin story

In April 2026 I was building a side project that needed a free weather API. I went to the public-apis GitHub repository — the canonical community list, ~350,000 stars at the time — and started clicking through the weather section. Of the first ten entries I checked, four were dead (404 on the documentation URL), two had quietly moved to paid plans with no update to the GitHub list, and one required a credit card during signup that the listing didn't mention.

I spent an evening building a Cloudflare Worker that pinged each entry hourly to verify it was still alive. That afternoon project turned into FreeAPI.watch over the following weekends. The site launched publicly in May 2026.

Who maintains this

I'm A10A, an independent developer based in Europe. I build small web tools as side projects when I find a problem I'd want solved for myself. FreeAPI.watch is the largest of those projects to date — built in spare time, run as a passion project with monetization that's transparent and sits alongside (not in front of) the data.

Reach me at:

• Email: [email protected]
• Community discussions on GitHub
• Dev.to

How the monitoring actually works

Each API in the catalog has a documented health endpoint (the lightest available call that confirms the service is responding). Every hour, a Cloudflare Worker fires an HTTP request to that endpoint and records the status code, the response time in milliseconds, and whether the response matched the expected status. Results are written to a SQLite database (Cloudflare D1) and rolled up daily into a 30-day uptime percentage and average response time per API.

Three details decide whether a number here means anything:

• A 401 counts as alive. For an API that requires a key, an authentication challenge proves the service is answering. We record the expected status per API rather than demanding 200 from everything — an earlier version of this monitor did demand 200, and spent weeks reporting 45 perfectly healthy keyed APIs as broken.
• A 429 counts as alive. Our checks run from shared Cloudflare egress IPs, which trip per-IP rate limits that a real user with their own address never hits.
• MCP servers get a real handshake. The 9 remote MCP servers we track are probed with the JSON-RPC initialize call an actual client sends, not a blind GET — most MCP endpoints answer a GET with 405 or 400, so a naive checker reports working servers as broken.

Where we run the checks from also changes what we see. Apple's iTunes Search API answers a residential connection with 200 and our datacenter IP with 403; it is up, it simply refuses cloud ranges. We record that rather than calling it down. A newly added API reports no history yet instead of a fabricated uptime figure — a 30-day average means nothing on its first day.

Rankings on the category pages combine three signals: 30-day uptime (60% weight), normalized response time (30%), and free-tier friction (10% — no-key APIs score higher than API-key-required, which score higher than credit-card-required). The full formula and how each input is measured is documented at our methodology page.

When an API changes state (alive → dead or vice versa), an event row is created and surfaces on the changelog and homepage. When an API is permanently dead or has moved fully to paid, it's promoted to the graveyard with replacement suggestions.

What we curate vs. what we automate

Curated by hand: which APIs are in the catalog, the description text per API, the free-tier text (read from each provider's docs at time of entry), the paid alternative suggestions, the categorization, and which APIs are marked as dead or paid in the graveyard.

Automated: the hourly uptime and response-time monitoring, the ranking computation, the snapshot generation, and the daily site rebuild.

This combination is deliberate. Pure automation would let us claim more breadth at the cost of accuracy (free-tier text in particular changes in ways automation can't reliably catch). Pure curation would let us claim more depth per entry at the cost of staleness (one human can't verify 133 APIs hourly).

It is also why the catalog is 133 entries and not several thousand. Directories that list every API anyone ever published look more impressive and age far worse: nothing in them is verified, so a dead entry sits there indefinitely. We would rather be smaller and right. The graveyard currently holds 10 APIs that died or moved behind a paywall — in most directories those would still be listed as free.

Machine access

Everything we measure is available to programs, not just to readers. There is a public JSON API — no authentication, CORS open — and an MCP server at api.freeapi.watch/mcp that lets an AI assistant query the same data directly. That second one exists because language models confidently recommend APIs that shut down years ago; their training data predates the shutdown. An assistant that can check first stops generating integrations against services that no longer exist.

How the site is funded

The site is funded by affiliate links to paid alternatives shown on each API page (when a visitor needs more than the free tier offers, we link to paid services and receive a small commission if they sign up), by sponsorship, and by reader support. Display advertising via Google AdSense is planned once approved. There is no paid placement: API rankings on category pages are computed purely from the live monitoring data using the formula documented in the methodology. We have never accepted payment in exchange for inclusion, ranking position, or favorable description.

Infrastructure costs are currently $0/month — the site runs entirely on Cloudflare's free tier (Workers, D1, Pages) plus GitHub Actions for the daily rebuild. This means the project doesn't need significant revenue to continue running, which keeps incentives aligned: there is no pressure to compromise data accuracy for monetization growth.

Update cadence

• Monitoring data: updated hourly (status, response time)
• Site rebuild: daily at 02:15 UTC (refreshes static pages with latest data)
• Catalog additions/changes: manual, typically within 1-2 days of a reader suggesting an API via contact
• Graveyard updates: manual when monitoring detects sustained outages (7+ days) or when a free tier is removed

Open feedback

If you find an API that's missing, an entry that's miscategorized, or a free-tier description that's no longer accurate, please email [email protected], suggest it here, or start a thread in the public community repository. Corrections are typically applied within 24 hours — a wrong entry here is worse than a missing one, so please do report them.

What this site is not

It is also not exhaustive, and does not try to be. We track 133 APIs across 14 categories because that is what one person can verify honestly. If you want the widest possible list, the public-apis GitHub repository is still the best starting point — just check anything you find there before you build on it.

FreeAPI.watch is not a generic uptime monitor — services like StatusGator, Pingdom, and UptimeRobot are better-suited for monitoring arbitrary URLs you choose. We specifically curate free public APIs that indie developers, hackathon participants, and prototype builders are likely to use, and we measure them in a way that surfaces both reliability and free-tier honesty. For the broader comparison of public-API directories, see our positioning article.