# Vercel MCP MCP

> Vercel MCP connects your AI agent to Vercel’s entire deployment system. You can manage project domains, trigger manual builds, check live CI/CD status, and audit DNS settings—all from chat or directly within your IDE. It lets you run advanced DevOps commands without ever touching the web UI.

## Overview
- **Category:** loved-by-devs
- **Price:** Free
- **Tags:** serverless, deployment, git-integration, infrastructure-as-code, web-hosting, ci-cd

## Description

This MCP embeds Vercel's full continuous integration ecosystem right into your AI agent. Forget navigating multiple dashboards just to check a build status or spin up a new testing environment; you can handle complex deployment tasks via natural conversation.

It lets you manage everything from the project level down, whether you need to list all current architecture portfolios, force-build a specific tag for hotfixes, or map out which domains are pointing where. You can even cancel stalled compilations if things get weird. The real value comes when your agent chains this MCP with others; because Vinkius manages every tool call within its own isolated sandbox and generates cryptographically signed audit trails, you know exactly what happened—and who told the AI to do it.

This capability means you can handle entire deployment lifecycles without ever leaving your coding environment. It's pure DevOps power delivered right where you’re working.

## Tools

### cancel_active_build
Stops a Vercel compilation pipeline that is currently running.

### create_project
Sets up and initializes a new project within your Vercel account using a given name and framework.

### delete_project
Permanently removes an entire Vercel project. Use with extreme caution.

### get_deployment_details
Retrieves specific metadata and status for a known deployment execution ID.

### get_project_details
Pulls the full configuration details for an entire Vercel project.

### list_account_domains
Lists all high-level root domains connected across your entire Vercel account.

### list_deployments
Fetches a list of recent CI/CD build summaries for a specific project.

### list_project_aliases
Maps and displays all custom subdomain routing rules attached to a single project.

### list_projects
Returns an inventory of every Vercel project currently set up in the account.

### trigger_github_deployment
Forces a new build on a specified Vercel project using a GitHub branch or tag reference.

## Prompt Examples

**Prompt:** 
```
List all root domains connected to my Vercel infrastructure.
```

**Response:** 
```
I've queried the apex domains across your environment. You have 3 custom domains actively bound: `production-agent.com`, `internal-tools.io`, and `legacy-blog-marketing.net`. All three signify successful certificate validations.
```

**Prompt:** 
```
Create a manual deploy on the 'billing-service' project pulling directly from the 'main' branch on GitHub repo '341xyz'.
```

**Response:** 
```
I've successfully triggered a queued manual compilation for 'billing-service' using your target GitHub parameters. 

Vercel has acknowledged the deployment intent. The new processing ID assigned to this task is `dpl_H3vM4Q...`. You can poll `get_deployment_details` intermittently with this string or I can check again for you in 3 minutes if you'd prefer.
```

**Prompt:** 
```
Check the status of deployment 'dpl_827a' and give me its exact live preview URL if ready.
```

**Response:** 
```
I've checked deployment `dpl_827a`. Good news – Vercel marks its `readyState` as fully `READY`. There were zero pipeline errors.

You can access your newly compiled live preview here: [https://billing-service-pr-12-test.vercel.app](https://billing-service-pr-12-test.vercel.app)
```

## Capabilities

### Map and manage domains
Lists high-level domains and specific subdomain routing mappings for a given project.

### Check build status
Retrieves the current state and detailed history of any deployment execution.

### Create or delete projects
Sets up new Vercel projects or permanently removes existing ones.

### Force a build trigger
Initiates a brand-new compilation process from a specific GitHub branch or tag reference.

### Cancel running builds
Immediately aborts any active Vercel compilation pipeline that's taking too long.

## Use Cases

### The domain audit
You need to confirm if a new sub-app is properly routed. Instead of logging into the DNS panel, you ask your agent to run `list_project_aliases` against the target project. It immediately provides the full mapping table.

### The failed deployment
A staging environment build fails overnight. You prompt the agent with `list_deployments`, quickly see the failure ID, and then use `get_deployment_details` to pinpoint the exact error message for the developer.

### The urgent hotfix
A production bug is found. You don't want a full PR cycle; you just need it fixed now. You tell your agent to `trigger_github_deployment` on the specific project using the 'hotfix-v1' tag.

### The initial setup
You start a new client site. Instead of manually creating the structure, you ask the agent to run `list_projects`, see what exists, and then use `create_project` to get the scaffolding started.

## Benefits

- No more guessing if a build finished. Use `get_deployment_details` to check the exact status of any deployment run, so you know instantly if it succeeded or failed.
- Spin up new test environments on demand. You can use `create_project` and immediately start testing infrastructure without manual setup in the dashboard.
- Pinpoint where traffic is going. Running `list_project_aliases` shows every single subdomain mapping for a project, making domain debugging fast.
- Need to roll back or test a hotfix? Use `trigger_github_deployment` to force a build from any specific Git tag without needing a full push cycle.
- Stop wasting time on failed builds. If something is stalled, you can use `cancel_active_build` to clear the queue and move on.

## How It Works

The bottom line is you manage complex web infrastructure tasks by talking to your agent, not by clicking through the Vercel website.

1. Start by letting your agent list all existing projects to confirm the correct target.
2. Next, instruct your agent to pull the current build status or project details for validation.
3. Finally, tell it to trigger a deployment using `trigger_github_deployment` or cancel an active compile via `cancel_active_build`.

## Frequently Asked Questions

**How do I check the status of my latest build using the `list_deployments` tool?**
Run `list_deployments` first to get a list of recent deployment IDs. Then, provide one of those IDs to `get_deployment_details` for the full, current state report.

**Can I force a build using `trigger_github_deployment`?**
Yes, you specify the exact project name and the GitHub reference (like a branch or tag) to kick off a new compilation cycle immediately.

**What is the difference between `list_projects` and `list_account_domains`?**
`list_projects` gives you an inventory of all project containers. `list_account_domains` shows the highest-level custom domains that are bound to your entire Vercel account.

**I need to delete a service, should I use `delete_project`?**
Yes, if you want to permanently remove an entire project and all its associated settings, `delete_project` is the tool. Remember this action cannot be undone.

**When should I use `list_project_aliases` instead of listing domains?**
Use `list_project_aliases` when you need specific subdomain mapping details for one project. While domain listings show high-level apex domains, aliases tell you exactly which custom subdomain points to that particular service build.

**How do I use `create_project` if I'm starting a brand new application?**
Just run `create_project` and provide the desired name along with its framework slug. This instantly provisions a whole new Vercel project environment, letting you start deploying immediately from chat.

**If my deployment fails, what information can I grab using `get_deployment_details`?**
It pulls the full status and detailed logs for a specific build. You'll find out why it failed—be it compilation errors or missing environment variables—giving you the exact data needed to fix it.

**How do I stop an ongoing build that is stalled or incorrect using `cancel_active_build`?**
Calling `cancel_active_build` sends the abort signal directly to Vercel. This stops resource consumption instantly, which is handy when you realize a deployment was triggered from the wrong Git branch.