RealWorldAPIs

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 browser-parity flow always returns five structured candidates: limit is retained only for backward compatibility. requirements.categories, capabilities, mcp, openapi and auth are added as task hints; free_tier and min_readiness are accepted for compatibility but are not hard filters. Unknown remains Unknown.

{
  "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 compatibility hints appended to the task before canonical ranking. categories, capabilities, mcp, openapi and auth influence the effective query. free_tier and min_readiness are accepted for backward compatibility but are not hard filters; use search_apis when you need strict field filtering.",
      "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": "Compatibility hint for MCP support. Only Yes becomes an explicit 'Must support MCP' task hint; use search_apis for exact Yes/No/Unknown filtering."
        },
        "openapi": {
          "type": "string",
          "enum": [
            "Yes",
            "No",
            "Unknown"
          ],
          "description": "Compatibility hint for OpenAPI support. Only Yes becomes an explicit task hint; use search_apis for exact Yes/No/Unknown 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": "Preferred authentication method, appended to the effective task as a ranking hint."
        },
        "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
}

{
  "type": "object",
  "properties": {
    "name": {
      "type": "string"
    },
    "engine_version": {
      "type": "string"
    },
    "method": {
      "type": "string"
    },
    "task": {
      "type": "string"
    },
    "effective_query": {
      "type": "string"
    },
    "snapshot_date": {
      "type": [
        "string",
        "null"
      ]
    },
    "coverage_status": {
      "type": "string"
    },
    "coverage_warnings": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "structured_results": {
      "type": "array",
      "description": "Canonical deterministic shortlist. This is the authoritative result set.",
      "items": {
        "type": "object",
        "additionalProperties": true
      }
    },
    "ai_comparison": {
      "type": [
        "object",
        "null"
      ],
      "additionalProperties": true,
      "description": "Best-effort grounded explanation of only the structured_results candidates."
    },
    "ai": {
      "type": "object",
      "additionalProperties": true
    },
    "compatibility_warnings": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "source_endpoints": {
      "type": "object",
      "additionalProperties": true
    },
    "grounding_policy": {
      "type": "object",
      "additionalProperties": true
    },
    "timing_ms": {
      "type": "object",
      "additionalProperties": true
    }
  },
  "required": [
    "name",
    "task",
    "structured_results",
    "ai",
    "grounding_policy"
  ],
  "additionalProperties": true
}

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 are sorted by agent_readiness_score descending and then API name, with 1–20 results returned (default 10); total_matches reports the complete match count and there is no pagination. Use find_api_for_task for open-ended task recommendations, get_api for one known API, and compare_apis for side-by-side inspection.

{
  "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
}

{
  "type": "object",
  "properties": {
    "name": {
      "type": "string"
    },
    "method": {
      "type": "string"
    },
    "query": {
      "type": "string"
    },
    "filters": {
      "type": "object",
      "additionalProperties": true
    },
    "total_matches": {
      "type": "integer",
      "minimum": 0
    },
    "returned": {
      "type": "integer",
      "minimum": 0
    },
    "results": {
      "type": "array",
      "items": {
        "type": "object",
        "additionalProperties": true,
        "properties": {
          "slug": {
            "type": "string"
          },
          "name": {
            "type": "string"
          },
          "provider": {
            "type": "string"
          },
          "category": {
            "type": "string"
          },
          "description": {
            "type": "string"
          },
          "capabilities": {
            "type": "array",
            "items": {
              "type": "string"
            }
          },
          "agent_capabilities": {
            "type": "array",
            "items": {
              "type": "string"
            }
          },
          "auth_methods": {
            "type": "array",
            "items": {
              "type": "string"
            }
          },
          "openapi": {
            "type": "string",
            "enum": [
              "Yes",
              "No",
              "Unknown"
            ]
          },
          "mcp": {
            "type": "string",
            "enum": [
              "Yes",
              "No",
              "Unknown"
            ]
          },
          "a2a": {
            "type": "string",
            "enum": [
              "Yes",
              "No",
              "Unknown"
            ]
          },
          "x402": {
            "type": "string",
            "enum": [
              "Yes",
              "No",
              "Unknown"
            ]
          },
          "llms_txt": {
            "type": "string",
            "enum": [
              "Yes",
              "No",
              "Unknown"
            ]
          },
          "agent_readiness_score": {
            "type": "number",
            "minimum": 0,
            "maximum": 100
          },
          "public_documentation": {
            "type": "boolean"
          },
          "authentication_verified": {
            "type": "boolean"
          },
          "agent_actionable": {
            "type": "boolean"
          },
          "website": {
            "type": [
              "string",
              "null"
            ]
          },
          "docs_url": {
            "type": [
              "string",
              "null"
            ]
          }
        }
      }
    },
    "evidence_policy": {
      "type": "string"
    }
  },
  "required": [
    "name",
    "method",
    "filters",
    "total_matches",
    "returned",
    "results",
    "evidence_policy"
  ],
  "additionalProperties": false
}

