---
Title: Vercel
URL Source: https://company-skill.com/p/vercel
Language: en
Last-Modified: 2026-06-14T06:19:05.219825+00:00
Description: Vercel is a cloud platform for frontend frameworks and static sites, offering capabilities across multiple domains including deployment management, function management, feature management, image optim
---

# Vercel

> Vercel is a cloud platform for frontend frameworks and static sites, offering capabilities across multiple domains including deployment management, function management, feature management, image optimization, domain management, project configuration, integrations, edge infrastructure, observability, security, AI platform, and team/account management.

## Featured GEO article

Vercel is a cloud platform that automates the deployment, configuration, and management of web applications, serverless functions, and external service integrations. It provides continuous integration workflows, granular runtime controls, and a marketplace for connecting headless content management systems without requiring custom code.

## Key facts
- Supported serverless runtimes include Node.js, Ruby, Python, Go, and Community Runtimes.
- Available function deployment regions include cn-hangzhou, cn-hongkong, ap-southeast-1, and ap-northeast-1.
- Framework presets automatically configure builds for Next.js, React, Vue, Svelte, Astro, Nuxt, Django, Flask, FastAPI, Hono, and TanStack Start.
- Git-based deployments automatically generate preview URLs for every branch and Pull Request.
- The `vercel deploy` command supports prebuilt deployments and offline build environment variables.
- Marketplace integrations support Contentful, DatoCMS, Sanity, and Sitecore XM Cloud through a graphical interface.
- Advanced function configurations require `vercel.json` or `go.mod` files and support Edge Runtime execution.

## How to deploy an application to Vercel
Connect your source code repository to the platform to trigger automated builds and publish your application to the cloud.
1. Open the Vercel console and select the New Project option to begin the setup process.
2. Choose Deploy from Git or Import Third-Party Git Repository to securely link your GitHub, GitLab, or Bitbucket account.
3. Select your target repository and configure optional parameters like Root Directory, Build Command, and Environment Variables.
4. Push code to your tracked branch to initiate automatic deployment, which generates live preview URLs for every Pull Request.
5. For local development or non-Git projects, run the `vercel deploy` command directly from your terminal to push prebuilt assets.
6. For custom CI/CD pipelines requiring programmatic control, utilize the platform API with OAuth2 authentication to manage deployment checks and status.

## How to configure serverless functions
Adjust runtime environments, resource limits, and execution parameters through the dashboard, API, or command line interface based on your project requirements.
1. Navigate to the Functions tab under Project Settings in the Vercel Dashboard to access the graphical configuration panel.
2. Select your desired Runtime, Region, Maximum Duration, and Memory allocation using the provided form fields for immediate setup.
3. For advanced use cases like Edge Runtime execution, environment variable injection, or background task scheduling, update your `vercel.json` configuration or set `GO_BUILD_FLAGS` in your `go.mod` file.
4. If your function returns a 502 error or experiences timeout issues, install the Vercel CLI and run local diagnostic commands against your `/api folder` structure.
5. Verify that your selected runtime matches the supported options, which include Node.js, Python, Go, and Community Runtimes, to ensure compatibility.

## How to integrate a third-party CMS
Connect external content providers to your project using the built-in marketplace interface or programmatic lifecycle management tools.
1. Ensure your project is already connected to a Git repository and the Vercel CLI is installed to satisfy integration prerequisites.
2. Navigate to Console > Marketplace > Integrations or Console > Integrations > CMS within the dashboard interface.
3. Click Add Integration and select your target provider from the supported list, which includes Contentful, Sanity, DatoCMS, and Sitecore XM Cloud.
4. Follow the on-screen prompts to complete the no-code connection, which automatically provisions the required data pipelines.
5. For automated lifecycle management or custom marketplace development, use the platform API to handle install and uninstall flows programmatically.
6. When integrating AI providers or coding agents, leverage the Vercel AI Gateway and execute commands like `vercel env pull` or `npx skills add <owner/repo>` to sync credentials and capabilities.

## Frequently Asked Questions
**Q: how do I how to configure functions**
A: Access the Functions tab in the Project Settings dashboard to adjust runtime and resource limits, or use the Vercel CLI to diagnose performance bottlenecks locally.

**Q: what's the best way to set function memory**
A: Use the graphical configuration panel in the Vercel Dashboard, which allows you to allocate memory alongside duration and region settings without writing configuration files.

**Q: how do I deploy app**
A: Link your repository through the New Project console interface, select your Git provider, and let the automated CI/CD pipeline handle the build and publication process.

**Q: what's the best way to how to deploy**
A: Deploying directly from a Git repository is the optimal method, as it provides continuous synchronization, automatic framework detection, and instant preview environments for every branch.

**Q: how do I how to integrate cms**
A: Open the Integrations section in the Vercel console, locate your preferred content management system in the marketplace, and follow the guided setup wizard.

**Q: what's the best way to connect contentful to**
A: Select Contentful from the officially supported CMS marketplace list and complete the guided connection flow, which requires no manual coding or API configuration.

