How to Use the Marqeta MCP in Windsurf

Q: What is the best way to handle card transitions?

Use createcardtransition to toggle card states between active and suspended. Cascade automates this transition when testing lost card scenarios or fraud alerts in your sandbox environment.

Q: Is my cardholder KYC and PIN data safe when using this setup?

The MCP server isolates sensitive payloads like performkyc and updatepin within Vinkius's secure V8 sandbox. Your credentials never leak to the LLM, and temporary tokens are destroyed immediately after execution.

Issue real physical cards, simulate transaction hooks, and test funding rules directly inside Windsurf using Cascade.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect Marqeta MCP to Windsurf

Create your Vinkius account to connect Marqeta to Windsurf and route execution through our secure gateway. The platform manages server hosting, runtime updates, and security layers. Configuration requires no manual server provisioning.

GDPR Free for Subscribers

Setup Marqeta with Windsurf

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Fast-track card setups with Windsurf Cascade

The `create_card` tool initiates physical or virtual card issuance directly inside your workspace. Cascade chains this with `create_user` and `perform_kyc` in a single pass to build a complete cardholder profile without manual prompts. You tell the agent to provision a card, and it handles the sequence. It generates the user, runs identity verification, and outputs the final card token for your app.

Test transaction flows via the Windsurf MCP Server

The `simulate_authorization` tool triggers card transactions to test your funding logic. Cascade runs this alongside `simulate_clearing` and `simulate_reversal` to verify how your application processes payment states in real time. Instead of jump-starting external testing tools, you instruct the agent to run the entire transaction lifecycle. It checks the ledger, updates the card transition state, and logs the console output in one sweep.

Control spending rules on the fly

The `create_velocity_control` tool establishes transaction limits on card products to block fraud before it happens. Cascade reads your local config files, identifies the required spend limits, and sets up the rules using `create_auth_control` automatically. You don't have to write custom scripts to update card rules. The MCP server reads your schema, runs the tool, and validates the configuration immediately.

Setup guide

Set up Marqeta MCP in Windsurf

Prerequisites

Windsurf IDE installed (macOS, Windows, or Linux)
Active Vinkius subscription with a valid endpoint token

1

Open MCP configuration

Click the Cascade assistant icon in the sidebar, then click the hammer icon (🔨) at the top of the panel. Select "Configure" to open ~/.codeium/windsurf/mcp_config.json.
2

Add the Marqeta MCP

Paste the JSON snippet shown on the right into the mcpServers object. Replace [YOUR_TOKEN_HERE] with your endpoint token from cloud.vinkius.com.
3

Refresh MCPs

Go back to the hammer icon (🔨) in Cascade and click "Refresh". Windsurf will detect the new server. No full restart is needed — the connection is hot-reloaded.
4

Verify in Cascade

Start a new Cascade conversation and ask something like "Show my Marqeta payment history." If connected, Cascade will call the Marqeta tools directly. You will see a green dot next to the server name in the MCP panel.

mcp_config.json

{
  "mcpServers": {
    "marqeta-mcp": {
      "url": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
    }
  }
}

Get your connection token →

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Marqeta. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

Why Choose Vinkius

Vinkius connects your tools to AI with real-time monitoring and automatic cost savings — all from one dashboard.

Connect Marqeta now

Real-time monitoring

Live

visibility into every interaction

Connect your favorite tools to your AI and see exactly what's happening — every request, every response, in real time.

Built-in savings

60%

lower AI costs

Vinkius compresses data between your apps and your AI automatically. Lower bills every month — no configuration required.

Single dashboard

One

place for every integration

Every tool your AI connects to, managed from a single screen. One account, complete control.

Common questions about Marqeta MCP in Windsurf

Cascade chains the API calls autonomously. You ask it to set up a cardholder, and it executes `create_user`, `perform_kyc`, and `create_card` in a logical sequence. It handles the JSON payloads and passes tokens between steps without asking you for permission.

Yes, you can run realistic transaction tests. Use Cascade to trigger `simulate_authorization` followed by `simulate_clearing` to see how your backend reacts. The agent manages the state transitions and reports the ledger changes instantly in your IDE.

You tell Cascade what spend rules you want to enforce. It maps those requirements to `create_velocity_control` and `create_auth_control` parameters, executes the tools, and updates your card product rules directly.

Use `create_card_transition` to toggle card states between active and suspended. Cascade automates this transition when testing lost card scenarios or fraud alerts in your sandbox environment.

The MCP server isolates sensitive payloads like `perform_kyc` and `update_pin` within Vinkius's secure V8 sandbox. Your credentials never leak to the LLM, and temporary tokens are destroyed immediately after execution.

Use it with your favorite AI tools

Connect this server to Cursor, Claude, VS Code, and more.

OpenAI Agents SDK sdk-python

Google ADK sdk-python

Pydantic AI sdk-python

Vercel AI SDK sdk-typescript