Tavily MCP Server

The Tavily MCP server provides:

• search, extract, map, crawl tools
• Real-time web search capabilities through the tavily-search tool
• Intelligent data extraction from web pages via the tavily-extract tool
• Powerful web mapping tool that creates a structured map of website
• Web crawler that systematically explores websites

Helpful Resources

• Tutorial on combining Tavily MCP with Neo4j MCP server
• Tutorial on integrating Tavily MCP with Cline in VS Code

Remote MCP Server

Connect directly to Tavily's remote MCP server instead of running it locally. This provides a seamless experience without requiring local installation or configuration.

Simply use the remote MCP server URL with your Tavily API key:

https://mcp.tavily.com/mcp/?tavilyApiKey=<your-api-key>

Get your Tavily API key from tavily.com.

Alternatively, you can pass your API key through an Authorization header if the MCP client supports this:

Authorization: Bearer <your-api-key>

Note: When using the remote MCP, you can specify default parameters for all requests by including a DEFAULT_PARAMETERS header containing a JSON object with your desired defaults. Example:

{"include_images":true, "search_depth": "basic", "max_results": 10}

Connect to Claude Code

Claude Code is Anthropic's official CLI tool for Claude. You can add the Tavily MCP server using the claude mcp add command. There are two ways to authenticate:

Option 1: API Key in URL

Pass your API key directly in the URL. Replace <your-api-key> with your actual Tavily API key:

claude mcp add --transport http tavily https://mcp.tavily.com/mcp/?tavilyApiKey=<your-api-key>

Option 2: OAuth Authentication Flow

Add the server without an API key in the URL:

claude mcp add --transport http tavily https://mcp.tavily.com/mcp

After adding, you'll need to complete the authentication flow:

1. Run claude to start Claude Code
2. Type /mcp to open the MCP server management
3. Select the Tavily server and complete the authentication process

Tip: Add --scope user to either command to make the Tavily MCP server available globally across all your projects:

claude mcp add --transport http --scope user tavily https://mcp.tavily.com/mcp/?tavilyApiKey=<your-api-key>

Once configured, you'll have access to the Tavily search, extract, map, and crawl tools.

Connect to Cursor

Click the ⬆️ Add to Cursor ⬆️ button, this will do most of the work for you but you will still need to edit the configuration to add your API-KEY. You can get a Tavily API key by signing up for a free account.

Once you click the button you should be redirect to Cursor ...

Step 1

Click the install button

Step 2

You should see the MCP is now installed, if the blue slide is not already turned on, manually turn it on. You also need to edit the configuration to include your own Tavily API key.

Step 3

You will then be redirected to your mcp.json file where you have to add your-api-key.

{
  "mcpServers": {
    "tavily-remote-mcp": {
      "command": "npx -y mcp-remote https://mcp.tavily.com/mcp/?tavilyApiKey=<your-api-key>",
      "env": {}
    }
  }
}

Remote MCP Server OAuth Flow

The Tavily Remote MCP server supports secure OAuth authentication, allowing you to connect and authorize seamlessly with compatible clients.

How to Set Up OAuth Authentication

A. Using MCP Inspector:

• Open the MCP Inspector and click "Open Auth Settings".
• Select the OAuth flow and complete these steps:
  1. Metadata discovery
  2. Client registration
  3. Preparing authorization
  4. Request authorization and obtain the authorization code
  5. Token request
  6. Authentication complete

Once finished, you will receive an access token that lets you securely make authenticated requests to the Tavily Remote MCP server.

B. Using other MCP Clients (Example: Cursor):

You can configure your MCP client to use OAuth without including your Tavily API key in the URL. For example, in your mcp.json:

{
  "mcpServers": {
    "tavily-remote-mcp": {
      "command": "npx mcp-remote https://mcp.tavily.com/mcp",
      "env": {}
    }
  }
}

If you need to clear stored OAuth credentials and reauthenticate, run:

rm -rf ~/.mcp-auth

Note:

• OAuth authentication is optional. You can still use API key authentication at any time by including your Tavily API key in the URL query parameter (?tavilyApiKey=...) or by setting it in the Authorization header, as described above.

Selecting Which API Key Is Used for OAuth

After successful OAuth authentication, you can control which API key is used by naming it mcp_auth_default:

• If you set a key named mcp_auth_default in your personal account, that key will be used for the auth flow.
• If you are part of a team that has a key named mcp_auth_default, that key will be used for the auth flow.
• If you have both a personal key and a team key named mcp_auth_default, the personal key will be prioritized.
• If no mcp_auth_default key is set, the default key in your personal account will be used. If no default key is set, the first available key will be used.

Local MCP

Prerequisites

Before you begin, ensure you have:

• Tavily API key
  • If you don't have a Tavily API key, you can sign up for a free account on the Tavily website
• Claude Desktop or Cursor
• Node.js (v20 or higher)
  • You can verify your Node.js installation by running:
    • node --version
• Git installed (only needed if using Git installation method)
  • On macOS: brew install git
  • On Linux:
    • Debian/Ubuntu: sudo apt install git
    • RedHat/CentOS: sudo yum install git
  • On Windows: Download Git for Windows

Running with NPX

npx -y tavily-mcp@latest

Default Parameters Configuration

You can set default parameter values for the tavily-search tool using the DEFAULT_PARAMETERS environment variable. This allows you to configure default search behavior without specifying these parameters in every request.

Example Configuration

export DEFAULT_PARAMETERS='{"include_images": true}'

Example usage from Client

{
  "mcpServers": {
    "tavily-mcp": {
      "command": "npx",
      "args": ["-y", "tavily-mcp@latest"],
      "env": {
        "TAVILY_API_KEY": "your-api-key-here",
        "DEFAULT_PARAMETERS": "{\"include_images\": true, \"max_results\": 15, \"search_depth\": \"advanced\"}"
      }
    }
  }
}

Stripe Payment Integration

The Tavily MCP server includes Stripe payment integration for processing payments. This is useful if you want to integrate payment processing into your AI-powered applications.

Available Stripe Tools

• stripe_create_payment_intent - Create a payment intent for collecting payments
• stripe_get_payment_intent - Retrieve a payment intent by ID
• stripe_create_customer - Create a new Stripe customer
• stripe_get_customer - Retrieve a customer by ID
• stripe_list_charges - List recent charges
• stripe_create_checkout_session - Create a Stripe checkout session
• stripe_get_checkout_session - Retrieve a checkout session

Configuration

To enable Stripe functionality, set the STRIPE_SECRET_KEY environment variable with your Stripe secret key:

export STRIPE_SECRET_KEY="sk_test_your_stripe_secret_key"

Stripe Example Usage

{
  "mcpServers": {
    "tavily-mcp": {
      "command": "npx",
      "args": ["-y", "tavily-mcp@latest"],
      "env": {
        "TAVILY_API_KEY": "your-api-key-here",
        "STRIPE_SECRET_KEY": "sk_test_your_stripe_secret_key"
      }
    }
  }
}

Security Note: Never hardcode your Stripe secret key in source code or configuration files that are committed to version control. Always use environment variables.

Cloudflare MCP Servers

The Tavily MCP server also provides integration with Cloudflare's MCP servers for additional capabilities. These can be added as remote MCP servers to your client configuration.

Available Cloudflare MCP Servers

| Service | URL | Description | | ------- | --- | ----------- | | Observability | https://observability.mcp.cloudflare.com/mcp | Monitoring, logs, and metrics | | Radar | https://radar.mcp.cloudflare.com/mcp | Security analytics and threat data | | Browser | https://browser.mcp.cloudflare.com/mcp | Web browsing and page rendering |

Connecting to Cloudflare MCP Servers

Claude Desktop

Add Cloudflare MCP servers to your Claude Desktop configuration:

{
  "mcpServers": {
    "cloudflare-observability": {
      "command": "npx",
      "args": ["-y", "@cloudflare/mcp-server"],
      "env": {
        "CLOUDFLARE_API_TOKEN": "your-api-token"
      }
    },
    "cloudflare-radar": {
      "command": "npx",
      "args": ["-y", "@cloudflare/mcp-server"],
      "env": {
        "CLOUDFLARE_API_TOKEN": "your-api-token"
      }
    },
    "cloudflare-browser": {
      "command": "npx",
      "args": ["-y", "@cloudflare/mcp-server"],
      "env": {
        "CLOUDFLARE_API_TOKEN": "your-api-token"
      }
    }
  }
}

