RealWorldAPIs

com.realworldapisPublished by realworldapis.comOfficial publisherv3.0.1Updated Oct 25, 2026

Evidence-first registry of real-world APIs for AI agents, with verified metadata and comparison.

VerifiedStreamable HTTPWeb executableWeb Search & ScrapingDeveloper Tools

Overview

AI-generated overview

A remote, read-only registry of real-world APIs that lets an assistant find, filter, verify and compare APIs for physical-world tasks.

What you can do
Recommend APIs for an open-ended natural-language task or outcome, with the shortlist drawn from a hosted recommender and comparison limited to those candidates. Search and filter the API catalog by category, capability, protocol status or readiness. Search the verified capability graph for task-level capabilities and their execution conditions. Verify whether one known API satisfies one exact requirement, returning YES, NO, PARTIAL or UNKNOWN with evidence. Retrieve one API's full decision profile by name or slug, and compare two to eight known APIs field by field.
When to use it
Useful when an assistant must choose between real-world APIs (weather, maps, mobility, logistics, IoT, energy, robotics) or check whether a specific API meets a requirement before integration. Good for evidence-backed selection where unknown support must stay unknown rather than be assumed.
Requirements
A remote Streamable HTTP endpoint; no API key is currently required and no environment variables or headers are declared. The client must support remote Streamable HTTP connections, and network access to the hosted service is needed.
Before you install
All six tools are read-only and return catalog and evidence data; no writes or payments are performed. Results come from a hosted proprietary service that may change independently of public documentation, and the README advises checking provider documentation before production integration. Unknown values are not confirmed support.

Installation

In SourceWeft

  1. Open RealWorldAPIs in the dashboard and add it to a workspace.
  2. Enable the server for the chats that should use its tools.

Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.

Use with an agent

Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.

Read https://sourceweft.com/mcp/com.realworldapis%2Frealworldapis/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.

Read the install guide the agent follows

Other MCP clients

Add this to your client's mcpServers config.

{
  "mcpServers": {
    "realworldapis": {
      "type": "http",
      "url": "https://mcp.realworldapis.com/mcp"
    }
  }
}

README

RealWorldAPIs MCP

RealWorldAPIs is an evidence-first API registry for AI agents connecting to the physical world.

A real-world API connects software or AI agents to data, devices, infrastructure or services representing the physical world — including weather, maps, mobility, logistics, IoT, energy and robotics.

This repository documents and provides a publicly inspectable MCP interface implementation for RealWorldAPIs.

The live hosted RealWorldAPIs service is the source of truth for current tools, schemas, recommendation behavior and evidence semantics. The hosted service may evolve independently from the code visible in this repository.

One core evidence rule applies throughout the service:

Unknown remains Unknown and is never treated as confirmed support.

Public interface, proprietary intelligence

RealWorldAPIs intentionally separates its public interoperability surface from its proprietary decision systems.

Public / interoperability surface

The following are intended to be publicly discoverable and usable for interoperability:

  • the remote MCP endpoint and tool schemas
  • public HTTP endpoints and OpenAPI descriptions
  • public API catalog and capability/evidence outputs
  • public documentation and usage examples
  • factual provider metadata and evidence links
  • structured recommendation and verification results returned by the hosted service

Proprietary hosted systems

The following are not published or licensed through this repository:

  • the canonical RealWorldAPIs recommendation and ranking engine
  • natural-language task parsing and task-frame logic
  • capability retrieval, fusion and sibling-capability reranking logic
  • internal scoring rules, weights and optimization logic
  • verification and evidence-processing implementation
  • assertion-generation and research pipelines
  • benchmark tooling, active private evaluation sets and holdout sets
  • internal administration, proposal and approval systems

The MCP layer calls hosted canonical RealWorldAPIs services for recommendation and evidence-backed decision support. Publishing an interface, schema or result does not publish the underlying hosted implementation.

See PROPRIETARY_NOTICE.md for the repository rights notice.

Live service

No RealWorldAPIs API key is currently required to discover or call the public MCP tools.

MCP tools

The live RealWorldAPIs MCP service currently exposes six read-only tools:

ToolPurpose
find_api_for_taskNatural-language API selection using the canonical hosted recommender, followed by constrained comparison over returned candidates.
search_apisDeterministic search and filtering over canonical API fields.
search_capabilitiesSearch the verified capability graph directly.
verify_requirementEvidence-backed YES / NO / PARTIAL / UNKNOWN verification of one API against a specific requirement.
get_apiRetrieve one canonical API decision profile by slug or name.
compare_apisDeterministic side-by-side comparison of canonical fields.

The live tool set and schemas are authoritative. The source-visible implementation in this repository may lag the hosted service.

Which tool should I use?

If you need...Use
Recommendations for an open-ended natural-language task or desired outcomefind_api_for_task
Exact filtering by category, capability, protocol status or readinesssearch_apis
Direct discovery over verified task-level capabilitiessearch_capabilities
Evidence-backed adjudication of an exact API requirementverify_requirement
The canonical record for one already-known APIget_api
A field-by-field comparison of already-known candidatescompare_apis

