RealWorldAPIs

Official6 tools

by rwapis · JavaScript

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

MCP Server: com.realworldapis/realworldapis

com.realworldapis/realworldapis is an MCP server focused on API discovery and selection for AI agents that connect to the physical world. Its purpose is to help agents find and choose relevant APIs for downstream integration, based on what is available for use.

🛠️ Key Features

API discovery
API selection for AI agents connecting to the physical world

🚀 Use Cases

Enabling AI agents to identify appropriate APIs for real-world/physical-world integrations

⚡ Developer Benefits

Streamlines the process of locating and selecting APIs needed by agents for physical-world connectivity

⚠️ Limitations

Additional details (e.g., tool count, supported topics, or specific behaviors) were not provided in the available source data.

Captured live from the server via tools/list.

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.

Parameters3

task	string	required	Required natural-language goal or workflow, for example 'connect to a car and predict weather on the route'. Describe the desired outcome rather than naming a specific API.
requirements	object	optional	Optional task requirements appended before canonical ranking. categories and capabilities shape task intent. mcp=Yes, openapi=Yes and auth are expressed as hard task requirements and are evaluated against verified evidence; Unknown does not count as a confirmed contradiction and remains eligible with an uncertainty. free_tier and min_readiness are accepted for backward compatibility but are not hard filters.
limit	integer	optional	Backward-compatible parameter. The canonical browser-parity workflow always produces five structured candidates before the AI comparison, even when another value is supplied.

Raw schema

{
  "type": "object",
  "properties": {
    "task": {
      "type": "string",
      "maxLength": 1000,
      "description": "Required natural-language goal or workflow, for example 'connect to a car and predict weather on the route'. Describe the desired outcome rather than naming a specific API."
    },
    "requirements": {
      "type": "object",
      "additionalProperties": false,
      "description": "Optional task requirements appended before canonical ranking. categories and capabilities shape task intent. mcp=Yes, openapi=Yes and auth are expressed as hard task requirements and are evaluated against verified evidence; Unknown does not count as a confirmed contradiction and remains eligible with an uncertainty. free_tier and min_readiness are accepted for backward compatibility but are not hard filters.",
      "properties": {
        "categories": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "Preferred catalog categories, such as Geospatial, Weather or Mobility. These are ranking hints, not strict filters."
        },
        "capabilities": {
          "type": "array",
          "items": {
            "type": "string",
            "enum": [
              "observe",
              "locate",
              "predict",
              "plan",
              "control",
              "act"
            ]
          },
          "description": "Desired agent capability dimensions. These are appended as ranking hints, not strict filters."
        },
        "mcp": {
          "type": "string",
          "enum": [
            "Yes",
            "No",
            "Unknown"
          ],
          "description": "When set to Yes, becomes an explicit 'Must support MCP' requirement. Verified No excludes; Unknown remains eligible with an uncertainty. Use search_apis for exact status filtering."
        },
        "openapi": {
          "type": "string",
          "enum": [
            "Yes",
            "No",
            "Unknown"
          ],
          "description": "When set to Yes, becomes an explicit OpenAPI requirement. Verified No excludes; Unknown remains eligible with an uncertainty. Use search_apis for exact status filtering."
        },
        "free_tier": {
          "type": "boolean",
          "description": "Backward-compatible field only. The canonical recommendation engine does not currently hard-filter on free-tier availability."
        },
        "auth": {
          "type": "string",
          "enum": [
            "none",
            "api_key",
            "oauth",
            "client_credentials",
            "bearer",
            "jwt",
            "basic"
          ],
          "description": "Authentication requirement appended as an explicit task requirement. The canonical engine excludes only when the verified API authentication methods contradict it."
        },
        "min_readiness": {
          "type": "integer",
          "minimum": 0,
          "maximum": 100,
          "description": "Backward-compatible field only. It does not hard-filter the canonical top five; use search_apis for a strict minimum readiness threshold."
        }
      }
    },
    "limit": {
      "type": "integer",
      "minimum": 1,
      "maximum": 5,
      "default": 5,
      "description": "Backward-compatible parameter. The canonical browser-parity workflow always produces five structured candidates before the AI comparison, even when another value is supplied."
    }
  },
  "required": [
    "task"
  ],
  "additionalProperties": false
}

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.

Parameters12