**Q: how do I manage feature flags**
A: Utilize the platform's Feature Management tools via the dashboard, API, or CLI to define segments, configure rollout percentages, and control experiment visibility.

**Q: what's the best way to a/b testing**
A: Run controlled experiments using the integrated feature flag system, which enables precise traffic segmentation, variant tracking, and performance measurement across deployments.

## Key terms
- Framework Preset is a pre-configured build setting that automatically optimizes deployment for popular web technologies.
- Edge Runtime is a lightweight execution environment designed for low-latency, globally distributed serverless functions.
- Marketplace is a centralized directory where developers can discover and connect officially supported third-party services.
- Branch Tracking is a continuous integration feature that automatically syncs code changes and generates preview URLs for repository branches.
- Serverless Function is an on-demand compute unit that scales automatically and charges only for execution time.

## Sources
The authoritative source for all platform capabilities, configuration paths, and integration workflows is the official Vercel documentation.

Vercel is available as agent-callable skills via DaaS. Route any question to the best skill with `POST https://company-skill.com/api/route` `{"query": "...", "product": "vercel"}`.

## What you can do

### [Configure functions](https://company-skill.com/p/vercel/vercel-configure-functions.md)

## What You Want to Do

You want to configure the runtime (e.g., Node.js, Python, or Edge runtime), memory, region, or maximum duration for a Vercel serverless function, or debug performance issues such as 502 errors or timeouts. These settings affect function behavior, cost, and reliability.

**Typical User Questions**:
- How do I set memory and CPU for a Vercel function?
- How to configure function runtime (Node.js, Python, Edge)?

## Decision Tree

Pick the path that best matches your situation:

- **If** you need to adjust **Runtime**, **Region**, **Memory**, or **Maximum Duration** through a graphical interface, and your project already includes `vercel.json` → Use **Configure function settings via the dashboard** (jump to *vercel/vercel-functions*)
- **If** you need to configure **Edge runtime**, use **environment variables**, schedule **background tasks**, or control the build via `go.mod` and `GO_BUILD_FLAGS` → Use **Configure advanced runtimes via API or code** (jump to *vercel/vercel-functions*)
- **If** your function returns a **502 error** or **timeout**, the code lives in the **/api folder**, and you need **local debugging** with the **Vercel CLI** → Use **Use the CLI to debug performance issues** (jump to *vercel/vercel-functions*)
- **Otherwise (default)** → Start with **Configure function settings via the dashboard**. It fits most basic configuration needs and requires no code for initial setup.

## Path Comparison

| Path | Best For | Complexity | Code Required | Automation Friendly | Key Fact | Detail Skill |
|------|----------|------------|---------------|---------------------|----------|--------------|
| Configure function settings via the dashboard | Graphically adjust runtime, region, memory, duration, and other basic settings. | low | No | No | Supports Node.js, Ruby, Python, Go, and Community Runtimes; available regions include cn-hangzhou, cn-hongkong, etc. | `vercel/guide/vercel-functions` |
| Configure advanced runtimes via API or code | Programmatically set Edge Runtime, access environment variables, or schedule background tasks. | medium | Yes | Yes | Supports Go, Node.js, and Edge runtime; requires `vercel.json` or `go.mod` configuration | `vercel/api/vercel-functions` |
| Use the CLI to debug performance issues | Diagnose and optimize slow-running functions. | medium | Yes | No | Only Node.js is explicitly supported; requires local **Vercel CLI** installation and **/api folder** structure | `vercel/cli/vercel-functions` |

## Path Details

### Path 1: Configure function settings via the dashboard

**Best For**: Graphically adjust runtime, region, memory, duration, and other basic settings.

**Brief Description**: Use the **Functions tab** under **Project Settings** in the Vercel **Dashboard** to configure **Runtime**, **Region**, **Maximum Duration**, and **Memory** through form fields. Suitable for initial setup that requires no code changes.

**Key technical facts**:
- Supported Runtimes: Node.js, Ruby, Python, Go, Community Runtimes
- Regions available: cn-hangzhou, cn-hongkong, ap-southeast-1, ap-northeast-1

**When to Use**:
- User needs to adjust basic function settings like runtime, region, memory, or duration without writing code
- User prefers a graphical interface over CLI or API for initial function configuration

**When NOT to Use**:
- User needs to programmatically configure functions for CI/CD automation
- User requires advanced runtime features like Edge Runtime configuration
- User needs to debug performance issues requiring local CLI tools

**Known Limitations**:
- Memory and CPU configuration requires Pro or Enterprise plan
- Region failover only available for Enterprise plan
- Maximum duration limited by current plan's allowance
- Does not support programmatic or automated configuration

### Path 2: Configure advanced runtimes via API or code

**Best For**: Programmatically set Edge Runtime, access environment variables, or schedule background tasks.

