Skip to main content
Glama
@lstpsche/apidog-mcp

@lstpsche/apidog-mcp

by lstpsche

@lstpsche/apidog-mcp

MCP server for managing Apidog API documentation. Provides 22 tools for importing, exporting, diffing, analyzing, and bulk-editing OpenAPI specs and endpoint cases via the Model Context Protocol.

Quick Start

npx @lstpsche/apidog-mcp

Related MCP server: Swagger MCP Server

Configuration

Create .apidog.json in your project root:

{
  "accessToken": "adgp_your_token_here",
  "projectId": "1234567",
  "modules": {
    "backend": 1234,
    "payments": 5678
  }
}

Add .apidog.json to your .gitignore to keep secrets out of version control.

Then configure your MCP client (e.g. .cursor/mcp.json):

{
  "mcpServers": {
    "apidog": {
      "command": "npx",
      "args": ["-y", "@lstpsche/apidog-mcp"]
    }
  }
}

Multi-project config

To manage multiple Apidog projects from a single config, use the projects array:

{
  "accessToken": "adgp_your_token_here",
  "projects": [
    {
      "name": "main",
      "projectId": "1234567",
      "modules": {
        "backend": 1234,
        "payments": 5678
      }
    },
    {
      "name": "staging",
      "projectId": "7654321",
      "modules": {
        "default": 9999
      }
    }
  ]
}

Each project has a name used to target it in tool calls via the project parameter. When only one project is configured, the project parameter is optional and defaults automatically.

The single-project format (with top-level projectId and modules) is still fully supported and treated as a single project named "default".

Option B: Environment variables

Set these in your shell or CI environment:

Variable

Description

APIDOG_ACCESS_TOKEN

Apidog personal access token

APIDOG_PROJECT_ID

Apidog project ID

APIDOG_MODULES

JSON map of module names to IDs (e.g. {"api":123})

{
  "mcpServers": {
    "apidog": {
      "command": "npx",
      "args": ["-y", "@lstpsche/apidog-mcp"],
      "env": {
        "APIDOG_ACCESS_TOKEN": "${APIDOG_ACCESS_TOKEN}",
        "APIDOG_PROJECT_ID": "${APIDOG_PROJECT_ID}",
        "APIDOG_MODULES": "${APIDOG_MODULES}"
      }
    }
  }
}

Environment variables define a single project named "default". They can be combined with a multi-project .apidog.json — the env-var project overrides any file-based project with the same name.

Config file resolution

The server locates .apidog.json using the following strategy:

  1. APIDOG_CONFIG_PATH env var — if set, uses this explicit file path

  2. Upward directory walk — searches from process.cwd() upward through parent directories until .apidog.json is found (similar to how Node resolves package.json)

  3. Env-only fallback — if no file is found, falls back to environment variables

This means .apidog.json works reliably even when the MCP server is started from a subdirectory or by a plugin that doesn't set the working directory to the project root.

Resolution order

Environment variables take precedence over .apidog.json for the "default" project. You can mix both — for example, keep projectId and modules in .apidog.json and set APIDOG_ACCESS_TOKEN via environment for security.

Where to find your credentials

  • Access Token: Apidog > Account Settings > API Access Tokens

  • Project ID: Open your project > Settings > Basic Settings

  • Module IDs: Each module's settings page within your Apidog project

Tools (22)

All tools accept an optional project parameter to target a specific project in multi-project configurations. When only one project is configured, this parameter can be omitted.

Read

Tool

Description

apidog_modules

List configured projects and their modules with names and IDs

apidog_export

Export full OpenAPI spec for a module

apidog_list

List/search endpoints with filters and pagination

apidog_get

Get full details of a single endpoint

apidog_folders

Analyze folder structure and counts

Write

Tool

Description

apidog_import_openapi

Import OpenAPI spec (auto-batched for large specs)

apidog_wipe

Wipe all endpoints in a module (requires confirm)

apidog_update

Update a single endpoint via partial spec import

apidog_delete

Delete an endpoint

apidog_pipeline

3-step pipeline: wipe, create cases, overlay spec