query	string	optional	Optional case-insensitive text search across API name, provider, category, description, capabilities, agent capabilities and authentication fields.
categories	array	optional	Exact category names. Supplying multiple category values allows a record to match any listed category; this category condition still combines with every other supplied filter group using AND logic.
capabilities	array	optional	Capability terms that must all be present in the record's verified capabilities. Matching is case-insensitive and allows a capability string to contain the supplied term.
agent_capabilities	array	optional	Agent capability dimensions that must all be explicitly present on a record.
openapi	string	optional	Exact OpenAPI evidence status required for a match.
mcp	string	optional	Exact MCP evidence status required for a match.
a2a	string	optional	Exact A2A evidence status required for a match.
x402	string	optional	Exact x402 evidence status required for a match.
llms_txt	string	optional	Exact llms.txt evidence status required for a match.
min_readiness	integer	optional	Strict minimum agent-readiness score. Records below this score are excluded.
agent_actionable	boolean	optional	When true, require agent_actionable = true. False does not exclude actionable records; omit this field unless you need the positive requirement.
limit	integer	optional	Maximum number of matching records returned. Results are sorted by readiness descending then API name. total_matches still reports the full count. No pagination is currently exposed.

Raw schema

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "maxLength": 300,
      "description": "Optional case-insensitive text search across API name, provider, category, description, capabilities, agent capabilities and authentication fields."
    },
    "categories": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Exact category names. Supplying multiple category values allows a record to match any listed category; this category condition still combines with every other supplied filter group using AND logic."
    },
    "capabilities": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Capability terms that must all be present in the record's verified capabilities. Matching is case-insensitive and allows a capability string to contain the supplied term."
    },
    "agent_capabilities": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "observe",
          "locate",
          "predict",
          "plan",
          "control",
          "act"
        ]
      },
      "description": "Agent capability dimensions that must all be explicitly present on a record."
    },
    "openapi": {
      "type": "string",
      "enum": [
        "Yes",
        "No",
        "Unknown"
      ],
      "description": "Exact OpenAPI evidence status required for a match."
    },
    "mcp": {
      "type": "string",
      "enum": [
        "Yes",
        "No",
        "Unknown"
      ],
      "description": "Exact MCP evidence status required for a match."
    },
    "a2a": {
      "type": "string",
      "enum": [
        "Yes",
        "No",
        "Unknown"
      ],
      "description": "Exact A2A evidence status required for a match."
    },
    "x402": {
      "type": "string",
      "enum": [
        "Yes",
        "No",
        "Unknown"
      ],
      "description": "Exact x402 evidence status required for a match."
    },
    "llms_txt": {
      "type": "string",
      "enum": [
        "Yes",
        "No",
        "Unknown"
      ],
      "description": "Exact llms.txt evidence status required for a match."
    },
    "min_readiness": {
      "type": "integer",
      "minimum": 0,
      "maximum": 100,
      "description": "Strict minimum agent-readiness score. Records below this score are excluded."
    },
    "agent_actionable": {
      "type": "boolean",
      "description": "When true, require agent_actionable = true. False does not exclude actionable records; omit this field unless you need the positive requirement."
    },
    "limit": {
      "type": "integer",
      "minimum": 1,
      "maximum": 20,
      "default": 10,
      "description": "Maximum number of matching records returned. Results are sorted by readiness descending then API name. total_matches still reports the full count. No pagination is currently exposed."
    }
  },
  "additionalProperties": false
}

search_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.

Parameters15

query	string	optional	Optional case-insensitive text search across API/provider/category, capability key/name, primitive/action type, object, execution fields and constraints. Search terms may match across different capability fields; all supplied terms must be present somewhere in the capability record.
api_slugs	array	optional	Optional API slugs. Multiple values are OR within this filter.
categories	array	optional	Exact category labels. Multiple values are OR within this filter.
primitives	array	optional	Exact capability primitives such as Observe, Locate, Predict, Plan, Control or Act.
action_types	array	optional	Exact action types such as Read, Search, Analyze, Route or Control.
actionability	array	optional	Exact actionability labels such as Information only, Planning or Physical action.
object	string	optional	Case-insensitive substring match on the object acted upon, such as smart lock, parcel or charging session.
human_approval	array	optional	Exact approval labels, for example Required, Not required, Depends on action or Unknown.
physical_consequence	boolean	optional	When supplied, require the exact physical-consequence boolean.
irreversible_high_consequence	boolean	optional	When supplied, require the exact irreversible/high-consequence boolean.
sandbox	array	optional	Exact sandbox/test-environment labels, including Unknown when desired.
hardware_dependency	array	optional	Exact hardware-dependency labels.
access_friction	array	optional	Exact access-friction labels such as Self-service signup, Sales contract or Hardware ecosystem.
agent_setup	array	optional	Exact agent-setup labels such as Fully self-service or Human setup required.
limit	integer	optional	Maximum capability rows returned. total_matches reports the full match count.