find_api_for_task

Use when the user describes a goal rather than a specific API.

Example task:

json
{  "task": "I need my agent to connect to a car and predict weather on the route"}

The structured shortlist returned by the canonical hosted recommender is the source of truth. Any AI comparison is constrained to that shortlist and is not permitted to introduce outside APIs.

search_apis

Use when the task is explicit enough to filter the registry directly.

Example:

json
{  "categories": ["Geospatial"],  "agent_capabilities": ["locate"],  "mcp": "Yes",  "min_readiness": 60,  "limit": 10}

Only explicit stored values are used. For example, mcp: "Yes" must not be satisfied by an API whose MCP status is Unknown.

search_capabilities

Use when the task is better expressed as an exact capability or execution requirement than as a broad API category.

Capability results can include execution, access, approval, hardware, sandbox, physical-consequence and reversibility fields when available from the canonical evidence graph.

verify_requirement

Use when you need to adjudicate one API against one exact requirement.

Example:

json
{  "api": "here-location-services",  "requirement": "truck routing in Sweden"}

The verifier returns an evidence-backed YES, NO, PARTIAL or UNKNOWN result. Unknown is never silently promoted into support.

get_api

Example:

json
{  "identifier": "geoapify"}

The response is the canonical RealWorldAPIs decision profile, including provider metadata, capabilities, authentication, protocol status and evidence links.

compare_apis

Example:

json
{  "apis": ["Geoapify", "Google Maps Platform", "Mapbox"],  "fields": [    "category",    "capabilities",    "agent_capabilities",    "auth_methods",    "openapi",    "mcp",    "agent_readiness_score"  ]}

The comparison is deterministic. RealWorldAPIs does not infer missing support or silently replace Unknown with a guess.

Connect

Any MCP client that supports remote Streamable HTTP can connect to:

text
https://mcp.realworldapis.com/mcp

Example MCP configuration:

json
{  "mcpServers": {    "realworldapis": {      "url": "https://mcp.realworldapis.com/mcp"    }  }}

Codex-style TOML

toml
[mcp_servers.realworldapis]url = "https://mcp.realworldapis.com/mcp"

Evidence model

RealWorldAPIs is designed around a normalized evidence layer rather than free-form API recommendations.

The canonical dataset tracks fields such as:

  • provider and category
  • verified task-level capabilities
  • agent action primitives
  • authentication methods
  • OpenAPI
  • MCP
  • A2A
  • x402
  • llms.txt
  • public documentation status
  • authentication verification
  • access and setup requirements
  • approval requirements
  • hardware dependencies
  • sandbox availability
  • physical consequence
  • irreversibility
  • direct evidence links

Grounding rules

  1. The canonical structured dataset is the source of truth.
  2. Unknown is distinct from No.
  3. AI comparison may not introduce APIs outside the structured shortlist.
  4. Search and comparison tools use canonical stored evidence.
  5. Hard provider facts require the appropriate evidence quality under the hosted RealWorldAPIs evidence policy.
  6. Provider documentation should be checked before production integration.

Why RealWorldAPIs exists

General API directories are useful for broad discovery, but AI agents increasingly need a normalized way to answer questions such as:

  • Which exact API capability can perform this task?
  • Which APIs can locate a vehicle and route a technician?
  • Which weather APIs are both agent-actionable and machine-readable?
  • Which robotics APIs expose machine-usable interfaces?
  • Which APIs can be combined for a physical-world workflow?
  • What access, approval, hardware or safety constraints apply?
  • What evidence gaps remain before an agent should rely on a provider?

RealWorldAPIs focuses specifically on APIs that connect software and agents to the physical world.

Research and dataset

The public research page, State of Agent-Ready Real-World APIs 2026, summarizes the catalog snapshot across agent-readiness, protocol support and category-level evidence:

https://realworldapis.com/research/state-of-agent-ready-apis-2026

Machine-readable research data:

https://realworldapis.com/research/state-of-agent-ready-apis-2026.json

The public catalog is available at:

https://realworldapis.com/api/catalog.json

The verified capability graph is available at:

https://realworldapis.com/api/capabilities.json

Architecture

The MCP server is intentionally an interface layer over canonical hosted RealWorldAPIs services.

text
MCP client   |   +-- find_api_for_task --------> hosted canonical recommender   +-- verify_requirement --------> hosted evidence/verifier layer   +-- search_capabilities -------> canonical capability graph   +-- search_apis ---------------> canonical API catalog   +-- get_api -------------------> canonical API decision profile   +-- compare_apis --------------> canonical evidence fields

This avoids maintaining a second independent recommendation, ranking or evidence system inside the public MCP interface.

The implementation of the canonical hosted recommendation, ranking, verification and evidence-processing systems is proprietary and is not contained in this repository.

See docs/ARCHITECTURE.md for additional public interface details.

Repository layout