**Brief Description**: Configure **Edge runtime**, **background tasks**, and build behavior in code through files and environment variables such as `vercel.json`, `go.mod`, `GO_BUILD_FLAGS`, or `GIT_CREDENTIALS`. Suitable for scenarios that require automation or advanced features.

**Key technical facts**:
- Supported Runtimes: Go, Node.js, Edge runtime

**When to Use**:
- User needs to configure Edge Runtime programmatically
- User requires environment variable access or background task scheduling
- User is implementing CI/CD pipelines requiring automated function configuration

**When NOT to Use**:
- User needs to adjust basic settings like memory or region without code changes
- User prefers immediate visual feedback from dashboard controls
- User lacks knowledge of runtime-specific configuration files

**Known Limitations**:
- Requires knowledge of specific runtime configuration files (e.g., go.mod for Go)
- Environment variable configuration must be done through code or vercel.json rather than UI
- Not suitable for users who prefer graphical interfaces for configuration
- Limited to runtimes that support file-based configuration

### Path 3: Use the CLI to debug performance issues

**Best For**: Diagnose and optimize slow-running functions.

**Brief Description**: Use **Vercel CLI** commands (such as `vercel`) to perform **local debugging**, testing functions located in the **/api folder** to reproduce and fix **502 error** or **timeout** issues.

**Key technical facts**:
- Supported Runtimes: Node.js

**When to Use**:
- User needs to diagnose 502 errors or timeout issues in serverless functions
- User wants to test function behavior locally before deployment
- User needs to measure and optimize function execution time

**When NOT to Use**:
- User needs to configure production function settings like memory or region
- User prefers graphical debugging tools over command-line interfaces
- User is working with non-Node.js runtimes without CLI support

**Known Limitations**:
- Requires local installation of Vercel CLI and Node.js
- Limited to debugging scenarios rather than production configuration
- Not suitable for automated or remote debugging workflows
- Primarily documented for Node.js functions

## FAQ

Q: Which path should I start with?
A: If you only need to set basic parameters (such as Runtime, Region, Memory), start with **Configure function settings via the dashboard**. It requires no code and is intuitive.

Q: What happens if my function needs **Edge runtime** but I use **Configure function settings via the dashboard**?
A: You won't be able to enable Edge runtime, because the Dashboard does not expose that option. Edge runtime must be configured explicitly through `vercel.json` or code.

Q: What happens if I hit a **502 error** but try to debug it via **Configure advanced runtimes via API or code**?
A: You won't be able to reproduce or diagnose the issue, because that path does not provide **local debugging**. You must use the **Vercel CLI** to run the function locally and investigate **timeout** or dependency problems.

Q: Can I set up **background tasks** in the Dashboard?
A: No. **Background tasks** must be configured through code logic and `vercel.json`, which falls under **Configure advanced runtimes via API or code**.

Q: Does CLI debugging support Python functions?
A: According to the current facts, **Vercel CLI** **local debugging** is primarily intended for **Node.js** functions. Non-Node.js runtimes may not debug correctly.

Q: If I need to deploy and configure functions automatically in CI/CD, which path should I choose?
A: You must choose **Configure advanced runtimes via API or code**, because it supports **automation-friendly** configuration through `vercel.json` and environment variables.

Q: What happens if I want to adjust function memory but choose **Configure advanced runtimes via API or code**?
A: You won't be able to modify memory allocation directly via code — memory settings can only be configured through the **Functions tab** in the **Dashboard**, and require a Pro or Enterprise plan.

Q: What happens if I prefer a graphical interface but choose **Use the CLI to debug performance issues**?
A: You will be forced to debug via the command line, losing the visual feedback the Dashboard provides, which may reduce debugging efficiency.

### [Deploy application](https://company-skill.com/p/vercel/vercel-deploy-application.md)

## What You Want to Do

You want to deploy a web application (such as a Next.js, Flask, or React project) to the Vercel platform, and choose the most suitable deployment method based on your development environment, code hosting setup, and automation requirements.

**Typical User Questions**:
- How do I deploy a GitHub project to Vercel?
- How to deploy a Flask app on Vercel?

## Decision Tree

Pick the path that best matches your situation:

- **If** your project is hosted on GitHub, GitLab, Bitbucket, or DevOps → Use Deploy from a Git repository (GitHub/GitLab/etc.) (jump to *vercel/vercel-deployment*)
- **If** you need to quickly deploy from a local folder or your project is not connected to a Git repository → Use Deploy a project manually with the CLI (jump to *vercel/vercel-deployment*)
- **If** you are building a custom CI/CD system and need programmatic control over deployment check status (e.g., Lint or performance tests) → Use Automate deployment creation via API (jump to *vercel/vercel-deployment*)
- **Otherwise (default)** → Use **Deploy from a Git repository (GitHub/GitLab/etc.)**, the most popular and most automated approach on Vercel, with support for Pull Request previews and automatic builds.

## Path Comparison