Cases

Tool

Description

apidog_create_cases

Create endpoint usage examples (single or batch)

Diff & Analysis

Tool

Description

apidog_diff

Compare Apidog state against a local spec

apidog_analyze

Coverage and validation analysis (selectable checks)

Schemas

Tool

Description

apidog_list_schemas

List component schemas with references

apidog_get_schema

Get full schema definition

apidog_update_schema

Create or update a component schema

apidog_delete_schema

Delete a schema (refuses if still referenced)

Bulk Operations

Tool

Description

apidog_bulk_update

Batch update tags, folders, status, summaries

Export Formats

Tool

Description

apidog_export_markdown

Export as Markdown documentation

apidog_export_curl

Export as curl command examples

apidog_export_postman

Export as Postman Collection v2.1

Testing

Tool

Description

apidog_run_test

Run test scenarios or folders via Apidog CLI

Architecture

A single server instance can manage multiple Apidog projects and modules. Pass the module name (e.g. "backend", "payments") to each tool call — the server resolves it to the correct module ID. For multi-project setups, also pass the project name (e.g. "main", "staging").

Limitations

Apidog's public API is limited in scope. The following functionality is not available through this MCP server due to missing API support:

Feature

Reason

Direct endpoint CRUD

No REST API for creating/updating/deleting individual endpoints. Workaround: OpenAPI spec import with matching options.

Endpoint case CRUD

No API for creating/editing endpoint cases directly. Workaround: Postman collection import to inject cases.

Auto-generated "Success" case suppression

autoGenerateCase: false is silently ignored by the API. Workaround: auto-generated empty cases are detected and replaced after import.

Folder/module management

No API to create, rename, or delete folders or modules. Workaround: x-apidog-folder extension in OpenAPI import controls folder placement.

Test scenario management

No API to create or edit test scenarios. Only execution of existing scenarios is supported via apidog-cli.

Test execution auth

apidog-cli requires a separate CI/CD access token generated from within a test scenario's settings, not the general API access token.

Environment variables

No API to manage Apidog environment variables.

Mock server configuration

No API to configure or control mock servers.

Comments and discussions

No API to read or post comments on endpoints.

Change history

No API to access endpoint revision history.

These limitations are inherent to the Apidog API as of March 2026. The MCP server implements workarounds where possible (noted above).

License

MIT

Available Tools

22 tools
apidog_analyzeA

Analyze an Apidog module. Use checks param to select: "coverage" (missing summaries, descriptions, tags, etc.) and/or "validate" (duplicate IDs, orphaned schemas, missing params, etc.). Defaults to both.

Inputs: module (required), checks, project.

apidog_bulk_updateA

Batch update endpoints. Target by explicit endpoints array OR keyword filters. Supports: addTags, removeTags, setFolder, setStatus, setSummaryPrefix, summaryFindReplace. Set confirm=false to preview.

Inputs: module (required), addTags, confirm, project, +11 more.

apidog_create_casesA

Create one or more endpoint cases (usage examples). Pass a single-item or multi-item array. Internally builds a Postman collection and imports safely. Never overwrites endpoint definitions — only manages cases.

Inputs: cases (required), module (required), project, overwriteExisting.

apidog_deleteA

Delete an endpoint from Apidog. Exports current spec, removes the target, reimports with deleteUnmatchedResources.

Inputs: path (required), method (required), module (required), project.

apidog_delete_schemaA

Delete a component schema. Refuses if the schema is still referenced by endpoints.

Inputs: name (required), module (required), project.

apidog_diffA

Compare current Apidog state against a provided OpenAPI spec. Reports added, removed, and changed endpoints with field-level diffs.

Inputs: module (required), spec, project, specPath.

apidog_exportA

Export full OpenAPI spec for an Apidog module

Inputs: module (required), project, oasVersion, includeExtensions.

apidog_export_curlA

Export endpoints as ready-to-use curl command examples with placeholder values.

Inputs: module (required), baseUrl (required), project, filterTag, +3 more.

apidog_export_markdownB

Export module documentation as Markdown. Groups endpoints by folder or tag. Suitable for README or docs sites.