Raw schema

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "maxLength": 300,
      "description": "Optional case-insensitive text search across API/provider/category, capability key/name, primitive/action type, object, execution fields and constraints. Search terms may match across different capability fields; all supplied terms must be present somewhere in the capability record."
    },
    "api_slugs": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Optional API slugs. Multiple values are OR within this filter."
    },
    "categories": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Exact category labels. Multiple values are OR within this filter."
    },
    "primitives": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Exact capability primitives such as Observe, Locate, Predict, Plan, Control or Act."
    },
    "action_types": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Exact action types such as Read, Search, Analyze, Route or Control."
    },
    "actionability": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Exact actionability labels such as Information only, Planning or Physical action."
    },
    "object": {
      "type": "string",
      "maxLength": 200,
      "description": "Case-insensitive substring match on the object acted upon, such as smart lock, parcel or charging session."
    },
    "human_approval": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Exact approval labels, for example Required, Not required, Depends on action or Unknown."
    },
    "physical_consequence": {
      "type": "boolean",
      "description": "When supplied, require the exact physical-consequence boolean."
    },
    "irreversible_high_consequence": {
      "type": "boolean",
      "description": "When supplied, require the exact irreversible/high-consequence boolean."
    },
    "sandbox": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Exact sandbox/test-environment labels, including Unknown when desired."
    },
    "hardware_dependency": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Exact hardware-dependency labels."
    },
    "access_friction": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Exact access-friction labels such as Self-service signup, Sales contract or Hardware ecosystem."
    },
    "agent_setup": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Exact agent-setup labels such as Fully self-service or Human setup required."
    },
    "limit": {
      "type": "integer",
      "minimum": 1,
      "maximum": 50,
      "default": 20,
      "description": "Maximum capability rows returned. total_matches reports the full match count."
    }
  },
  "additionalProperties": false
}

verify_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.

Parameters3

api	string	required	Exact API slug or API name, for example nuki-web-api or Nuki Web API.
requirement	string	required	Specific requirement to verify, for example 'remotely unlock a smart lock without human approval'.
location	string	optional	Optional geographic coverage requirement, for example Sweden. Coverage is returned as Unknown/Partial when the normalized capability graph does not contain enough location evidence.

Raw schema

{
  "type": "object",
  "properties": {
    "api": {
      "type": "string",
      "maxLength": 200,
      "description": "Exact API slug or API name, for example nuki-web-api or Nuki Web API."
    },
    "requirement": {
      "type": "string",
      "maxLength": 1000,
      "description": "Specific requirement to verify, for example 'remotely unlock a smart lock without human approval'."
    },
    "location": {
      "type": "string",
      "maxLength": 200,
      "description": "Optional geographic coverage requirement, for example Sweden. Coverage is returned as Unknown/Partial when the normalized capability graph does not contain enough location evidence."
    }
  },
  "required": [
    "api",
    "requirement"
  ],
  "additionalProperties": false
}

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.

Parameters1

identifier

string

required

Required API slug or API name. Exact matches are preferred; a unique case-insensitive partial slug/name match is accepted. If it is ambiguous or missing, use search_apis to find the exact identifier.

Raw schema

{
  "type": "object",
  "properties": {
    "identifier": {
      "type": "string",
      "maxLength": 200,
      "description": "Required API slug or API name. Exact matches are preferred; a unique case-insensitive partial slug/name match is accepted. If it is ambiguous or missing, use search_apis to find the exact identifier."
    }
  },
  "required": [
    "identifier"
  ],
  "additionalProperties": false
}

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.

Parameters2

apis	array	required	Required list of 2–8 API slugs or names. Exact matches are preferred; unique partial matches are accepted. Unresolved identifiers are reported separately, and the call fails if fewer than two records resolve.
fields	array	optional	Optional fields to compare. The default includes core catalog fields plus verified capability count, physical-consequence count, approval-relevant count, irreversible/high-consequence count and the decision-profile URL.

Raw schema