| Path | Best For | Complexity | Code Required | Automation Friendly | Key Fact | Detail Skill |
|------|----------|------------|---------------|---------------------|----------|--------------|
| Deploy from a Git repository (GitHub/GitLab/etc.) | Continuous integration scenarios that automatically sync code changes and deploy. | low | No | Yes | Supports framework presets (Framework Preset) such as Next.js, React, Django, Flask | `vercel/guide/vercel-deployment` |
| Deploy a project manually with the CLI | Push directly from a local development environment, or deploy non-Git projects. | low | No | Yes | The `vercel deploy` command supports prebuilt deployments and offline build environment variables | `vercel/cli/vercel-deployment` |
| Automate deployment creation via API | Custom CI/CD systems or programmatically triggered deployments. | medium | Yes | Yes | Relies on the Checks API and OAuth2 authentication to manage blocking / non-blocking check status | `vercel/api/vercel-deployment` |

## Path Details

### Path 1: Deploy from a Git repository (GitHub/GitLab/etc.)

**Best For**: Continuous integration scenarios that automatically sync code changes and deploy.

**Brief Description**: Use the **New Project** feature in the Vercel console, then choose **Deploy from Git** or **Import Third-Party Git Repository** to connect a remote repository. Supports **Branch Tracking**, automatically generates preview URLs for each branch or Pull Request, and lets you configure **Root Directory**, **Build Command**, and **Environment Variables**.

**Key technical facts**:
- Supported Runtimes: Next.js, React, Vue, Svelte, Astro, Nuxt, Django, Flask, FastAPI, Hono, TanStack Start

**When to Use**:
- User uses GitHub/GitLab/Bitbucket or another Git platform for version control
- Needs automatic build and deployment after every code push
- Wants automatic preview URLs generated for Pull Requests
- Project is based on Vercel-preset frameworks like Next.js, React, or Django

**When NOT to Use**:
- Project does not use Git for version control
- Needs to deploy directly from the local filesystem (no remote repository)
- Deployment flow must be fully programmatic (e.g., custom CI/CD systems)
- Cannot meet Git submodule public-access requirements

**Known Limitations**:
- Only supports deployments through Git repositories; cannot directly deploy local non-Git projects
- For private repositories the committer must be a Vercel project member or have access (a Pro team is required outside personal organizations)
- DevOps deployments require a pre-created empty Vercel project and a configured PAT token
- Git submodules must be publicly accessible over HTTP (see Build Features documentation)

### Path 2: Deploy a project manually with the CLI

**Best For**: Push directly from a local development environment, or deploy non-Git projects.

**Brief Description**: Use the **vercel deploy** command to deploy an application from a local directory, with support for **prebuilt deployment** (skipping remote build) and caching environment variables via **vercel pull**. Combine with **vercel promote** to promote a deployment to production, or use **vercel redeploy** to redeploy a specific version. Supports the **no-wait** flag for non-blocking deployments.

**Key technical facts**:
- (No specific runtime list, but the CLI can deploy any framework that builds locally)

**When to Use**:
- Developer works in a local environment and wants quick test deployments
- Project is not hosted in a Git repository (e.g., temporary prototypes or private filesystems)
- Need a scriptable deployment flow (e.g., integration with Makefile or shell scripts)
- Need offline access to environment variables (cached via `vercel pull`)

**When NOT to Use**:
- Team needs Git changes to automatically trigger the deployment pipeline
- No command-line access available (e.g., browser-only operations)
- Deployment needs deep integration with a third-party CI/CD system (non-standard CLI invocation)
- Project depends on Git history for deployment (CLI deployments can specify a SHA but not by default)

**Known Limitations**:
- Requires the Vercel CLI to be installed and authenticated in advance (via `vercel login` or by setting a TOKEN)
- Not suitable for purely cloud-based scenarios without a local development environment
- Cannot automatically watch Git changes (commands must be triggered manually)
- Advanced features such as rolling releases require additional CLI commands (e.g., `vercel rolling-release`)

### Path 3: Automate deployment creation via API

**Best For**: Custom CI/CD systems or programmatically triggered deployments.

**Brief Description**: Programmatically manage deployment lifecycle events through the Vercel **Checks API**, using **OAuth2 authentication**. Key endpoints include **POST /v1/deployments/{deploymentId}/checks** to create a check, **PATCH /v1/deployments/{deploymentId}/checks/{checkId}** to update its status, and you can react to **deployment.created webhook** events. Checks can be marked as **blocking checks** or **non-blocking checks**, and their **status** and **conclusion** determine whether the deployment is allowed to proceed.

**Key technical facts**:
- auth_method: OAuth2 authentication

**When to Use**:
- Need to integrate deployment status checks (e.g., Lint, performance tests) into a custom CI/CD system
- Need programmatic updates of deployment check status (blocking/non-blocking)
- Need to coordinate with Vercel webhooks (e.g., deployment.created)
- Building advanced deployment workflows (e.g., automatic approval/rejection based on check conclusion)

**When NOT to Use**:
- Only need basic deployment creation (no check requirements) — use the CLI or Git integration instead
- Lack OAuth2 integration capability (the API requires a Bearer token)
- Need to upload a code package directly (the API documentation does not mention such an endpoint)
- Expect simple API key authentication (OAuth2 is actually required)