Inputs: module (required), groupBy, project, includeSchemas.

apidog_export_postmanA

Convert module to a Postman Collection v2.1 format with folder structure and placeholder values.

Inputs: module (required), baseUrl, project.

apidog_foldersA

Analyze folder structure of an Apidog module — counts, tree, unfoldered endpoints

Inputs: module (required), project.

apidog_getA

Get full details of a single endpoint including operation object and referenced schemas

Inputs: path (required), method (required), module (required), project.

apidog_get_schemaA

Get full JSON Schema definition by name, plus list of endpoints that reference it.

Inputs: name (required), module (required), project.

apidog_import_openapiA

Import an OpenAPI spec into an Apidog module. Auto-batches large specs to avoid payload limits. Accepts a file path or inline JSON.

Inputs: module (required), spec, project, specPath, +4 more.

apidog_listA

List and search endpoints in an Apidog module. Supports keyword search (scored by relevance), filters, and pagination.

Inputs: module (required), limit, query, offset, +6 more.

apidog_list_schemasA

List all component schemas in an Apidog module with types, property counts, and referencing endpoints.

Inputs: module (required), project.

apidog_modulesA

List all configured Apidog projects and their modules with names and IDs

Inputs: project.

apidog_pipelineA

Run the proven 3-step pipeline: (1) wipe module, (2) create cases from structured data, (3) overlay enriched OpenAPI spec in batches. Accepts file paths or inline data.

Inputs: module (required), cases, project, batchSize, +2 more.

apidog_run_testA

Run Apidog tests via CLI. Provide scenarioId for a single scenario OR folderId for all scenarios in a folder.

Inputs: module (required), project, folderId, timeoutMs, +3 more.

apidog_updateA

Update a single endpoint via targeted partial spec import. Does not affect other endpoints.

Inputs: path (required), method (required), module (required), operation (required), +1 more.

apidog_update_schemaB

Create or update a component schema via targeted spec import.

Inputs: name (required), module (required), definition (required), project.

apidog_wipeA

Wipe ALL endpoints in an Apidog module. Requires confirm=true as safety gate. Irreversible.

Inputs: module (required), confirm (required), project.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.9/5.0

    Scored across 22 tools

    Disambiguation5/5

    Each tool targets a distinct operation, whether it's a specific export format (OpenAPI vs curl vs Postman vs Markdown), a single endpoint vs bulk operation, or schema vs endpoint management. The descriptions clearly differentiate overlapping concepts like update vs bulk_update and delete vs wipe.

    Naming Consistency4/5

    All tools share the 'apidog_' prefix, which provides strong consistency. However, the pattern is not strictly verb_noun: modules, folders, pipeline, and diff are noun-style names, while most others are verbs or verb_noun. This minor inconsistency keeps it from a perfect score.

    Tool Count4/5

    22 tools is on the heavier side but appropriate for a feature-rich Apidog API management server covering endpoints, schemas, imports/exports, testing, analysis, and bulk operations. Each tool serves a clear purpose, so the count feels justified rather than bloated.

    Completeness4/5

    The surface covers most of the core Apidog workflows: endpoint CRUD, schema CRUD, multiple export formats, OpenAPI import, testing, diff/analyze, and bulk updates. Minor gaps include no direct endpoint creation tool (though import_openapi and pipeline handle it) and no tool for listing test scenarios/folders.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      C
      quality
      D
      maintenance
      An MCP server that integrates Apifox API documentation with AI assistants, allowing AI to extract and understand API information from Apifox projects.
      2
      46 npm
      ISC
    • F
      license
      Not graded
      quality
      D
      maintenance
      An MCP server for the comprehensive analysis of Swagger 2.0 and OpenAPI 3.x contracts. It allows users to extract detailed information about endpoints, request/response schemas, parameters, and security configurations from API documentation.
      -
    • A
      license
      A
      quality
      D
      maintenance
      MCP server for managing Apidog test cases, scenarios, suites, and test data, providing full read/write access to Apidog's test management features.
      30
      70 npm
      1
      MIT