Or using the remote server approach:

{
  "mcpServers": {
    "cloudflare-observability": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://observability.mcp.cloudflare.com/mcp"],
      "env": {
        "CLOUDFLARE_API_TOKEN": "your-api-token"
      }
    },
    "cloudflare-radar": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://radar.mcp.cloudflare.com/mcp"],
      "env": {
        "CLOUDFLARE_API_TOKEN": "your-api-token"
      }
    },
    "cloudflare-browser": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://browser.mcp.cloudflare.com/mcp"],
      "env": {
        "CLOUDFLARE_API_TOKEN": "your-api-token"
      }
    }
  }
}

Cursor

Add Cloudflare MCP servers to your Cursor configuration (mcp.json):

{
  "mcpServers": {
    "cloudflare-observability": {
      "command": "npx",
      "args": ["-y", "@cloudflare/mcp-server"],
      "env": {
        "CLOUDFLARE_API_TOKEN": "your-api-token"
      }
    },
    "cloudflare-radar": {
      "command": "npx",
      "args": ["-y", "@cloudflare/mcp-server"],
      "env": {
        "CLOUDFLARE_API_TOKEN": "your-api-token"
      }
    },
    "cloudflare-browser": {
      "command": "npx",
      "args": ["-y", "@cloudflare/mcp-server"],
      "env": {
        "CLOUDFLARE_API_TOKEN": "your-api-token"
      }
    }
  }
}

Getting a Cloudflare API Token

1. Log in to the Cloudflare Dashboard
2. Go to Profile > API Tokens
3. Click "Create Token"
4. Choose a template or create a custom token
5. Ensure the token has appropriate permissions for the services you want to use

Note: Some Cloudflare MCP servers may require specific API token permissions. Refer to the Cloudflare MCP server documentation for details.

Eleven Labs MCP Server

The Tavily MCP server provides integration with Eleven Labs' MCP server for text-to-speech and voice synthesis capabilities.

Available Eleven Labs Tools

When you add the Eleven Labs MCP server to your client, you'll have access to:

• elevenlabs-text-to-speech - Convert text to speech with various voices
• elevenlabs-voices - List available voices for synthesis
• elevenlabs-models - List available TTS models
• elevenlabs-settings - Get or set user preferences

Connecting to Eleven Labs MCP Server

Claude Desktop (Eleven Labs)

Add the Eleven Labs MCP server to your Claude Desktop configuration:

{
  "mcpServers": {
    "elevenlabs": {
      "command": "npx",
      "args": ["-y", "@elevenlabs/mcp-server"],
      "env": {
        "ELEVENLABS_API_KEY": "your-api-key"
      }
    }
  }
}

Cursor (Eleven Labs)

Add the Eleven Labs MCP server to your Cursor configuration (mcp.json):

{
  "mcpServers": {
    "elevenlabs": {
      "command": "npx",
      "args": ["-y", "@elevenlabs/mcp-server"],
      "env": {
        "ELEVENLABS_API_KEY": "your-api-key"
      }
    }
  }
}

Getting an Eleven Labs API Key

1. Log in to the Eleven Labs Dashboard
2. Go to Settings > API Keys
3. Click "Create API Key"
4. Copy your API key and use it in your MCP client configuration

Note: The Eleven Labs MCP server requires an API key with appropriate permissions for text-to-speech operations.

Eleven Labs Resources

• Eleven Labs Documentation
• Eleven Labs MCP GitHub

GitHub MCP Server

The Tavily MCP server provides integration with GitHub's MCP server for code scanning, issues, pull requests, and repository management capabilities.

Available GitHub Tools

When you add the GitHub MCP server to your client, you'll have access to:

• github-code-scanning - Security vulnerability detection
• github-issues - Create, read, update, and search issues
• github-pull-requests - Create, read, update, and search PRs
• github-repositories - Manage repositories, branches, and commits
• github-search - Search code, issues, PRs, and repositories
• github-actions - Manage workflows and runs

Connecting to GitHub MCP Server

Claude Desktop (GitHub)

Add the GitHub MCP server to your Claude Desktop configuration:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@github/mcp-server"],
      "env": {
        "GITHUB_TOKEN": "your-github-token"
      }
    }
  }
}

Cursor (GitHub)

