FreeAPI.watch MCP Server

A free remote MCP server that gives your AI assistant live status data for 133 free public APIs. No key, no signup, one URL.

Endpoint

https://api.freeapi.watch/mcp

Streamable HTTP · MCP 2025-06-18 · no authentication

The problem it solves

Ask any AI assistant for a free weather API and it will confidently recommend Dark Sky, which Apple shut down in 2023. Ask for a free news API and you may get Twitter's v1.1 endpoint, which stopped being free in July 2023. Models are trained on documentation and blog posts, and those age badly — an API that was free and healthy when the training data was collected may be dead, paywalled, or key-gated today.

This server closes that gap. Instead of recalling what was true, your assistant can ask what is true right now: we ping every API in the catalog every hour against a real endpoint and publish what we measure. A model that checks first stops generating integrations against services that no longer exist.

Tools

`check_api_status`

Live status of one API — up or down right now, measured response time, 30-day uptime, free-tier terms, and whether a key is needed.

When to use it: Call it before writing an integration. It is the difference between generating code against a working API and against one that died in 2024.

`search_free_apis`

Finds APIs matching a topic, ranked by measured uptime. Filter to no-key-required or set a minimum uptime.

When to use it: When you need an API for a task and want one that currently works, not one a blog post recommended three years ago.

`find_alternatives`

Given an API that died, went paid, or is rate-limiting you, returns free alternatives in the same category ranked by uptime.

When to use it: The fastest path from a broken integration to a working one.

`list_dead_apis`

The graveyard: APIs that shut down or moved behind a paywall, each with what still works instead.

When to use it: Model training data is full of APIs that no longer exist. This is the corrective.

`check_mcp_servers`

Live status of the 9 public no-auth remote MCP servers we monitor, each probed with a real JSON-RPC initialize handshake every hour.

When to use it: Pick an MCP server that works today, or find out whether the one you are connected to is down for everyone.

`list_categories`

Every category in the catalog with counts and how many are up right now.

When to use it: Discovery — what is actually tracked before you search.

Connect it

Claude Code

claude mcp add freeapi-watch --transport http https://api.freeapi.watch/mcp

Claude Desktop / any client using a JSON config

{
  "mcpServers": {
    "freeapi-watch": {
      "type": "http",
      "url": "https://api.freeapi.watch/mcp"
    }
  }
}

Cursor

{
  "mcpServers": {
    "freeapi-watch": {
      "url": "https://api.freeapi.watch/mcp"
    }
  }
}

Raw JSON-RPC (any language)

curl -X POST https://api.freeapi.watch/mcp \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call",
       "params":{"name":"check_api_status",
                 "arguments":{"api":"open-meteo"}}}'

What the data actually means

Everything this server returns is measured, never self-reported. Three details worth knowing before you trust a number:

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.
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. We send the JSON-RPC initialize call your client would send, not a blind GET — most MCP endpoints return 405 or 400 to a GET, so a naive checker reports healthy servers as broken and broken ones as fine.

A recently added API reports no history yet rather than a fabricated uptime figure. It takes a day of hourly checks before a 30-day average means anything. See the methodology for the full scoring formula.

Frequently asked questions

What does the FreeAPI.watch MCP server do?

It gives an AI assistant live access to our monitoring data for 133 free public APIs and remote MCP servers. The most common use is checking that an API is actually up and still free before writing code against it — the failure mode where a model recommends an API that shut down years ago.

Do I need an API key to use it?

No. It is a public remote MCP server with no authentication, no signup, and no credit card. Add the URL to your client and it works. Fair-use rate limiting applies.

How do I add it to Claude Code?

Run: claude mcp add freeapi-watch --transport http https://api.freeapi.watch/mcp — then ask Claude to check whether an API is up.

How current is the data?

Every API in the catalog is checked hourly against a real endpoint, and the server reads from that live database on each call. Uptime figures are 30-day averages recomputed daily. Nothing is self-reported by the API providers.

What transport does it use?

Streamable HTTP, MCP specification revision 2025-06-18. It responds with JSON rather than opening an SSE stream, since every tool resolves in a single database round-trip.

Is it open about its own status?

Yes — this server is in our own monitored catalog and is probed hourly with the same handshake as every other MCP server we track. If it breaks, our own site says so.

Prefer raw HTTP? The same data is available through our public JSON API — no auth, CORS open. Browsing for a server rather than building with one? See free MCP servers.