text
src/  worker.js               Publicly inspectable MCP interface implementation
examples/  requests.md             Example tool calls and expected semantics
docs/  ARCHITECTURE.md         Public data flow, grounding and failure behavior  DATA_MODEL.md           Important catalog fields and evidence semantics
CHANGELOG.md               Release historyCONTRIBUTING.md            Contribution and correction workflowPROPRIETARY_NOTICE.md      Repository rights and proprietary-service boundary

Status

The hosted RealWorldAPIs service evolves independently from this public repository.

For current production behavior, use the live MCP endpoint and canonical website endpoints. Third-party directories and this repository may temporarily show an older tool count, description, implementation detail or schema after a production deployment.

Contributing

Corrections to public API metadata are welcome when supported by current provider documentation. Please include the evidence URL and identify the exact field that should change.

Public contributions do not grant access to, or imply publication of, proprietary RealWorldAPIs ranking, verification, optimization, benchmark or research systems.

See CONTRIBUTING.md.

Rights and licensing

This repository is publicly source-visible but is not released under an open-source license.

No MIT, Apache, BSD, GPL or other open-source license is granted by this repository.

Use of the hosted RealWorldAPIs service is separate from rights in repository source code. Public protocol descriptions, schemas and factual outputs may be used for interoperability as permitted by applicable terms and law, but the proprietary hosted RealWorldAPIs systems are not licensed through this repository.

See PROPRIETARY_NOTICE.md.

Copyright © 2026 RealWorldAPIs. All rights reserved.

Source: README.md at commit 39545da

Tools

6

find_api_for_task

Find API for Task

Find the best APIs for a natural-language physical-world task. Use this for open-ended task or outcome-based recommendations; use search_apis when you already know exact filters, get_api for one known API, or compare_apis for known candidates. Returns an authoritative canonical structured_results shortlist plus a best-effort AI comparison restricted to that shortlist. The canonical engine now applies Verified/High capability evidence before ranking: explicit hard requirements expressed with terms such as must, required, no or without can exclude a candidate only when verified evidence contradicts them. Unknown evidence remains eligible and is surfaced as uncertainty. requirements.mcp, openapi and auth are translated into explicit requirements; categories and capabilities remain task-shaping hints. free_tier and min_readiness are accepted for compatibility but are not hard filters.

Parameterstaskrequiredlimitrequirements

search_apis

Search APIs

Search the canonical registry when you already know keywords or exact requirements. All supplied filter groups combine with AND logic; array capability filters require every supplied value, and protocol fields match the exact Yes/No/Unknown status, so Unknown never satisfies Yes. Results include each API's capability_summary and direct decision-profile URL. Results are sorted by agent_readiness_score descending and then API name, with 1–20 results returned (default 10). Use search_capabilities when you need capability-level filters such as approval, physical consequence, sandbox or access friction.

Parametersa2amcpx402limitqueryopenapillms_txtcategoriescapabilitiesmin_readinessagent_actionableagent_capabilities

search_capabilities

Search Verified Capabilities

Search the canonical 770-capability Verified/High decision graph directly. Use this when the question is about what an agent can actually do and under what execution conditions: task/capability text, API, category, action type, acted-on object, human approval, physical consequence, irreversibility, sandbox, hardware dependency, access friction or setup. All supplied filter groups combine with AND logic; multiple values inside one array filter are alternatives (OR). Unknown remains Unknown and may be filtered explicitly by passing the literal value Unknown.

Parameterslimitqueryobjectsandboxapi_slugscategoriesprimitivesagent_setupaction_typesactionabilityhuman_approvalaccess_friction+3 more

verify_requirement

Verify API Requirement

Verify whether one specific API can satisfy one exact requirement using the canonical Verified/High capability graph plus linked assertion evidence. Returns YES, NO, PARTIAL or UNKNOWN with matched capability, access/setup prerequisites, approval, safety, reversibility, reliability, coverage and other requested dimensions; direct provider facts remain distinct from inferred policy assertions. Unknown remains Unknown.

Parametersapirequiredlocationrequirementrequired

get_api

Get API

Retrieve one canonical API decision profile when you already know its name or slug. The response includes the full Verified/High capability profile with execution, access, approval, reversibility, physical-consequence and evidence fields. Exact slug or exact API name is preferred; a partial identifier is accepted only when it uniquely resolves to one record.

Parametersidentifierrequired

compare_apis

Compare APIs

Compare 2–8 already-known APIs side by side using canonical catalog fields plus capability-graph summary fields such as verified capability count, physical consequences, approval relevance and irreversibility. Use get_api for the full decision profile of one API and search_capabilities for capability-level filtering. No missing value is inferred and Unknown remains Unknown.

Parametersapisrequiredfields

Version history

2
  1. v3.0.1LatestSep 27, 2026
  2. v1.2.1Sep 16, 2026

Score

90% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 daysRequired25 pts
  • Auth declaredRequired10 pts
  • Tools listedRequired15 pts
  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts

    Declare a license in the repository or the registry entry.