# Apidog MCP for AI Agents AI Agent Connect

> Apidog MCP connects your API development workspace to your AI agent. It lets you browse projects, fetch endpoint schemas, and export full OpenAPI 3.0 specifications so your agent can understand your backend contracts without you having to copy and paste data manually.

## Overview
- **Category:** productivity
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_1gfzKqa8BKdlksvlirUta1L3JF2RLj6gA89JA1li/ai-agent-connect
- **Tags:** api-testing, mocking, openapi, schema-validation, lifecycle-management, documentation

## Description

You spend a lot of time jumping between your API documentation and your code editor. When you need to know exactly what a specific route expects, you're usually hunting for a stale Swagger file or digging through a web UI. This Connector changes that by bringing your Apidog workspace directly into your chat interface. Instead of manually grabbing JSON schemas, you can just ask your agent to look up the details of a route or pull the full specification for a project. It gives your agent the same visibility you have in the Apidog dashboard, meaning it can write more accurate types, generate better mock data, and stay in sync with your live production contracts. Vinkius makes this easy by hosting the Connector so you can connect your favorite client once and access the whole catalog. You get to stop worrying about whether your agent is hallucinating a field that doesn't exist and start getting code that actually works the first time. It turns your API contracts into a live knowledge base for your agent to use whenever you're building.

## Tools

### list_endpoints
Get a list of every API route defined in a specific project. This helps you see the full scope of an API.

### get_endpoint
Fetch the complete schema for a single API endpoint. This provides the exact request and response bodies.

### list_schemas
Find all data model schemas and DTOs in an Apidog project. This helps your agent understand your data structures.

### list_projects
See all API projects in your connected Apidog organization. Use this to find the right workspace quickly.

### export_openapi
Download the full OpenAPI 3.0 specification as a JSON file. This gives your agent the maximum possible context.

## Prompt Examples

**Prompt:** 
```
List the projects in our Apidog workspace.
```

**Response:** 
```
I found these projects in your Apidog organization:

* **E-commerce API** (ID: 39420)
* **Internal Admin Portal** (ID: 10429)

Which one should we look at?
```

**Prompt:** 
```
Write a TypeScript interface for the /users endpoint in the E-commerce project.
```

**Response:** 
```
I checked the `/users` endpoint in the E-commerce project. Here is the exact TypeScript interface matching the backend contract:

```typescript
export interface UserResponse {
  id: number;
  email: string;
  status: 'active' | 'suspended';
}
```
```

**Prompt:** 
```
Export the full OpenAPI JSON for the E-commerce project.
```

**Response:** 
```
I've pulled the full OpenAPI 3.0 specification for the E-commerce project. It defines 42 endpoints and 18 global schemas. I'm ready to help you generate tests or scaffold your code based on this context.
```

## Capabilities

### Browse your API projects
See all active projects in your connected Apidog organization at a glance.

### List all project endpoints
Get a full list of every HTTP route defined within a specific project.

### Fetch specific endpoint schemas
Pull the complete request and response body details for any single route.

### Query reusable data models
Access all DTOs and entities defined across your API projects.

### Export OpenAPI 3.0 specs
Download the full JSON specification to give your agent complete context.

## Use Cases

### Generating frontend types from a backend route
A frontend engineer asks the agent to create a service layer. The agent uses get_endpoint to see the JSON structure and writes the correct TypeScript interfaces.

### Scaffolding a new backend controller
A backend developer wants to build a new endpoint. The agent uses export_openapi to understand the whole project before writing the boilerplate code.

### Creating mock data for integration tests
A QA engineer needs a complex response payload. The agent uses list_schemas to find the correct DTO structure and generates a valid mock.

### Auditing all available API routes
A lead dev wants to see what's currently live. The agent uses list_endpoints to provide a clean summary of every route in the project.

## Benefits

- Stop copy-pasting schemas by using get_endpoint to feed your agent the exact request and response bodies every time.
- Generate perfect TypeScript types instantly by letting your agent query list_schemas for your actual DTOs.
- Keep your docs in sync because export_openapi lets your agent see the latest project changes without manual updates.
- Build better tests faster by using list_endpoints to see every available route in your project in one go.
- Reduce hallucinations by giving your agent the full context of your Apidog organization via list_projects.

## How It Works

The bottom line is you get instant access to your API contracts without leaving your editor.

1. Subscribe to this Connector and grab your Personal Apidog API Access Token.
2. Paste your token into your AI client settings to establish the connection.
3. Ask your agent to fetch schemas or list projects to start coding.

## Frequently Asked Questions

**What can the Apidog MCP do for my team?**
It lets your AI agent read your Apidog API contracts directly. This means your agent can write more accurate code, generate better mocks, and stay in sync with your live documentation.

**Can I use Apidog MCP with Cursor?**
Yes, you can connect this Connector to Cursor or any other compatible client. It allows your agent to access your Apidog workspace while you're coding in your IDE.

**How do I get my API schemas into my AI client?**
Once you connect the Apidog MCP, your agent can fetch schemas automatically. You don't have to copy and paste anything; just ask the agent to look up a specific endpoint.

**Does Apidog MCP support OpenAPI 3.0?**
Yes, it can export the full OpenAPI 3.0 specification as JSON. This gives your agent the complete context of your project's endpoints and data models.

**Can I use Apidog MCP to generate TypeScript types?**
Absolutely. By querying your data models and endpoint schemas, your agent can generate precise TypeScript interfaces that match your backend exactly.

**How do I connect my Apidog account to my AI agent?**
You just need your Personal Apidog API Access Token. Once you subscribe to the Connector and enter your token, your agent can start interacting with your API contracts.

**Can I import a complete OpenAPI spec into an AI chat session?**
Yes. Instruct the agent to run the `export_openapi` tool. It downloads the JSON metadata and safely passes it into your context. Given its size, the agent can use this massive reference guide to rapidly write tests, endpoints, or data models perfectly mimicking your production systems.

**How can I check the payload requirements for a single specific route?**
If you know the general area of the project, use `list_endpoints` to verify the ID. Then query `get_endpoint`. It brings back the specific HTTP verbs, query arguments, path definitions, and expected JSON body — letting your agent craft exact functional requests to external systems.

**Will my Apidog tokens expire?**
When generating your Personal Access Token in Apidog, you dictate the validity duration (e.g. 30 days, 1 year or never expire). If you choose a finite span, you will need to come back, generate a new token and insert it once more to reconnect the Connector successfully.