Add the GitHub MCP server to your Cursor configuration (mcp.json):

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@github/mcp-server"],
      "env": {
        "GITHUB_TOKEN": "your-github-token"
      }
    }
  }
}

Getting a GitHub Token

1. Log in to your GitHub account
2. Go to Settings > Developer settings > Personal access tokens
3. Click "Generate new token"
4. Select the scopes you need (repo, workflow, read:org, etc.)
5. Copy your token and use it in your MCP client configuration

Note: The GitHub MCP server requires a token with appropriate permissions for the operations you want to perform.

GitHub Resources

• GitHub MCP Server

AgentQL MCP Server

The Tavily MCP server provides integration with AgentQL's MCP server for AI-powered web scraping and data extraction capabilities.

Available AgentQL Tools

When you add the AgentQL MCP server to your client, you'll have access to:

• query_data - Extract structured data from any web page using AgentQL's GraphQL-like query language
• get_web_element - Locate and retrieve specific web elements from a page using natural language queries

Connecting to AgentQL MCP Server

Claude Desktop (AgentQL)

Add the AgentQL MCP server to your Claude Desktop configuration:

{
  "mcpServers": {
    "agentql": {
      "command": "npx",
      "args": ["-y", "agentql-mcp"],
      "env": {
        "AGENTQL_API_KEY": "your-api-key"
      }
    }
  }
}

Cursor (AgentQL)

Add the AgentQL MCP server to your Cursor configuration (mcp.json):

{
  "mcpServers": {
    "agentql": {
      "command": "npx",
      "args": ["-y", "agentql-mcp"],
      "env": {
        "AGENTQL_API_KEY": "your-api-key"
      }
    }
  }
}

Getting an AgentQL API Key

1. Visit https://agentql.com
2. Sign up for an account or log in
3. Navigate to your account settings or API keys section
4. Generate a new API key
5. Copy your API key and use it in your MCP client configuration

Note: The AgentQL MCP server requires an API key with appropriate permissions for web scraping operations.

AgentQL Resources

• AgentQL MCP GitHub

Alby Bitcoin Lightning MCP Server

The Tavily MCP server provides integration with Alby's MCP server for Bitcoin Lightning wallet operations using Nostr Wallet Connect (NWC).

Available Alby Tools

When you add the Alby MCP server to your client, you'll have access to:

NWC Wallet Tools:

• get_balance - Get the balance of the connected lightning wallet
• get_info - Get NWC capabilities and general information about the wallet and underlying lightning node
• get_wallet_service_info - Get NWC capabilities, supported encryption and notification types
• lookup_invoice - Look up lightning invoice details from a BOLT-11 invoice or payment hash
• make_invoice - Create a lightning invoice
• pay_invoice - Pay a lightning invoice
• list_transactions - List all transactions from the connected wallet with optional filtering

Lightning Tools:

• fetch_l402 - Fetch a paid resource protected by L402 (Lightning HTTP 402 Payment Required)
• fiat_to_sats - Convert fiat currency amounts (e.g. USD, EUR) to satoshis
• parse_invoice - Parse a BOLT-11 lightning invoice and return its details
• request_invoice - Request a lightning invoice from a lightning address (LNURL)

Connecting to Alby MCP Server

Option 1: Local (STDIO) — Claude Desktop

Add the Alby MCP server to your Claude Desktop configuration:

{
  "mcpServers": {
    "alby": {
      "command": "npx",
      "args": ["-y", "@getalby/mcp"],
      "env": {
        "NWC_CONNECTION_STRING": "nostr+walletconnect://..."
      }
    }
  }
}

Option 1 (Cursor): Local (STDIO)

Add the Alby MCP server to your Cursor configuration (mcp.json):

{
  "mcpServers": {
    "alby": {
      "command": "npx",
      "args": ["-y", "@getalby/mcp"],
      "env": {
        "NWC_CONNECTION_STRING": "nostr+walletconnect://..."
      }
    }
  }
}

Option 2: Remote Server

Connect directly to Alby's hosted MCP server (no local installation required):

• HTTP Streamable: https://mcp.getalby.com/mcp
• SSE: https://mcp.getalby.com/sse

Bearer Authentication (preferred):

Authorization: Bearer nostr+walletconnect://...

Query Parameter:

https://mcp.getalby.com/mcp?nwc=ENCODED_NWC_URL

Claude Code (Remote)

claude mcp add --transport http alby https://mcp.getalby.com/mcp --header "Authorization: Bearer nostr+walletconnect://..."

Getting a NWC Connection String

1. Visit nwc.getalby.com or use any NWC-compatible Bitcoin Lightning wallet
2. Create a new connection and copy the connection string
3. The connection string starts with nostr+walletconnect://
4. Set it as the NWC_CONNECTION_STRING environment variable

Security Note: Your NWC connection string grants access to your Bitcoin Lightning wallet. Never share it or commit it to version control. Always use environment variables.

Alby Resources

• Alby MCP GitHub — Alby MCP server repo and docs

• NWC (Nostr Wallet Connect) — protocol spec and tools

• NWC Connection Generator — create NWC connection strings

• Alby Support — help center and troubleshooting

• Alby Homepage — product overview and sign-up

• Alby MCP GitHub

• Nostr Wallet Connect (NWC)

• Alby Support

Netlify MCP Server

The Netlify MCP Server enables AI agents to create, manage, and deploy Netlify projects using natural language prompts.

• npm package: @netlify/mcp
• Auth: Netlify OAuth (default, interactive) or NETLIFY_PERSONAL_ACCESS_TOKEN (optional, non-interactive)
• Docs: Netlify MCP Server Documentation

Available Tools (16 tools across 5 domains)

Project Tools:

• get-project - Get a Netlify project/site by ID or name
• get-projects - List all Netlify projects/sites for the current team
• create-new-project - Create a new Netlify project/site
• update-project-name - Update the name of an existing Netlify project
• update-visitor-access-controls - Modify visitor access controls (password protection, JWT, etc.)
• update-project-forms - Enable or disable Netlify form submissions for a project
• get-forms-for-project - Get all forms associated with a Netlify project
• manage-form-submissions - Manage form submissions (list, delete, etc.)
• manage-project-env-vars - Create, update, or delete environment variables and secrets

Deploy Tools:

• get-deploy - Get a specific Netlify deploy by deploy ID
• get-deploy-for-site - Get all deploys for a specific Netlify site
• deploy-site - Build and deploy a site to Netlify
• deploy-site-remotely - Deploy a site to Netlify using remote build infrastructure

User / Team / Extension Tools:

• get-user - Get current authenticated Netlify user information
• get-team - Get Netlify team information and settings
• manage-extensions - Install or uninstall Netlify extensions for a project

Connecting to Netlify MCP Server

Claude Desktop (Netlify)

Add the Netlify MCP server to your Claude Desktop configuration (claude_desktop_config.json):

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

With optional Personal Access Token (for non-interactive / CI use):

{
  "mcpServers": {
    "netlify": {
      "command": "npx",
      "args": ["-y", "@netlify/mcp"],
      "env": {
        "NETLIFY_PERSONAL_ACCESS_TOKEN": "your-netlify-pat"
      }
    }
  }
}

Cursor (Netlify)

Add to your Cursor configuration (mcp.json):

{
  "mcpServers": {
    "netlify": {
      "command": "npx",
      "args": ["-y", "@netlify/mcp"],
      "env": {
        "NETLIFY_PERSONAL_ACCESS_TOKEN": "your-netlify-pat"
      }
    }
  }
}

Claude Code (Netlify CLI)

claude mcp add netlify -- npx -y @netlify/mcp

Getting a Netlify Personal Access Token

1. Log in to app.netlify.com
2. Go to User Settings → Applications → Personal access tokens
3. Click New access token, give it a name, and copy the token
4. Set it as the NETLIFY_PERSONAL_ACCESS_TOKEN environment variable

Note: A PAT is optional. By default, the Netlify MCP server uses OAuth (interactive browser login). The PAT is only needed for non-interactive or CI/CD environments.

Netlify Resources

• Netlify MCP GitHub
• Netlify MCP Documentation
• Netlify Personal Access Tokens

J.P. Morgan Account Balances API

Access real-time and historical account balances for J.P. Morgan accounts directly through the MCP server.

Available Tools

• jpmorgan_retrieve_balances — Retrieve balances for one or more J.P. Morgan accounts. Supports:
  • Date range query: start_date + end_date (format: yyyy-MM-dd, max 31 days apart)
  • Relative date query: relative_date_type = CURRENT_DAY or PRIOR_DAY
