Orbit
Server Details
Turn any task into the right API calls: discover, evaluate, and integrate public APIs.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP
- URL
TDQS
Scored across 2 tools
search and integrate have clearly distinct roles: one discovers and evaluates endpoints/MCPs, the other generates integration task briefs from selected results. There is no functional overlap between them.
Both tools use the same simple lowercase verb pattern (search, integrate), which is consistent and predictable for a two-tool set.
Two tools is below the typical 3-15 range, but the narrow scope of discover-and-integrate is fully covered by this pair. Each tool earns its place with no redundant additions.
The end-to-end workflow is complete: search provides discovery, evaluateGuide, and pagination; integrate consumes the selected results to produce comprehensive integration details. There are no obvious missing operations for the stated purpose.
Available Tools
2 toolsintegrateAInspect
Get integration details for public endpoints and MCPs from search results. Provide a task describing what you want to accomplish and up to 10 resources — each with an id and type taken from the matching search result's resourceType. Returns a task brief covering authentication, base URLs, request steps, parameters, expected responses, dependencies between steps, and other important considerations.
| Name | Required | Description | Default |
|---|---|---|---|
| task | Yes | What you want to accomplish with the selected resources (max 512 characters). | |
| resources | Yes | Up to 10 endpoints or MCPs to integrate. Each entry needs an `id` and `type` from a search result (`type` is the result's `resourceType`). | |
| clientName | No | Name of the client application or agent invoking this tool (e.g. "cursor/composer-2.5", "claude/sonnet-4.6", "codex/gpt-5.6-sol"). Used for anonymous usage analytics. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses that the tool returns a task brief covering authentication, base URLs, request steps, parameters, expected responses, dependencies between steps, and other considerations. It also implies a read-only operation (getting details) and does not claim any destructive side effects. It could be more explicit about whether it performs any external calls or just compiles a brief, but the disclosed return content is substantial.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, dense paragraph that front-loads the core purpose and then details the required inputs and expected output. Every sentence earns its place: the first sentence states the function, the second explains the input format, and the third lists the output contents. No fluff or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (3 params, no output schema, no annotations), the description is quite complete. It explains the input contract (task + resources from search results), the output contents (task brief with auth, base URLs, steps, etc.), and the relationship to the sibling tool. The only minor gap is that it doesn't explicitly state whether the tool makes external network calls or just synthesizes a plan, but the phrase 'task brief' suggests a synthesized document. Overall, it's sufficient for an agent to use correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all three parameters. The description adds value by explaining the relationship between `resources` and search results (`resourceType`), and by clarifying the purpose of `task` ('describing what you want to accomplish'). It also adds the constraint of up to 10 resources, which is already in the schema but reinforced. The description doesn't add much beyond the schema, but the schema is already rich, so a 4 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get integration details for public endpoints and MCPs from `search` results.' It specifies the verb (get), the resource (integration details), and the source (search results). It also distinguishes itself from the sibling tool `search` by explaining that it consumes search results to produce a task brief.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly instructs the agent to provide a `task` and up to 10 `resources` with `id` and `type` taken from the matching search result's `resourceType`. It also names the sibling tool `search` as the source of these results, making the workflow clear: first search, then integrate. This is strong when-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
searchAInspect
Find and evaluate public API endpoints and MCPs that match your query. Set q to a natural language query, keywords, an API name, or a question — results are matched by meaning and keyword; each result includes id, resourceType (endpoint or mcp), name, description, method (for an endpoint) or transport (for an mcp), url, and evaluateGuide — an evaluation of what the endpoint or MCP does, when to use it, and its limitations. Review evaluateGuide to pick the best fit, then pass each chosen result's id and resourceType (as type) to integrate. Paginate with cursor from meta.nextCursor (limit defaults to 10, max 25; pagination stops at 40 results total). No authentication required.
Best practices for querying:
Use focused keyword queries that include the product or provider name along with the endpoint details, for example "PayPal create invoice".
Alternatively, use natural language queries such as "PayPal API to create an invoice".
Avoid jumbled queries that cram many unrelated keywords into a single query, for example "paypal invoice payment delivery payments ordering".
Avoid OR-separated queries such as "paypal invoice OR paypal create invoice OR paypal OR invoice creation".
If you need to explore multiple intents, try each as a separate call.
| Name | Required | Description | Default |
|---|---|---|---|
| q | Yes | Free-text search: a natural language query, keywords, an API name, or a question (e.g. "weather forecast", "twilio", "Add tracking details for an existing paypal order"). Matched by meaning and keyword. | |
| limit | No | Results per page (default 10, max 25). | |
| cursor | No | Pagination cursor from a prior response's `meta.nextCursor`. Omit for the first page. | |
| clientName | No | Name of the client application or agent invoking this tool (e.g. "cursor/composer-2.5", "claude/sonnet-4.6", "codex/gpt-5.6-sol"). Used for anonymous usage analytics. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses key behavioral traits: matching by meaning and keyword, the structure of each result (including `evaluateGuide`), pagination mechanics (`cursor` from `meta.nextCursor`, limit defaults, max 25, stops at 40 results total), and no authentication required. This is comprehensive behavioral transparency beyond what any annotation might have provided.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is long but well-organized. It front-loads the core purpose and result structure, then provides a clearly labeled best-practices section. Every sentence adds relevant information (result fields, pagination, no-auth, query examples). Slight redundancy exists between the schema and description for `limit`/`cursor`, but it's minimal and arguably reinforcing. Overall efficient for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (search, pagination, result evaluation, integration routing) and absence of an output schema, the description is remarkably complete. It explains return fields, how to use `evaluateGuide` to select results, pagination limits, and even query best practices. An agent has everything needed to call it correctly and interpret results. No significant gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds value beyond the schema by clarifying semantic nuances: `q` can be natural language, keywords, or a question; pagination stops at 40 total results; `clientName` is used for anonymous analytics. This extra context justifies a 4 rather than the baseline 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The opening sentence states a specific purpose: 'Find and evaluate public API endpoints and MCPs that match your query.' It clearly identifies the resource (endpoints/MCPs) and the action (find and evaluate). It also distinguishes itself from the sibling `integrate` by explicitly stating 'pass each chosen result's `id` and `resourceType` (as `type`) to `integrate`.' No ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit when-to-use and how-to-use guidance. It explains when to use this tool (to explore and evaluate) and then route to `integrate` for actual integration. It also provides concrete best practices and anti-patterns for query formulation (e.g., avoid jumbled or OR-separated queries), making usage conditions clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
1 tool update
- Changed
integrate4 fields changed- changed
Input schema / properties / resources / descriptionPrevious value: -"Up to 10 endpoints to integrate. Each entry needs an `id` and `type` from a search result (`type` is the result's `resourceType`)."New value: +"Up to 10 endpoints or MCPs to integrate. Each entry needs an `id` and `type` from a search result (`type` is the result's `resourceType`)." - changed
Input schema / properties / resources / items / properties / id / descriptionPrevious value: -"Endpoint id from a search result's `id` field."New value: +"Resource id from a search result's `id` field." - changed
Input schema / properties / resources / items / properties / type / descriptionPrevious value: -"Resource type from a search result's `resourceType` field."New value: +"Resource type from a search result's `resourceType` field (`endpoint` or `mcp`)." - changed
Input schema / properties / task / descriptionPrevious value: -"What you want to accomplish with the selected endpoints (max 512 characters)."New value: +"What you want to accomplish with the selected resources (max 512 characters)."
Related MCP Connectors
Discover, compare, and monitor 1,400+ APIs directly from your AI coding agent.
AI service marketplace — agents discover, call, and pay for API services automatically.
Pay-per-use tool marketplace for AI agents. Search, price-check, and call APIs via MCP.
Discover and call 10,000+ production APIs from one MCP server. Pay-per-call billing for AI agents.
Related MCP Servers
- AlicenseAqualityBmaintenanceThe API layer for AI agents. World's biggest API index with 22,000+ APIs and growing. Agents discover and call APIs at runtime with semantic search, structured metadata, and 18 Direct Call APIs including AI providers.14868 npm8MIT
- FlicenseAqualityDmaintenanceEnables autonomous task execution by dynamically searching APIs, generating Python tools, and running them on-demand, with built-in web search, scraping, and file operations.3-

UCM MCP Serverofficial
FlicenseNot gradedqualityFmaintenanceEnables AI agents to autonomously discover and call a marketplace of 100+ APIs, including web search, image generation, and more, with automatic payments and refunds.-- AlicenseNot gradedqualityAmaintenanceEnables AI agents to discover, search, and call any REST API described by an OpenAPI or Swagger document. Supports multiple API endpoints with authentication and parameter handling.6 npmMIT
Glama MCP Gateway
Add one secure layer between your agents and this server.