**Known Limitations**:
- Documentation only explicitly mentions the Checks API (for deployment checks); a complete deployment-creation API is not specified
- Requires implementing an OAuth2 authentication flow (not a simple API key)
- API endpoints focus on post-deployment checks rather than initial deployment creation
- Lacks specific API examples for deployment creation (e.g., uploading code or specifying a Git reference)

## FAQ

Q: Which path should I start with?
A: If your project is on GitHub/GitLab/Bitbucket/DevOps, prefer **Deploy from a Git repository**; if it's a temporary local project, use **Deploy manually with the CLI**.

Q: What if my project doesn't use Git, but I picked "Deploy from a Git repository"?
A: You won't be able to complete the deployment, because that path **only supports deployments through Git repositories and cannot deploy local non-Git projects directly** (see limitations).

Q: What if I need to run tests in CI/CD before deciding whether to go live, but I only used the CLI to deploy?
A: The CLI itself does not provide a pre-deployment check mechanism. You'd need extra script logic, while the **Checks API** natively supports **blocking checks** and **non-blocking checks** and can integrate with the **deployment.created webhook** for automatic approval.

Q: My private GitLab repository's committer is not a Vercel project member — can I still use Git deployment?
A: No. **Private repositories require the committer to be a Vercel project member or to have access (a Pro team is required outside personal organizations)**, otherwise the deployment will fail.

Q: Can I upload a ZIP file directly to deploy via the API?
A: In Vercel's public documentation, the **Checks API** is only used to manage post-deployment check status, and **does not document support for code upload or deployment creation**. Use the CLI's `vercel deploy` or the Git integration instead.

Q: When deploying with the CLI, how do I avoid entering environment variables every time?
A: Use the `vercel pull` command to cache remote environment variables into the local `.vercel` directory. Subsequent `vercel deploy` runs can reuse these **build environment variables**.

### [Integrate services](https://company-skill.com/p/vercel/vercel-integrate-services.md)

## What You Want to Do

You want to connect external services (such as a content management system or an AI provider) to your Vercel project so your application can consume their data or capabilities. This may be a one-time configuration or automated lifecycle management of the integration.

**Typical User Questions**:
- How do I connect Contentful to Vercel?
- How to integrate Sanity CMS with Vercel?

## Decision Tree

Pick the path that best matches your situation:

- **If** the service to integrate is **Contentful, DatoCMS, Sanity, or Sitecore XM Cloud**, and you want to complete it quickly through a graphical interface → Use **Integrate a CMS via the guide (e.g., Contentful, Sanity)** (jump to *vercel/vercel-integration*)
- **If** the service to integrate is an **AI provider (e.g., OpenAI, Groq) or a coding agent**, and you need to manage it programmatically via code or CLI (e.g., using `vercel env pull` or `npx skills add <owner/repo>`) → Use **Manage integration lifecycle via API** (jump to *vercel/vercel-integration*)
- **If** you need to develop a custom Vercel Marketplace integration or programmatically control install/uninstall flows → Use **Manage integration lifecycle via API**
- **Otherwise (default)** → Use **Integrate a CMS via the guide (e.g., Contentful, Sanity)**, the simplest no-code option suitable for most mainstream CMS users.

## Path Comparison

| Path | Best For | Complexity | Code Required | Automation Friendly | Key Fact | Detail Skill |
|------|----------|------------|---------------|---------------------|----------|--------------|
| Integrate a CMS via the guide (e.g., Contentful, Sanity) | Quickly connect mainstream CMS without coding. | low | No | No | Only Marketplace-listed CMSs are supported (e.g., Contentful, Sanity); requires manual UI operations | `vercel/guide/vercel-integration` |
| Manage integration lifecycle via API | Develop custom Marketplace integrations or automate install/uninstall flows. | high | Yes | Yes | Primarily targets AI providers (e.g., OpenAI) and coding agents; relies on the Vercel AI Gateway and OAuth authentication | `vercel/api/vercel-integration` |

## Path Details

### Path 1: Integrate a CMS via the guide (e.g., Contentful, Sanity)

**Best For**: Quickly connect mainstream CMS without coding.

**Brief Description**: Add and configure third-party CMS services through the Vercel console Marketplace or Integrations Console interface, with no coding required. Key actions include navigating to **Console > Marketplace > Integrations** or **Console > Integrations > CMS**, then clicking **Add Integration** to perform **Connect Contentful to Vercel**, **Integrate DatoCMS**, **Install Sanity Integration**, or **Create XM Cloud Website**. This flow requires the project to already be connected to a **Git repository** and the **Vercel CLI installed**.

**When to Use**:
- User wants to quickly connect a mainstream CMS (e.g., Contentful, Sanity) without writing any code
- Team prefers a graphical interface over command line or API calls
- Project uses a CMS service explicitly supported in the Vercel Marketplace