• jpmorgan_list_tools — List available J.P. Morgan API tools
• jpmorgan_get_server_info — Get API endpoints, auth details, and setup instructions

Authentication

Set the JPMORGAN_ACCESS_TOKEN environment variable with your J.P. Morgan OAuth Bearer token:

export JPMORGAN_ACCESS_TOKEN=your-oauth-access-token
export JPMORGAN_ENV=testing   # or 'production'

API Environments

| Environment | Auth | URL | | --- | --- | --- | | Client Testing | OAuth | https://openbankinguat.jpmorgan.com/accessapi | | Client Testing | MTLS | https://apigatewayqaf.jpmorgan.com/accessapi | | Production | OAuth | https://openbanking.jpmorgan.com/accessapi | | Production | MTLS | https://apigateway.jpmorgan.com/accessapi |

Example Usage

Query current day balance:

{
  "tool": "jpmorgan_retrieve_balances",
  "arguments": {
    "account_ids": ["00000000000000304266256"],
    "relative_date_type": "CURRENT_DAY",
    "environment": "testing"
  }
}

Query by date range:

{
  "tool": "jpmorgan_retrieve_balances",
  "arguments": {
    "account_ids": ["00000000000000304266256"],
    "start_date": "2024-01-01",
    "end_date": "2024-01-05",
    "environment": "testing"
  }
}

J.P. Morgan Resources

• J.P. Morgan Developer Portal
• Account Balances API Spec (OpenAPI 3.0, v1.0.5)

J.P. Morgan Embedded Payments API

Access J.P. Morgan's Embedded Finance platform to manage clients and accounts directly through the MCP server. Supports virtual transaction accounts and limited access payment accounts (Accounts v2 Beta).

Available Embedded Payments Tools

Client Tools:

• ef_list_clients — List all embedded finance clients (supports pagination via limit / page)
• ef_get_client — Get a specific client by client_id
• ef_create_client — Create a new embedded finance client (name, type, email, phone, address)

Account Tools (Accounts v2 Beta):

• ef_list_accounts — List all accounts for a specific client
• ef_get_account — Get a specific account by client_id + account_id

Meta Tools:

• ef_list_tools — List all available Embedded Payments tools
• ef_get_server_info — Get API endpoints, auth details, and setup instructions

Embedded Payments Authentication

Set the JPMORGAN_ACCESS_TOKEN environment variable with your J.P. Morgan OAuth Bearer token:

export JPMORGAN_ACCESS_TOKEN=your-oauth-access-token
export JPMORGAN_PAYMENTS_ENV=production   # or 'mock'

Embedded Payments Environments

| Environment | URL | | --- | --- | | Production | https://apigateway.jpmorgan.com/tsapi/v1/ef | | Mock / Testing | https://api-mock.payments.jpmorgan.com/tsapi/v1/ef |

Embedded Payments Example Usage

List all clients:

{
  "tool": "ef_list_clients",
  "arguments": {
    "limit": 20,
    "page": 1
  }
}

Create a new client:

{
  "tool": "ef_create_client",
  "arguments": {
    "name": "Acme Corp",
    "type": "BUSINESS",
    "email": "[email protected]",
    "address": {
      "line1": "123 Main St",
      "city": "New York",
      "state": "NY",
      "postalCode": "10001",
      "country": "US"
    }
  }
}

List accounts for a client:

{
  "tool": "ef_list_accounts",
  "arguments": {
    "client_id": "your-client-id",
    "limit": 20
  }
}

Configuration Example

{
  "mcpServers": {
    "tavily-mcp": {
      "command": "npx",
      "args": ["-y", "tavily-mcp@latest"],
      "env": {
        "TAVILY_API_KEY": "your-tavily-api-key",
        "JPMORGAN_ACCESS_TOKEN": "your-jpmorgan-oauth-token",
        "JPMORGAN_PAYMENTS_ENV": "production"
      }
    }
  }
}

J.P. Morgan Embedded Payments Resources

• J.P. Morgan Embedded Payments Developer Portal
• J.P. Morgan Developer Portal

Acknowledgments

• Model Context Protocol for the MCP specification
• Anthropic for Claude Desktop