Skip to main content
MCP is an open protocol that enables Devin to use hundreds of external tools and data sources. Devin supports 3 transport methods (stdio, SSE, and HTTP).

Why use MCP?

With MCP, Devin can help you:
  • dig through Sentry, Datadog and Vercel logs
  • use Devin as a data analyst in Slack with database MCPs
  • dig into SonarQube, CircleCI, and Jam issues
  • bulk create Linear tickets, Notion docs, Google Docs (through Zapier) and more
  • pull in context from and interact with Airtable, Stripe, and Hubspot
  • a lot more!

Get started with MCPs

Navigate to Settings > MCP Marketplace to enable an MCP.

Configuration tips

For MCPs that authenticate with OAuth, Devin will prompt you to visit a URL to connect your account. We strongly recommend using a service account, not your personal account, as access will be shared within your organization.
Don’t see the MCP you’re looking for? Set it up using the “Add Your Own” option!Having trouble? Contact us via our support page or via support@cognition.ai.

Setting up a custom MCP server

If the MCP you need isn’t in the marketplace, you can add any MCP server using the Add Your Own option. Devin supports three transport types for custom servers:
TransportBest forRequired fields
STDIOLocal CLI-based servers (e.g., npx, uvx, Docker)Command, args, env variables
SSERemote servers using Server-Sent EventsServer URL, headers
HTTPRemote servers using Streamable HTTPServer URL, headers

Step-by-step: Adding a custom MCP server

  1. Navigate to Settings > MCP Marketplace.
  2. Click Add Your Own at the top of the page.
  3. Fill in the server details:
    • Server Name: A descriptive name for the server (e.g., “Internal API Gateway”).
    • Icon (optional): An emoji or URL to use as the server’s icon.
    • Short Description: A brief summary of what the server does.
  4. Select the transport type (STDIO, SSE, or HTTP).
  5. Fill in the transport-specific configuration fields (see Configuration format below).
  6. Click Save to create the server.
  7. Click Test listing tools to verify the connection. Devin will spin up an isolated test environment, connect to your server, and attempt to discover its available tools.
The Test listing tools button is disabled until you save your configuration. If validation fails, check the error message displayed — it will indicate whether the issue is with connectivity, authentication, or a timeout.

Configuration format

The examples below show JSON representations of each transport’s configuration fields. In practice, you fill these in through the web form — you do not need to write or paste JSON. The JSON format is shown here for clarity and as a reference for API-based or programmatic setups.

STDIO transport

Use STDIO for servers that run as local processes. You provide the command to launch the server, along with any arguments and environment variables. Fields:
  • Command (required): The executable to run (e.g., npx, uvx, docker).
  • Arguments: Command-line arguments passed to the server.
  • Environment Variables: Key-value pairs set in the server’s process environment. Use these to pass API keys, tokens, or configuration values.
Example — a custom STDIO server using npx:
{
  "transport": "STDIO",
  "command": "npx",
  "args": ["-y", "@example/my-mcp-server"],
  "env_variables": {
    "API_KEY": "your-api-key",
    "API_BASE_URL": "https://internal-api.example.com"
  }
}
Example — a custom STDIO server using Docker:
{
  "transport": "STDIO",
  "command": "docker",
  "args": ["run", "-i", "--rm", "-e", "DB_CONNECTION_STRING", "my-org/my-mcp-server:latest"],
  "env_variables": {
    "DB_CONNECTION_STRING": "postgresql://user:pass@host:5432/mydb"
  }
}

SSE and HTTP transports

Use SSE or HTTP for remote servers accessible over the network. HTTP (Streamable HTTP) is recommended for new integrations; SSE is supported for legacy servers. Fields:
  • Server URL (required): The endpoint URL of the MCP server.
  • Authentication method: Choose between None, Auth Header, or OAuth.
    • For Auth Header: Provide the header key (defaults to Authorization) and the header value (e.g., Bearer your-token).
    • For OAuth: Devin will prompt you to complete an OAuth flow during your first session.
Example — a remote HTTP server with bearer token auth:
{
  "transport": "HTTP",
  "url": "https://mcp.internal-service.example.com/mcp",
  "auth_method": "auth_header",
  "headers": {
    "Authorization": "Bearer your-api-token"
  }
}
Example — a remote SSE server with no auth:
{
  "transport": "SSE",
  "url": "https://mcp.example.com/sse"
}
When choosing between SSE and HTTP, prefer HTTP (Streamable HTTP). SSE is a legacy protocol and is being deprecated across the MCP ecosystem.