{
  "type": "object",
  "properties": {
    "apis": {
      "type": "array",
      "minItems": 2,
      "maxItems": 8,
      "items": {
        "type": "string"
      },
      "description": "Required list of 2–8 API slugs or names. Exact matches are preferred; unique partial matches are accepted. Unresolved identifiers are reported separately, and the call fails if fewer than two records resolve."
    },
    "fields": {
      "type": "array",
      "uniqueItems": true,
      "description": "Optional fields to compare. The default includes core catalog fields plus verified capability count, physical-consequence count, approval-relevant count, irreversible/high-consequence count and the decision-profile URL.",
      "items": {
        "type": "string",
        "enum": [
          "provider",
          "category",
          "description",
          "capabilities",
          "agent_capabilities",
          "auth_methods",
          "openapi",
          "mcp",
          "a2a",
          "x402",
          "llms_txt",
          "agent_readiness_score",
          "public_documentation",
          "authentication_verified",
          "agent_actionable",
          "website",
          "docs_url",
          "verified_capability_count",
          "information_only_count",
          "physical_consequence_count",
          "irreversible_high_consequence_count",
          "approval_relevant_count",
          "capability_profile_url"
        ]
      }
    }
  },
  "required": [
    "apis"
  ],
  "additionalProperties": false
}

README.md12 KBView on GitHub

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

Website: https://realworldapis.com
Remote MCP endpoint: https://mcp.realworldapis.com/mcp
MCP health: https://mcp.realworldapis.com/health
Catalog JSON: https://realworldapis.com/api/catalog.json
Capabilities JSON: https://realworldapis.com/api/capabilities.json
Requirement verification: https://realworldapis.com/api/verify-requirement
Structured recommendation: https://realworldapis.com/api/recommend
OpenAPI: https://realworldapis.com/openapi.json
Full LLM catalog: https://realworldapis.com/llms-full.txt
Research: https://realworldapis.com/research/state-of-agent-ready-apis-2026

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:

Tool	Purpose
`find_api_for_task`	Natural-language API selection using the canonical hosted recommender, followed by constrained comparison over returned candidates.
`search_apis`	Deterministic search and filtering over canonical API fields.
`search_capabilities`	Search the verified capability graph directly.
`verify_requirement`	Evidence-backed YES / NO / PARTIAL / UNKNOWN verification of one API against a specific requirement.
`get_api`	Retrieve one canonical API decision profile by slug or name.
`compare_apis`	Deterministic 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 outcome	`find_api_for_task`
Exact filtering by category, capability, protocol status or readiness	`search_apis`
Direct discovery over verified task-level capabilities	`search_capabilities`
Evidence-backed adjudication of an exact API requirement	`verify_requirement`
The canonical record for one already-known API	`get_api`
A field-by-field comparison of already-known candidates	`compare_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

The canonical structured dataset is the source of truth.
Unknown is distinct from No.
AI comparison may not introduce APIs outside the structured shortlist.
Search and comparison tools use canonical stored evidence.
Hard provider facts require the appropriate evidence quality under the hosted RealWorldAPIs evidence policy.
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 history
CONTRIBUTING.md            Contribution and correction workflow
PROPRIETARY_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.

Install

Tools (6)

find_api_for_tasksearch_apissearch_capabilitiesverify_requirementget_apicompare_apis

Remote endpoint

Streamable HTTP

Hosted server - connect over the network, no local install.

url

https://mcp.realworldapis.com/mcp

Add to VS Code Add to Cursor

claude_desktop_config.json

json

{
  "mcpServers": {
    "realworldapis": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://mcp.realworldapis.com/mcp"
      ]
    }
  }
}

Desktop config is stdio-only; this bridges via mcp-remote. Native remote: Settings > Connectors.

MCP Server: com.realworldapis/realworldapis

🛠️ Key Features

🚀 Use Cases

⚡ Developer Benefits

⚠️ Limitations

find_api_for_task

search_apis

search_capabilities

verify_requirement

get_api

compare_apis

RealWorldAPIs MCP

Public interface, proprietary intelligence

Public / interoperability surface

Proprietary hosted systems

Live service

MCP tools

Which tool should I use?

find_api_for_task

search_apis

search_capabilities

verify_requirement

get_api

compare_apis

Connect

Codex-style TOML

Evidence model

Grounding rules

Why RealWorldAPIs exists

Research and dataset

Architecture

Repository layout

Status

Contributing

Rights and licensing

Install

Remote endpoint

Related servers

`find_api_for_task`

`search_apis`

`search_capabilities`

`verify_requirement`

`get_api`

`compare_apis`