apifable is an MCP server that helps AI agents explore and integrate OpenAPI-based APIs into TypeScript frontend projects. It supports OpenAPI 3.0 and 3.1 specs and works with Claude, Cursor, and Windsurf.
Get API overview (get_spec_info): Retrieve general info about the loaded spec — title, version, description, servers, security schemes, and tags with endpoint counts.
List endpoints by tag (list_endpoints_by_tag): Browse endpoints belonging to a specific tag, with pagination (limit/offset).
Search endpoints (search_endpoints): Keyword search across operationId, path, summary, and description. Results are relevance-ranked with automatic fuzzy fallback and a matchType indicator (exact or fuzzy).
Get endpoint details (get_endpoint): Fetch full details of an endpoint — parameters, request body, responses, and security — via method+path or operationId. Internal $refs are resolved inline.
Search schemas (search_schemas): Keyword search across schema names and descriptions in components/schemas, with fuzzy fallback.
Get schema details (get_schema): Retrieve a specific schema by name with inline $ref resolution.
Generate TypeScript types (get_types): Produce self-contained TypeScript type declarations for specific schemas or all schemas used by a given endpoint, including transitive dependencies.
Integrates with OpenAPI 3.0 and 3.1 specifications to allow for endpoint exploration, schema searching, and resolving request/response details.
Generates self-contained TypeScript type definitions from API endpoints and schemas to facilitate type-safe frontend integration.
Read the spec. Understand the API. Integrate with confidence.
English | 繁體中文
apifable is an MCP server that helps AI integrate APIs more smoothly into TypeScript frontend projects. It makes it easy to explore API structure, search endpoints, and generate TypeScript types, giving your AI agent the context it needs to write accurate integration code.
Related MCP server: openapi-mcp-proxy
📦 AI-ready API context — give AI the structure it needs to understand and work with your API
📘 OpenAPI 3.0 / 3.1 support — works with standard specs as a reliable source of truth
🤖 MCP server for AI agents — plug into Claude, Cursor, and Windsurf
🔍 API exploration tools — browse endpoints, search by keyword, and inspect full request/response details
🏷️ TypeScript type generation — generate TypeScript type definitions ready to use in frontend code
Run apifable init to set up your project configuration:
npx apifable@latest initThis creates apifable.config.json in your project root. The config file should be committed to version control so the spec path is shared with your team.
After the command starts, you can choose between Manual file and Remote URL.
Use this mode if your OpenAPI spec already lives in the project, or if you want to manage spec updates yourself.
init will ask for the local file path, such as openapi.yaml.
This generates the following apifable.config.json:
{
"spec": {
"path": "openapi.yaml"
}
}You then need to place your OpenAPI spec at that path manually. When the backend API changes, you also need to update that file manually.
Use this mode if your OpenAPI spec is available from a stable remote URL, such as the OpenAPI spec endpoint provided by your backend API docs.
init will first ask for the remote URL, such as https://api.example.com/openapi.yaml (supports yaml and json files), and then ask for the local output path, such as openapi.yaml.
This generates the following apifable.config.json:
{
"spec": {
"path": "openapi.yaml",
"url": "https://api.example.com/openapi.yaml"
}
}In this mode,init also adds the downloaded local spec path to .gitignore automatically, because the file is intended to be refreshed from the remote source. Of course, you can decide for yourself whether to commit it to version control.
You can then run the following command to download the OpenAPI spec from the remote URL to your local path (spec.url → spec.path). Whenever the spec changes, just run it again to refresh:
npx apifable@latest fetchFor non-sensitive headers that can be shared with your team, add spec.headers to apifable.config.json:
{
"spec": {
"path": "openapi.yaml",
"url": "https://example.com/openapi.yaml",
"headers": {
"X-Api-Version": "2"
}
}
}If downloading the remote OpenAPI spec requires authentication (private API), store secret headers in .apifable/auth.json. This file should not be committed to version control:
{
"headers": {
"Authorization": "Bearer YOUR_SECRET_TOKEN"
}
}Both apifable.config.json and .apifable/auth.json support ${ENV_VAR} syntax in header values.
{
"headers": {
"Authorization": "Bearer ${MY_API_KEY}"
}
}.apifable/auth.json headers (overrides same-named keys)
apifable.config.json spec.headers
Add the following to your .mcp.json:
{
"mcpServers": {
"apifable": {
"command": "npx",
"args": ["-y", "apifable@latest", "mcp"]
}
}
}For other AI agents such as Cursor and Windsurf, you can follow the same approach to configure apifable as an MCP server.
Here are some example prompts you can use to explore APIs and build features.
List all APIsShow me APIs related to postsList APIs under the Post tagShow me the API details for post commentsShow me the API details for GET /posts/{id}/commentsShow me the API details for postCommentsImplement the post comments feature
Post page: src/pages/posts/[id].tsx
Related APIs:
- GET /posts/{id}/comments (list post comments)
- POST /posts/{id}/comments (create a post comment)When writing a prompt to build a feature, include relevant context: page paths, component locations, related APIs, and any patterns or examples to follow.
Add the following to your project's AGENTS.md to help AI agents use apifable more effectively:
## API Integration (apifable)
- Always use `get_endpoint` to verify the exact path, method, and parameters before writing integration code. Never assume.
- When presenting endpoint list data from apifable tools, display exactly these columns in order: `Method` (Uppercase), `Path`, `Summary`. Keep all values verbatim, including summary prefixes like `[ 32 - 001 ]`. Do not omit, rename, paraphrase, or add extra columns.
- When saving generated types, store them under `src/types/` and name files by domain (e.g., `src/types/auth.ts`, `src/types/user.ts`), not by OpenAPI tag names.The above is a recommended starting point. Feel free to adjust the endpoint list columns and the types folder path to match your project.
get_spec_infoReturns the API title, version, description, servers, and all tags with their endpoint counts. Start here to understand the shape of an unfamiliar spec.
list_endpoints_by_tagInputs:
tag (string): The tag name to filter by
limit (number, optional): Max endpoints to return
offset (number, optional): Number of endpoints to skip (default: 0)
Returns all endpoints belonging to the given tag. The response includes total, offset, and hasMore fields for pagination. Includes a warning when results exceed 30 items and no limit is specified.
search_endpointsInputs:
query (string): Keyword to search for
tag (string, optional): Restrict search to a specific tag
limit (number, optional): Max results to return (default: 10)
Keyword search across operationId, path, summary, and description. Results are ranked by relevance. If no exact matches are found, automatically falls back to fuzzy search. The response includes a matchType field ("exact" or "fuzzy"); fuzzy results also include a score field per result.
get_endpointInputs (choose one):
method (string) + path (string): HTTP method and endpoint path (e.g. get + /users/{id})
operationId (string): Operation ID (e.g. listUsers)
Returns the full endpoint object, including parameters, requestBody, and responses, with supported internal component $refs resolved inline.
search_schemasInputs:
query (string): Keyword to search for
limit (number, optional): Max results to return (default: 10)
Keyword search across schema name and description. Results are ranked by relevance. If no exact matches are found, automatically falls back to fuzzy search. The response includes a matchType field ("exact" or "fuzzy"); fuzzy results also include a score field per result. Empty results may also include a message field with guidance for the next step.
get_schemaInputs:
name (string): Schema name from components/schemas
Returns the full schema with supported internal component $refs resolved.
get_typesInputs (choose one mode):
schemas (string[]): Array of schema names from components/schemas
method (string) + path (string): HTTP method and endpoint path
operationId (string): Operation ID (e.g. listUsers)
Generates self-contained TypeScript declarations as code text. In endpoint mode it follows supported internal component $refs before collecting schema dependencies. It automatically includes transitive dependencies and does not include import statements.
Mode rules:
Use exactly one mode per call: schemas, method + path, or operationId
Do not mix modes in the same call
External $refs (e.g. references to other files or URLs) are not supported.
OpenAPI 2.0 (Swagger) is not supported. Only OpenAPI 3.0 and 3.1 specs are supported.
If you think this package has helped you, please consider Becoming a sponsor to support my work~ and your avatar will be visible on my major projects.
@reapi/mcp-openapi — for the initial inspiration
Get full details of a specific endpoint including parameters, request body, responses, and security requirements. Supported internal component $refs are resolved inline. Provide either "method" + "path" or "operationId". Use get_types to get TypeScript type declarations for the endpoint.
| Name | Required | Description | Default |
|---|---|---|---|
| path | No | Endpoint path (e.g. /users/{id}) | |
| method | No | HTTP method (e.g. get, post, put, delete) | |
| operationId | No | Operation ID to look up (e.g. listUsers) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, but description mentions that internal component $refs are resolved inline, a useful behavioral detail. It does not disclose potential side effects, error handling, or authentication needs, but as a read-only operation, the description is adequate.
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?
Two sentences with no wasted words. The first sentence states the purpose, the second provides usage options. Front-loaded and efficient.
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 no output schema, the description adequately lists the returned content (parameters, request body, responses, security) and mentions $ref resolution. It lacks error handling details but is sufficient for an endpoint detail retrieval tool.
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?
With 100% schema description coverage, baseline is 3. The description adds meaning by explaining the two identification approaches (method+path vs operationId) and directing to get_types for types, which is helpful beyond the schema.
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?
Description clearly states the tool retrieves full details of a specific endpoint including parameters, request body, responses, and security requirements. It distinguishes from siblings like get_schema (schemas) and get_types (TypeScript declarations) by focusing on endpoint details.
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?
Explicitly provides two alternative identification methods (method+path or operationId) and directs users to get_types for TypeScript type declarations. Though it lacks explicit 'when not to use' guidance, the alternative is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get a specific schema from components/schemas by name. Supported internal component $refs are resolved inline. Use get_types to convert schemas to TypeScript type declarations.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Schema name (e.g. User, CreateOrderRequest) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses that internal $refs are resolved inline, which is a key behavioral detail for a schema retrieval tool.
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?
Two sentences with no wasted words. The first sentence delivers the core purpose, and the second adds valuable detail and cross-reference to a sibling tool.
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?
For a simple one-parameter tool with no output schema, the description covers the main functionality and resolution behavior. It could optionally hint at output format, but is largely complete.
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 coverage is 100%, and the description adds minimal value beyond the schema's own parameter description, merely restating the parameter's purpose with examples.
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 retrieves a specific schema by name, includes inline $ref resolution, and explicitly contrasts with sibling get_types for TypeScript conversion.
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 provides explicit guidance to use get_types for TypeScript type declarations, but does not address when to use other siblings like search_schemas or get_endpoint.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get general information about the OpenAPI spec: title, version, description, servers, security schemes, and available tags with endpoint counts. Start here to understand an unfamiliar API. Then use list_endpoints_by_tag or search_endpoints to explore specific areas.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Description implies a read-only operation without side effects; no annotations are provided, but the description adequately conveys the tool's behavior. Could potentially mention that it returns summary data, but overall transparent.
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?
Two sentences: first states purpose and contents, second gives usage guidance. Efficient, front-loaded, and no wasted words.
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?
For a parameterless tool with no output schema, the description fully explains what it returns (title, version, description, servers, security schemes, tags with counts) and how to use it.
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?
No parameters exist, so schema coverage is 100%. The description adds no parameter-specific info, but given no parameters, the baseline of 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?
Clearly states it retrieves general information about the OpenAPI spec and lists specific items (title, version, etc.). Distinguishes from siblings by positioning it as the starting point and suggesting exploration tools like list_endpoints_by_tag and search_endpoints.
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?
Explicitly advises to 'Start here to understand an unfamiliar API' and then use list_endpoints_by_tag or search_endpoints for further exploration, providing clear when-to-use and alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Generate self-contained TypeScript type declarations for specified schemas or for all schemas used by a specific endpoint. Endpoint mode follows supported internal component $refs before collecting schema dependencies. Provide exactly one of: "schemas" (array of schema names), "method" + "path" (endpoint), or "operationId". Transitive dependencies are included automatically.
| Name | Required | Description | Default |
|---|---|---|---|
| path | No | Endpoint path for endpoint mode (e.g. /users/{id}) | |
| method | No | HTTP method for endpoint mode (e.g. get, post) | |
| schemas | No | Array of schema names from components/schemas (e.g. ["User", "Address"]) | |
| operationId | No | Operation ID to generate types for (e.g. listUsers) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It explains the two modes, that endpoint mode follows internal $refs, and that transitive dependencies are included automatically. This is good behavioral transparency for a read-like tool, though it does not mention potential errors or output format.
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?
Three sentences, each earning its place: first states purpose, second adds endpoint detail, third specifies parameter usage. Front-loaded and efficient with no wasted words.
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 complexity (two modes, four parameters, no output schema), the description covers the key aspects: purpose, mode selection, dependency handling. It does not explain the return type explicitly, but the tool name suggests TypeScript declarations, so it is reasonably complete.
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?
All four parameters have schema descriptions (100% coverage). The description adds value by explaining the exclusivity rule and mode semantics, which goes beyond the individual parameter descriptions. It helps the agent understand how to combine parameters.
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 generates TypeScript type declarations for schemas or for schemas used by an endpoint. It uses specific verbs and resources, distinguishing from sibling tools like 'get_schema' or 'get_endpoint' which return different outputs.
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 tells the agent to provide exactly one of three parameter combinations: schemas, method+path, or operationId. It explains endpoint mode follows $refs and includes transitive dependencies. However, it does not explicitly contrast with sibling tools or mention when not to use, but the guidance is clear enough.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all endpoints belonging to a specific tag. Use get_spec_info first to see available tags. Supports pagination via limit and offset. Then use get_endpoint to inspect a specific endpoint in detail.
| Name | Required | Description | Default |
|---|---|---|---|
| tag | Yes | The tag name to filter endpoints by | |
| limit | No | Maximum number of endpoints to return | |
| offset | No | Number of endpoints to skip (default: 0) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It discloses pagination support and required tag. However, it does not describe the return format (e.g., list of endpoint names or objects), error handling for invalid tags, rate limits, or permissions.
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?
Three sentences, each serving a distinct purpose: stating the action, a prerequisite step, and a subsequent step. No filler or redundant information.
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?
No output schema is provided. The description does not specify the return value format, sorting order, or behavior when the tag does not exist. This is a notable gap for a list endpoint.
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 coverage is 100%; all parameters have descriptions in schema. The description adds the concept of pagination and workflow but does not provide additional semantics beyond the schema. Baseline 3 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 'List all endpoints belonging to a specific tag,' using a specific verb and resource. It distinguishes itself from siblings like 'get_endpoint' (inspect specific) and 'search_endpoints' (search-based).
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?
Explicitly recommends using 'get_spec_info first to see available tags' and then 'get_endpoint to inspect a specific endpoint in detail,' providing a clear workflow. Pagination is mentioned. No explicit when-not-to-use, but the context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search endpoints by keyword across operationId, path, summary, and description. Results are ranked by relevance. If no exact matches are found, automatically falls back to fuzzy search. The response includes a matchType field ("exact" or "fuzzy"); fuzzy results also include a score field per result. After finding the target endpoint, use get_endpoint for full details or get_types for TypeScript types.
| Name | Required | Description | Default |
|---|---|---|---|
| tag | No | Optional tag to filter results | |
| limit | No | Maximum number of results (default: 10) | |
| query | Yes | Search keyword |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description fully carries the burden of behavioral disclosure. It reveals that results are ranked by relevance, automatically falls back to fuzzy search on no exact matches, and includes a matchType and optional score field. This is substantial for a search tool.
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 four sentences, each serving a distinct purpose: purpose, ranking, fallback/response fields, and post-search guidance. It is front-loaded with the core action and contains no redundant or extraneous information.
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?
Despite lacking an output schema, the description explains the response structure (matchType, score) and fallback behavior. It also references sibling tools for next steps. It could mention pagination or limit usage, but overall it's fairly comprehensive for a search tool.
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 coverage is 100% (all three parameters have descriptions). The description adds minimal extra meaning beyond the schema, e.g., it implies query searches across specific fields and mentions limit's default, but otherwise provides no new param-level insights.
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 explicitly states 'Search endpoints by keyword across operationId, path, summary, and description,' which is a specific verb and resource, differentiating it from sibling tools like list_endpoints_by_tag (list) and search_schemas (different resource).
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 ends with 'After finding the target endpoint, use get_endpoint for full details or get_types for TypeScript types,' providing clear guidance on next steps and differentiation from other tools. However, it does not explicitly state when not to use this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search schemas by keyword across schema name and description. Results are ranked by relevance. If no exact matches are found, automatically falls back to fuzzy search. Empty results may include a guidance message suggesting next steps. Use get_schema to inspect a specific schema in detail.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum number of results (default: 10) | |
| query | Yes | Search keyword |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description fully discloses ranking by relevance, automatic fallback to fuzzy search, and empty results guidance, covering behavioral traits thoroughly.
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?
Four sentences, front-loaded with main action, no waste. Every sentence adds value.
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?
Covers all necessary aspects for a search tool: scope, ranking, fallback, empty results, and related tool reference. No gaps given lack of output schema.
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?
Input schema has 100% coverage, but description adds meaning by specifying search scope (name and description) and ranking context, exceeding baseline.
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 it searches schemas by keyword across name and description, and distinguishes from sibling tool get_schema by advising to use that for detailed inspection.
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?
Explicitly states when to use (search by keyword), describes fallback behavior and empty results guidance, and recommends get_schema for specific inspection, providing clear alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.1.1get_endpointget_schemaget_spec_infoget_typeslist_endpoints_by_tagsearch_endpointssearch_schemasEach tool has a clearly distinct purpose—getting endpoint details, schema details, spec info, generating types, listing endpoints by tag, searching endpoints, and searching schemas—with no overlap.
All tool names follow a consistent verb_noun pattern (get_, get_, get_, get_, list_, search_, search_), making them predictable.
With 7 tools, the set is well-scoped for exploring an OpenAPI spec—enough to cover browsing, searching, and type generation without being excessive.
The tools cover the full lifecycle of API spec exploration: getting spec info, listing and searching endpoints/schemas, retrieving details, and generating TypeScript types—no obvious gaps.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
MCP server for AI access to Swagger by SmartBear.
MCP server for secureFlows: token-free URL builders and integration-linting tools for AI agents.
MCP server for building and testing AI agents with multi-model experimentation and insights.
MCP server for AI agents to plan, verify, and deploy Cloudflare-native apps.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/ycs77/apifable'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