Common patterns

Connecting to an internal API

Expose your internal API as an MCP server so Devin can query it directly. Use the STDIO transport with a wrapper that translates MCP tool calls into API requests.
{
  "transport": "STDIO",
  "command": "npx",
  "args": ["-y", "@example/api-mcp-bridge"],
  "env_variables": {
    "API_BASE_URL": "https://api.internal.example.com",
    "API_TOKEN": "your-internal-api-token"
  }
}
Alternatively, if your internal API is reachable over the network, use the HTTP transport:
{
  "transport": "HTTP",
  "url": "https://api.internal.example.com/mcp",
  "headers": {
    "Authorization": "Bearer your-internal-api-token"
  }
}

Connecting to a database

Use a database MCP server to give Devin read or write access to your data. Many community-maintained servers exist for common databases.
{
  "transport": "STDIO",
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://user:password@host:5432/database"]
}
For production databases, use a read-only connection string or a database user with restricted permissions. Devin executes queries based on user instructions, so scoping access appropriately is important.

Connecting to a custom tool or script

Wrap any CLI tool or script as an MCP server. For example, a Python-based server using uvx:
{
  "transport": "STDIO",
  "command": "uvx",
  "args": ["my-custom-mcp-server"],
  "env_variables": {
    "CONFIG_PATH": "/path/to/config.json"
  }
}
Or a Docker-based server for isolated execution:
{
  "transport": "STDIO",
  "command": "docker",
  "args": ["run", "-i", "--rm", "my-org/custom-mcp-server:latest"]
}

Using environment variables for secrets

Pass sensitive values through environment variables rather than hardcoding them in arguments. Devin’s Secrets feature can manage these values — store your API keys or tokens as secrets, then reference them in your MCP server configuration.

Troubleshooting custom MCP servers

”Test listing tools” fails

SymptomLikely causeFix
”Verify server URL and network connectivity”The server URL is unreachableCheck that the URL is correct and accessible from the internet (or from Devin’s network if using VPN)
“Check authentication credentials and permissions”Invalid or missing auth credentialsVerify your API key, token, or OAuth configuration
”Server took too long to respond - check server status”The server didn’t respond within the timeoutEnsure the server is running and responsive; check for firewall rules blocking the connection
”MCP server validation failed” (generic)Command not found, missing dependencies, or server crashFor STDIO servers, verify the command exists and runs locally; check that all required env variables are set

Server connects but tools aren’t available

  • Verify the server correctly implements the MCP protocol’s tools/list method.
  • For STDIO servers, ensure the process writes valid JSON-RPC messages to stdout and reads from stdin — logging or debug output to stdout will break the protocol.
  • Check that environment variables are set correctly. Missing values (e.g., a blank API key) can cause the server to start but fail to register tools.

OAuth authentication issues

  • When prompted to authenticate, complete the OAuth flow in the browser window that opens. Devin will wait for the callback.
  • If authentication fails, check that the OAuth redirect URI is configured correctly on the provider side.
  • Only organization admins can authenticate OAuth-based MCP servers. If you see a permissions error, contact your org admin.
For OAuth-based MCPs, use a service account rather than your personal account. Access is shared across your organization, and all members’ sessions will use the same authenticated connection.

General debugging tips

  • Check the server locally first. Before adding a custom server to Devin, verify it works by running the command or hitting the URL from your own machine.
  • Review Devin’s session logs. If a server fails during a session, Devin will log the error. Look for MCP-related messages in the session output.
  • Simplify and iterate. Start with the minimal configuration (e.g., no auth, default settings) and add complexity once the basic connection works.
  • Verify environment variables. A common issue is missing or misnamed env variables. Double-check that every required variable is set in the configuration.
If you’re building your own MCP server, the Model Context Protocol specification has detailed documentation on the protocol, transport types, and tool definitions.

Marketplace MCPs

Below are configuration details for specific MCPs available in the marketplace.

Vercel, Atlassian, Notion, Sentry, Neon, Asana, Jam and many more