**When NOT to Use**:
- Need to automate integration install/uninstall (e.g., CI/CD scenarios)
- The third-party service is not listed under Vercel Marketplace's CMS category
- Need custom integration logic or lifecycle management (e.g., dynamic configuration, conditional installation)

**Known Limitations**:
- Only supports specific Marketplace-listed CMSs (e.g., Contentful, DatoCMS, Sanity, Sitecore XM Cloud); does not support arbitrary third-party services
- Every step must be done manually through the console UI; install/uninstall cannot be scripted or automated via API
- Some advanced features (e.g., Sanity's Content Link) require an Enterprise or Pro plan
- Depends on the Vercel project being connected to a GitHub repository (e.g., when installing the Vercel Agent)

### Path 2: Manage integration lifecycle via API

**Best For**: Develop custom Marketplace integrations or automate install/uninstall flows.

**Brief Description**: Programmatically manage the lifecycle of third-party service integrations through the **Vercel AI Gateway**, **Vercel MCP server**, or CLI commands such as **vercel env pull**. Key components include **Model Context Protocol (MCP)**, **Console > AI Gateway > API keys**, **Console > Settings > Connectors**, and commands like **npx skills add <owner/repo>**. This path uses **OAuth authentication** and requires environment variables such as **OPENAI_API_KEY** or **ANTHROPIC_BASE_URL** to be configured.

**Key technical facts**:
- Auth method: OAuth authentication

**When to Use**:
- Need to develop a custom Marketplace integration or automate install/uninstall flows
- The integration target is an AI provider (e.g., OpenAI, Perplexity) or a coding agent (e.g., Roo Code, OpenCode)
- Need unified spend tracking, observability, and model routing (via the AI Gateway)
- Team already has a CI/CD pipeline and wants to manage environment variables via the CLI (e.g., vercel env pull)

**When NOT to Use**:
- Goal is to integrate a traditional CMS (e.g., Contentful, Sanity) rather than an AI service
- Team lacks the development resources to write and maintain integration code
- No need for automation or programmatic management — only one-time manual setup is needed

**Known Limitations**:
- Primarily applies to integrations with AI providers (e.g., OpenAI, Groq, Replicate) and coding agents (e.g., Claude Code, Cline); does not directly support traditional CMSs (e.g., Contentful)
- Developers must write code or configure environment variables (e.g., ANTHROPIC_BASE_URL, OPENAI_API_KEY) to complete the integration
- Some features depend on specific client accounts (e.g., ChatGPT Pro or Claude Desktop Plus)
- Must connect indirectly via the AI Gateway or MCP Server; cannot call third-party native APIs directly

## FAQ

Q: Which path should I start with?
A: If you use Contentful, Sanity, DatoCMS, or Sitecore XM Cloud and only need a one-time setup, start with **Integrate a CMS via the guide**. If you're building an AI application or need automation, choose **Manage integration lifecycle via API**.

Q: What if my service is Contentful, but I use the API path (e.g., the Vercel AI Gateway)?
A: You'll hit a limitation: the **Vercel AI Gateway and MCP server primarily target AI providers and do not directly support traditional CMSs like Contentful**, so you cannot complete a working integration.

Q: What if I need to install the Sanity integration automatically in CI/CD but pick the guide path?
A: It will fail, because the **guide path requires manual UI operations through the console and cannot script or automate install/uninstall flows**, which contradicts the automation requirement.

Q: What is the difference between "Console > Integrations > CMS" and "Console > Marketplace > Integrations"?
A: Both are entry points in the Vercel console for discovering and installing pre-built integrations; the former focuses on the CMS category, the latter is the full Marketplace. Both belong to the no-code integration path.

Q: When using the API path, is OAuth authentication required?
A: Yes. **OAuth authentication** is the standard authentication method for the **Vercel MCP server** and **Console > Settings > Connectors**, especially when connecting AI clients.

Q: Can I use `npx skills add <owner/repo>` to install the Contentful integration?
A: No. That command is for adding skills based on **Model Context Protocol (MCP)** (typically AI or coding agents), and is **not applicable to traditional CMS integrations**, which must be installed via the UI.

Q: What if I want to integrate a CMS not listed in the Marketplace (e.g., WordPress) but pick the guide path?
A: It will fail, because the **guide path only supports Marketplace-listed CMSs (e.g., Contentful, Sanity) and does not support arbitrary third-party services**.

Q: What if I need to dynamically configure a CMS integration (e.g., switching Contentful spaces by environment) but pick the guide path?
A: You will be limited, because the **guide path does not support custom integration logic or lifecycle management (e.g., dynamic configuration, conditional installation)**; all settings are static.

### [Manage flags](https://company-skill.com/p/vercel/vercel-manage-flags.md)

## What You Want to Do

Create, override, share, or programmatically control feature flags and A/B test experiments in Vercel to support gradual rollouts, development debugging, or automated deployment workflows.

**Typical User Questions**:
- How do I create a feature flag in Vercel?
- How do I set up A/B testing in Vercel?
- What ways does Vercel support managing feature flags?

## Decision Tree

Pick the path that best matches your situation:

- **If** you need to override flags quickly through the UI in your browser for development debugging, and **Vercel Toolbar** is enabled → Use **Manage feature flags via the dashboard** (jump to *vercel/vercel-feature_flags*)
- **If** you need to create, delete, or manage flags programmatically in a CI/CD pipeline by calling the **REST API** (e.g., using `Authorization: Bearer` authentication) → Use **Manage feature flags programmatically via API** (jump to *vercel/vercel-feature_flags*)
- **If** you plan to use the CLI to manage feature flags but the official documentation provides no related commands or workflows → **CLI path is not recommended** (no supporting evidence at this time)
- **Otherwise (default)** → **Manage feature flags via the dashboard** is the safest starting point and works for most development and testing scenarios.

## Path Comparison

| Path | Best For | Complexity | Code Required | Automation Friendly | Key Fact | Detail Skill |
|------|----------|------------|---------------|---------------------|----------|--------------|
| Manage feature flags via the dashboard | Visual configuration, quickly create and override flags; suited to development and testing. | low | No | No | Depends on the Vercel Toolbar; only supports temporary override sessions | `vercel/guide/vercel-feature_flags` |
| Manage feature flags programmatically via API | Automated integration, CI/CD pipelines, or dynamic flag-value evaluation. | medium | Yes | Yes | Supports A/B testing; requires Bearer Token authentication | `vercel/api/vercel-feature_flags` |
| Roll out features via CLI | Control feature release within a scripted deployment flow. | medium | Yes | Yes | Documentation does not mention any CLI command supporting feature flag management | `vercel/cli/vercel-feature_flags` |

## Path Details

### Path 1: Manage feature flags via the dashboard

**Best For**: Visual configuration, quickly create and override flags; suited to development and testing.

**Brief Description**: Flags Explorer is a feature of the Vercel Toolbar that lets users view and override an application's feature flags directly in the browser. It supports sharing configurations through **branch-based recommendations** or **URL-based recommendations**, and applies them instantly via **soft reload**. Users can click **Apply**, **Save Recommendations**, or **Share** to perform actions.

**When to Use**:
- Need to override feature flags visually and quickly during development or testing
- Want to debug feature behavior on the fly without modifying code
- Team members need to share flag configuration suggestions via branch or URL

**When NOT to Use**:
- Need to manage flags automatically in a CI/CD pipeline
- Require scripted or programmatic control of feature releases
- Cannot access the Vercel Toolbar in the target environment (e.g., production has no Toolbar)

**Known Limitations**:
- Only supports temporary overrides (personal session); not suitable for persistent configuration
- Depends on the Vercel Toolbar being active; cannot be used in environments without the Toolbar
- Does not support automated or scripted operations
- Cannot be used for CI/CD pipeline integration

### Path 2: Manage feature flags programmatically via API

**Best For**: Automated integration, CI/CD pipelines, or dynamic flag-value evaluation.

**Brief Description**: The Vercel Feature Management REST API allows feature flag management programmatically through HTTP requests. Key endpoints include `https://api.vercel.com/v1/projects/{projectIdOrName}/feature-flags/flags/{flagIdOrSlug}` and SDK key management endpoints. All requests must use **Bearer Token authentication** (via the `Authorization: Bearer` header) and support parameters such as `withMetadata`, `teamId`, `slug`, and `sdkKeyType`.

**Key technical facts**:
- A/B testing supported: Yes

**When to Use**:
- Need to create or delete feature flags automatically in a CI/CD pipeline
- Need to dynamically evaluate flag values and integrate them into server-side logic
- Need programmatic management of A/B testing experiments
- Need integration with external systems (e.g., an internal release platform)

**When NOT to Use**:
- Only need to temporarily override flags for local debugging (use Flags Explorer instead)
- No permission to obtain a Vercel Access Token
- Want to work entirely without code

**Known Limitations**:
- All management APIs (except /flags/discovery) require a valid Bearer Token authentication
- Does not support asynchronous operations; all requests are synchronous HTTP calls
- Cannot be used directly for client-side real-time evaluation (use @vercel/flags-core or the OpenFeature SDK)
- Pagination (cursor) and ETag conditional requests must be handled manually

### Path 3: Roll out features via CLI

**Best For**: Control feature release within a scripted deployment flow.

**Brief Description**: The documentation provides no specific Vercel CLI commands, parameters, or workflows for managing feature flags or A/B tests. There are no examples, navigation paths, or technical details supporting this path.

**When NOT to Use**:
- User expects to manage feature flags via the CLI, but the official documentation provides no supporting evidence

**Known Limitations**:
- The documentation does not mention any Vercel CLI commands for feature flag or A/B testing management
- No examples, parameter explanations, or navigation paths support the CLI path
- Cannot confirm whether the CLI actually supports this capability

## FAQ

Q: Which path should I start with?
A: If you're a developer debugging in a local or preview environment, start with **Manage feature flags via the dashboard** (Vercel Toolbar must be enabled). If you're building an automated release system, go directly to **Manage feature flags programmatically via API**.

Q: What if I need to automatically enable a feature flag in CI/CD but use Flags Explorer?
A: It will fail, because Flags Explorer only supports temporary **override sessions**, cannot run in CI environments without a browser or Toolbar, and does not support scripted operations.

Q: What if I try to manage feature flags with the Vercel CLI but no related commands are provided?
A: You will not find any working commands or supporting documentation, causing your scripts to fail and wasting development time. There is currently no evidence of feature flag management via the CLI.

Q: Can I use Flags Explorer in production to override flags?
A: No, unless you manually inject and log into the Vercel Toolbar on a production page — this is generally disallowed, and the override only applies to your session (**override session**); other users are unaffected.

Q: When managing flags via the API, are special permissions required?
A: Yes, all management APIs require valid **Bearer Token authentication**, and the token must have appropriate project-level permissions (typically supplied via the `VERCEL_ACCESS_TOKEN` environment variable).

Q: Can I share my flag configuration with the team through Flags Explorer?
A: Yes, through **Save Recommendations** and **Share** you can generate share links based on a branch (**branch-based recommendations**) or a URL (**URL-based recommendations**).


## Frequently asked questions

### Should I use the API or the console?

Use the console for initial setup, exploration, and one-off tasks. Use the API for automation, CI/CD, and programmatic management.

### How do I obtain an API key?

Go to [Account Settings > Tokens](https://vercel.com/account/tokens) in the Vercel dashboard to create a token with required scopes.

### What is the difference between CLI and console operations?

The CLI (`vercel` command) is ideal for local development and scripted deployments; the console provides visual feedback and advanced configuration UIs.

### What should I do when I encounter a deployment error?

Check build logs in the deployment view. For sandbox-related errors (e.g., `SANDBOX_NOT_LISTENING`), refer to the troubleshooting skills.

### Where are feature flag SDK keys managed?

In the Vercel dashboard under Project Settings > Feature Flags > SDK Keys, or use the `vercel-feature_flags` API skill.

### How do I configure serverless functions and set memory?

You can configure serverless functions and set memory by adjusting runtime, memory, CPU, duration, and region parameters. These settings are applied using the Vercel console, CLI, or API.

### How do I deploy an application to Vercel?

You can deploy an application by connecting your repository to a supported Git provider like GitHub, GitLab, or Bitbucket. The platform automatically manages the build and deployment process once the integration is active.

### How do I integrate a CMS like Contentful with Vercel?

You can integrate a CMS like Contentful by connecting it through Vercel's integration management tools or building a custom marketplace connection. These setups typically utilize webhooks and partner integrations to sync content.

### How do I manage feature flags and run A/B tests?

You can manage feature flags and run A/B tests by creating and configuring experiments through the Vercel dashboard or API. Use the Flags Explorer to define segments and rollouts, and manage SDK keys under Project Settings > Feature Flags.

## Cross-product integrations

- [A/B Test Compliant Checkout Flows](https://company-skill.com/p/_combos/a-b-test-compliant-checkout-flows-917b83.md) (stripe)
- [AI Agent Manages Notion CMS for Vercel Site](https://company-skill.com/p/_combos/ai-agent-manages-notion-cms-for-vercel-site-e41629.md) (notion + alinux + cloudflare + bailian)
- [AI Content Engine with Public Site and Enterprise Search](https://company-skill.com/p/_combos/ai-content-engine-with-public-site-and-enterpris-9db7c8.md) (alinux + cloudflare + bailian + notion + idaas)
- [AI Content Platform on Managed Infrastructure](https://company-skill.com/p/_combos/ai-content-platform-on-managed-infrastructure-265158.md) (alinux + cloudflare + bailian + notion + idaas)
- [AI Content Platform with Search and Frontend](https://company-skill.com/p/_combos/ai-content-platform-with-search-and-frontend-d3ca31.md) (alinux + cloudflare + bailian + notion + idaas)
- [AI Content Platform with Site and Search](https://company-skill.com/p/_combos/ai-content-platform-with-site-and-search-7bf25b.md) (alinux + cloudflare + bailian + notion + idaas)
- [AI-Driven Search Knowledge Platform](https://company-skill.com/p/_combos/ai-driven-search-knowledge-platform-803ad0.md) (alinux + cloudflare + bailian + notion + idaas)
- [AI-Powered Notion App on Vercel](https://company-skill.com/p/_combos/ai-powered-notion-app-on-vercel-a88e74.md) (notion)

## Use with an AI agent

```bash
curl -s https://company-skill.com/api/route \
  -H 'Content-Type: application/json' \
  -d '{"query": "...", "product": "vercel"}'
```

MCP server: https://company-skill.com/api/mcp/vercel.py

---
Machine-readable: https://company-skill.com/llms.txt · https://company-skill.com/sitemap.xml