Retrieve one canonical verified API record when you already know its name or slug. Exact slug or exact API name is preferred; a partial identifier is accepted only when it uniquely resolves to one record. Missing or ambiguous identifiers return an error directing the agent to search_apis. Use compare_apis instead when you want fields from multiple known APIs.

{
  "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
}

{
  "type": "object",
  "properties": {
    "name": {
      "type": "string"
    },
    "record": {
      "type": "object",
      "additionalProperties": true,
      "properties": {
        "slug": {
          "type": "string"
        },
        "name": {
          "type": "string"
        },
        "provider": {
          "type": "string"
        },
        "category": {
          "type": "string"
        },
        "description": {
          "type": "string"
        },
        "capabilities": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "agent_capabilities": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "auth_methods": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "openapi": {
          "type": "string",
          "enum": [
            "Yes",
            "No",
            "Unknown"
          ]
        },
        "mcp": {
          "type": "string",
          "enum": [
            "Yes",
            "No",
            "Unknown"
          ]
        },
        "a2a": {
          "type": "string",
          "enum": [
            "Yes",
            "No",
            "Unknown"
          ]
        },
        "x402": {
          "type": "string",
          "enum": [
            "Yes",
            "No",
            "Unknown"
          ]
        },
        "llms_txt": {
          "type": "string",
          "enum": [
            "Yes",
            "No",
            "Unknown"
          ]
        },
        "agent_readiness_score": {
          "type": "number",
          "minimum": 0,
          "maximum": 100
        },
        "public_documentation": {
          "type": "boolean"
        },
        "authentication_verified": {
          "type": "boolean"
        },
        "agent_actionable": {
          "type": "boolean"
        },
        "website": {
          "type": [
            "string",
            "null"
          ]
        },
        "docs_url": {
          "type": [
            "string",
            "null"
          ]
        }
      }
    },
    "source": {
      "type": "string"
    },
    "evidence_policy": {
      "type": "string"
    }
  },
  "required": [
    "name",
    "record",
    "source",
    "evidence_policy"
  ],
  "additionalProperties": false
}

Compare 2–8 already-known APIs side by side using only canonical RealWorldAPIs fields. Use this after find_api_for_task or search_apis has produced candidates; use get_api when only one record is needed. If fields is omitted, the tool returns the default core comparison fields: provider, category, capabilities, agent capabilities, authentication, protocol statuses, readiness and verification/actionability fields, excluding long description and URLs. Unresolved names/slugs are listed in unresolved; at least two identifiers must resolve. No missing value is inferred and Unknown remains Unknown.

{
  "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. If omitted or empty, the tool uses the default core fields: provider, category, capabilities, agent_capabilities, auth_methods, openapi, mcp, a2a, x402, llms_txt, agent_readiness_score, public_documentation, authentication_verified and agent_actionable.",
      "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"
        ]
      }
    }
  },
  "required": [
    "apis"
  ],
  "additionalProperties": false
}

{
  "type": "object",
  "properties": {
    "name": {
      "type": "string"
    },
    "method": {
      "type": "string"
    },
    "fields": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "records": {
      "type": "array",
      "items": {
        "type": "object",
        "additionalProperties": false,
        "required": [
          "slug",
          "name",
          "values"
        ],
        "properties": {
          "slug": {
            "type": "string"
          },
          "name": {
            "type": "string"
          },
          "values": {
            "type": "object",
            "additionalProperties": true
          }
        }
      }
    },
    "unresolved": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "evidence_policy": {
      "type": "string"
    }
  },
  "required": [
    "name",
    "method",
    "fields",
    "records",
    "unresolved",
    "evidence_policy"
  ],
  "additionalProperties": false
}