Many MCPs in our marketplace can be enabled without configuration with 1 click! Just click “Enable”. You’ll be prompted to connect a service account during your Devin session, or when you click “Test listing tools”. Available MCPs include:
  • AlloyDB
  • Asana
  • Atlassian
  • BigQuery
  • Cloud SQL (MySQL)
  • Cloud SQL (PostgreSQL)
  • Cloud SQL (SQL Server)
  • Cloudflare
  • Cortex
  • Dataplex
  • Fireflies
  • Firestore
  • Jam
  • Linear
  • Looker
  • Metabase
  • MySQL
  • Neon
  • Notion
  • PostgreSQL
  • Prisma
  • Sentry
  • Spanner
  • SQL Server
  • Vercel
  • More below!
Linear: If you have the Linear integration connected, Devin already has native Linear tools and you do not need to configure the Linear MCP separately.

Datadog

You’ll need to provide 2 environment variables:
  • DATADOG_API_KEY - Datadog API key, which can be found on the /organization-settings/api-keys page in Datadog
  • DATADOG_APP_KEY - Datadog Application key, which can be found on the /organization-settings/application-keys page in Datadog
DATADOG_SITE (e.g. datadoghq.eu) is an optional environment variable. Documentation

Slack

To get the necessary credentials: Slack bot token: To start, navigate to to api.slack.com/apps and select your app. Then:
  • In the sidebar, navigate to Oauth & Permissions
  • Look for the Bot User OAuth Token (should start with “xoxb-”).
  • If you don’t see your Bot User Oauth Token, make sure you’ve configured app-level tokens (in Settings > Basic Information), added at least 1 scope (in Settings > Oauth & Permissions), and installed your app to your workspace.
Slack team ID:
  • Use the curl command: curl -H "Authorization: Bearer xoxb-your-token" https://slack.com/api/auth.test where xoxb-your-token should be replaced with your OAuth token
Slack channel IDs:
  • Use the curl command: curl -H "Authorization: Bearer xoxb-your-token" https://slack.com/api/conversations.list where xoxb-your-token is replaced with your OAuth token
  • For this command to work, you’ll need to add at least the following scopes: channels:read,groups:read,mpim:read,im:read
Documentation

Supabase

You’ll need to provide a personal access token, which you can find and create at https://supabase.com/dashboard/account/tokens Documentation

Figma

You’ll need to provide a Figma API key to enable this MCP:
  1. From the home page in Figma, click the profile icon in the top left corner and select Settings from the dropdown.
  2. In the settings menu, select the Security tab.
  3. Scroll down to the Personal access tokens section and click Generate new token.
  4. Enter a name for the token and make sure you provide the appropriate permissions. We recommend at least read permissions on File content and Dev resources.
  5. Click Generate token.
When using this MCP, make sure to send Devin a link to your Figma file. NOTE: This is a third-party MCP integration not built or maintained by Figma. Documentation

Stripe

You’ll need to provide an authorization header which follows the format Bearer <TOKEN>, where <TOKEN> is your Stripe API key. More info at: https://docs.stripe.com/mcp#bearer-token Documentation

Zapier

You’ll need to provide an authorization header which follows the format Bearer <TOKEN>. You’ll need to extract your Bearer token from the Server URL provided at https://mcp.zapier.com/mcp/servers > Connect Your Server URL will look like: https://mcp.zapier.com/api/mcp/s/*****/mcp Extract the starred section (*****) and use it in the authorization header you provide: Bearer *****
Devin
Documentation

Airtable

You’ll need to provide an Airtable API key. You can find your API keys at: https://airtable.com/create/tokens Documentation

Docker Hub

Credentials required:
  • Docker Hub username: This can be obtained from My Hub
  • Personal Access Token: Go to Account settings > Personal access tokens and create a token
    Devin
Documentation

SonarQube

To get the required credentials: Documentation

Netlify

You’ll need to provide a Personal Access Token, which you can view and create at https://app.netlify.com/user/applications#personal-access-tokens. Make sure to copy the PAT as soon as it is created. You won’t be able to see it again!
Devin
Documentation

Pulumi

A Pulumi access token can be obtained from the Access tokens section in the sidebar of the Pulumi dashboard.
Devin
Documentation

Parallel

You’ll need to provide an API key, which you can generate at https://platform.parallel.ai/ Documentation

Heroku

You’ll need to provide an API Key, which you can find at https://dashboard.heroku.com/account
Devin
Documentation

CircleCI

You’ll need to provide 2 environment variables:
Devin
  • CIRCLECI_BASE_URL [Optional] - This is optional and is required for on-prem customers only. The default value is "https://circleci.com"
Documentation

Cortex

You’ll need to provide a Cortex personal access token to enable this MCP:
  1. Log in to your Cortex instance.
  2. From the left-hand menu, go to Settings → My access tokens.
  3. Click Create new token.
  4. Enter a name for the token and description.
  5. Click Create token and copy the token.
When using this MCP, make sure Devin is configured with the correct Cortex API URL (defaults to https://api.getcortexapp.com). Documentation

Square

You’ll need to provide an authorization header which follows the format Bearer <TOKEN>, where <TOKEN> is your Square access token. More info at: https://developer.squareup.com/docs/build-basics/access-tokens Documentation

Hubspot

You’ll need to provide an access token as an environment variable. To get your access token:
  1. Create a private app in HubSpot:
  2. Go to Settings > Integrations > Private Apps
  3. Click “Create private app”
  4. Name your app and set required scopes
  5. Click “Create app”
  6. Copy the generated access token from the “Auth” tab
Documentation

Redis

Required credentials:
  • Redis host
  • Redis port
  • Redis username
  • Redis password
Documentation

Google Maps

You’ll need to (1) provide an API key (2) enable the individual APIs you’d like Devin to have access to. To get your API key, navigate to https://console.cloud.google.com/apis/credentials and open the sidebar > APIs and services > Credentials. To enable an individual API, search for the API and click enable.
Devin
Devin
Devin
Documentation

Playwright

No environment variables needed for this! Simply enable the integration. Documentation

Firecrawl

You’ll need to provide an API Key (FIRECRAWL_API_KEY), which you can view and create at https://www.firecrawl.dev/app/api-keys. Documentation

ElasticSearch

You’ll need to provide 2 environment variables:
  • ES_URL - ElasticSearch URL or endpoint, which can be found on the /overview page in Elasticsearch.
  • ES_API_KEY - ElasticSearch API key, which can be created on the /indices/index_details/<name>/data page in Elasticsearch.
Devin
ES_SSL_SKIP_VERIFY is an optional environment variable. When set to true , it skips SSL/TLS certificate verification when connecting to Elasticsearch. Documentation

Postgres

The only credential needed is the Postgres connection string. [Documentation] (https://www.npmjs.com/package/@modelcontextprotocol/server-postgres?activeTab=readme)

Plaid

The only credential required is an Oauth bearer access token that can be obtained by running the following code:
curl -X POST https://production.plaid.com/oauth/token \
-H 'Content-Type: application/json' \
-d '{
"client_id": "YOUR_PLAID_CLIENT_ID",
"client_secret": "YOUR_PRODUCTION_SECRET",
"grant_type": "client_credentials",
"scope": "mcp:dashboard"
}'
To obtain the client ID and client production secret, go to https://dashboard.plaid.com/developers/keys Documentation

Replicate

The only required credential is the API token which can be found at https://replicate.com/account/api-tokens Documentation

Grafana

You’ll need to provide 2 environment variables:
  • Grafana URL
  • Grafana service account token: To obtain the token, in the sidebar, go to Administration > Users and access > Service accounts > Add service account (if you don’t already have one added) > Add service account token
Devin

Pinecone

NOTE: The Pinecone MCP supports only indexes with integrated embedding. Indexes for vectors you create with external embedding models are not yet supported as of 7/16/25. The only credential required is the Pinecone API key, which can be obtained via the API keys page in the Pinecone dashboard as seen below:
Devin

Snyk

  1. First, configure the MCP server. Documentation is available here. Note: Make sure to add a env variable at the bottom (not listed in documentation guide).
    Devin
  2. Install the Snyk CLI on Devin’s machine. Documentation is available here
brew tap snyk/tap
brew install snyk-cli

snyk --disable-trust
Note: some Snyk tests require trust to operate - install on machine after homebrew is installed. Documentation is available here. Tip: If configured correctly - the full list of Snyk scans should run on the first pass. However, depending on Framework, some scans require an “unmanaged: true” flag (ex: C++) to be passed. Currently you can set this in knowledge or during your Devin session - here’s an example:
Devin
Tip: We’ve written an example playbook to help you get started. Documentation