4,500+ servers built on MCP Fusion
Vinkius

Stark Bank MCP. Automate Payments, Cards, and Transfers in Brazil.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

Stark Bank MCP on Cursor AI Code Editor MCP Client Stark Bank MCP on Claude Desktop App MCP Integration Stark Bank MCP on OpenAI Agents SDK MCP Compatible Stark Bank MCP on Visual Studio Code MCP Extension Client Stark Bank MCP on GitHub Copilot AI Agent MCP Integration Stark Bank MCP on Google Gemini AI MCP Integration Stark Bank MCP on Lovable AI Development MCP Client Stark Bank MCP on Mistral AI Agents MCP Compatible Stark Bank MCP on Amazon AWS Bedrock MCP Support

Just plug in your AI agents and start using Vinkius.

Stark Bank MCP Server connects your AI agent to Brazil's enterprise financial systems. It automates corporate payments—sending Pix transfers, generating virtual cards, and creating Boletos—directly inside chats.

Check balances, pull full statements, and manage high-volume payables without needing manual API calls or filesystem access.

What your AI agents can do

Stark create boleto

Generates a batch of official bank Boletos for invoicing purposes.

Stark create corporate card

Creates a new virtual Corporate Credit Card instantly using enterprise technology.

Stark create pix charge

Builds an immediate, dynamic Pix charge request from the Stark Bank system.

+ 6 more capabilities included
Initiate Payments

Sends corporate transfers (TED/Pix) to designated recipients or suppliers using structured payment codes.

Issue Financial Assets

Creates new virtual Corporate Cards or generates payable invoices (Boletos) for specific customer accounts.

Check Account Status

Retrieves the current, real-time monetary balance and detailed financial statements from your Stark account.

List Payment History

Pulls structured lists showing payment tracking for outgoing transfers or issued Pix charges.

Supported MCP Clients

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients
Free for Subscribers

Waiting for input…

AI Agent

Stark Bank MCP Server: 9 Tools for Finance Automation

Use these tools to programmatically manage payments, generate financial assets like Boletos, retrieve account balances, and audit transaction histories via your AI agent.

stark019d760d

stark create boleto

Generates a batch of official bank Boletos for invoicing purposes.

stark019d760d

stark create corporate card

Creates a new virtual Corporate Credit Card instantly using enterprise technology.

stark019d760d

stark create pix charge

Builds an immediate, dynamic Pix charge request from the Stark Bank system.

stark019d760d

stark create transfer

Initiates payment transfers (TED or Pix) to suppliers or employees.

stark019d760d

stark get balance

Checks the current total monetary balance available in your bank account.

stark019d760d

stark get statement

Pulls a detailed, raw JSON statement of all cash flow activity.

stark019d760d

stark list boletos

Lists the accounting progression and current status of generated Boletos.

stark019d760d

stark list pix charges

Retrieves a history log of all created Pix charges.

stark019d760d

stark list transfers

Discovers the tracking status of completed outgoing payment transfers.

Choose How to Get Started

Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.

Build Your Own

Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.

  • Import from OpenAPI, Swagger, or YAML specs
  • Create Agent Skills with progressive disclosure
  • Deploy to edge with MCPFusion framework
  • Built in DLP, auth, and compliance on every call
  • Real time usage dashboard and cost metering
  • Publish to catalog or keep private
Start building

Make Your AI Do More

Start with Stark Bank, then connect any of our 4,700+ other servers whenever your AI needs more. One click, no limits.

  • Use this MCP plus 4,700+ others, all in one place
  • Add new capabilities to your AI anytime you want
  • Every connection is secured and compliant automatically
  • Track usage and costs across all your servers
  • Works with Claude, ChatGPT, Cursor, and more
  • New servers added to the catalog every week

What you can do with this MCP connector

Listen up. The Stark Bank MCP Server puts Brazil's whole enterprise financial stack right into your agent's context. You don't gotta mess with manual API calls or file systems to run corporate payments anymore. It handles complex money moves—sending payroll, generating invoices, pulling statements—all directly inside the chat window.

When you connect this server, your AI client gets nine specific tools that let you manage high-volume payables and assets like a pro. You can check real-time account status with stark_get_balance, which gives you the current total monetary balance available in your Stark bank account. If you need a deep dive into cash flow history, run stark_get_statement to pull a detailed, raw JSON statement of all activity.

To pay people or suppliers, you initiate transfers with stark_create_transfer. This handles both TED and Pix payments using structured payment codes. If you need to track where those funds went after they left your account, use stark_list_transfers to discover the tracking status of all outgoing payment moves.

Need to charge a customer or pay an employee? You can build an immediate, dynamic Pix charge request right away using stark_create_pix_charge. To keep tabs on those charges, run stark_list_pix_charges for a history log. For invoicing purposes, you'll want to use stark_create_boleto, which generates a batch of official bank Boletos.

You can then check the accounting progress and current status of those generated invoices with stark_list_boletos.

On the asset side, you got two key tools. If you need to issue payable invoices for specific accounts, generating a Boleto is your move. But if you gotta create new corporate spending power, use stark_create_corporate_card to instantly generate a virtual Corporate Credit Card using enterprise tech.

To track all the money moving through your system, remember that stark_list_transfers tracks payments sent out, while stark_list_pix_charges tracks charges built. Basically, you're managing every step: from checking your balance with stark_get_balance, pulling full history with stark_get_statement, running the transfer via stark_create_transfer, and finally verifying everything with these list tools.

How Stark Bank MCP Works

  1. 1 First, you use your Stark Bank Dashboard to retrieve a Project ID.
  2. 2 Next, generate an ECDSA Private/Public Key pair in the bank's API settings and paste the raw private key into your MCP credentials.
  3. 3 Finally, your AI client invokes a tool (e.g., stark_create_transfer), which uses the secured credential to execute the payment or query.

The bottom line is: Your AI agent connects via secure cryptographic keys and executes complex banking functions without needing direct UI interaction.

Who Is Stark Bank MCP For?

This tool targets finance operations teams, CFOs, and infra ops engineers. You need this if your payment workflows are too manual or require high-volume, programmatic execution that can't survive the typical 'click through dashboard' process. It’s for people who spend their day moving money and auditing ledgers.

CFO

Triggers high-volume payroll transfers across large arrays of workers instantly from a single chat prompt.

Financial Operations Analyst

Generates and manages payments, like Boletos or corporate cards, by feeding specific customer details into the AI agent.

Infrastructure Ops Engineer

Rotates corporate card limits instantly when a spending threshold is hit, requiring no manual dashboard intervention.

What Changes When You Connect

  • Execute high-volume payroll transfers with stark_create_transfer. Instead of batch file uploads or manual console runs, your agent just needs to know the recipients, and it handles the execution.
  • Generate virtual cards instantly using stark_create_corporate_card. You can tell your AI client: 'Make a card for Cloud Services,' and it outputs the required asset immediately.
  • Audit finances faster with stark_get_statement. Pulling a detailed, raw JSON statement eliminates spending time on multiple banking portals. Everything is in one structured dump.
  • Manage payment invoicing using stark_create_boleto and stark_list_boletos. You can programmatically issue an invoice, then check its status later without logging into the web portal.
  • Gain visibility into every transaction with history tools like stark_list_pix_charges and stark_list_transfers. Your agent knows exactly where those payments landed.

Real-World Use Cases

01

Running Monthly Payroll

The CFO needs to pay 300 employees. Instead of pulling a massive CSV and running it through the banking portal, they simply prompt their agent: 'Send payroll for all workers using stark_create_transfer.' The agent parses the worker list and executes hundreds of payments in one flow.

02

Vendor Onboarding

A new vendor needs to be paid. Instead of emailing a finance team and waiting for an invoice, the Ops Analyst asks the agent: 'Create a payable Boleto for Vendor X.' The agent runs stark_create_boleto, and the necessary payment asset is generated immediately.

03

Immediate Hardware Upgrade

The team needs to buy new server racks and the card limit is low. Instead of finding a human who can manually rotate the card, the agent runs stark_create_corporate_card with elevated limits, allowing immediate purchases.

04

Daily Reconciliation

The finance team needs to know if yesterday's payments cleared. They prompt: 'Check all outgoing transfers and Pix charges.' The agent uses stark_list_transfers and stark_list_pix_charges together, giving a unified status report.

The Tradeoffs

Manual API Chaining

Trying to combine multiple separate calls (e.g., calling stark_get_balance, then manually passing that number into a prompt to determine a payment amount, and finally running stark_create_transfer). This requires too much context switching.

Chain the tools directly in your agent's workflow. Run stark_get_balance first. Then, pass its output result directly as an argument into the stark_create_transfer tool call to ensure the amount is current and accurate.

Assuming Payment Status

Running stark_create_transfer and then assuming the payment went through instantly. You have no visibility into its final state.

Always follow up a transfer with a status check using stark_list_transfers. This verifies if the outgoing payments were successfully queued or completed.

Ignoring Ledger Details

Just looking at the high-level balance without knowing where the money went. You can't reconcile anything.

Always pull a full statement using stark_get_statement immediately after making major payments or receiving funds. This gives you the granular, historical ledger detail.

When It Fits, When It Doesn't

Use this server if your financial process relies on high-volume, programmatic actions: issuing hundreds of payables, managing multiple card limits, or generating structured invoices (Boletos). It’s perfect for automation where speed and adherence to Brazilian banking standards are non-negotiable.

Don't use it if you just need simple data retrieval that doesn't involve a transaction. For example, if you only need to read a single field from an external database unrelated to Stark Bank, stick to simpler document/database connectors. If your workflow is purely conceptual and never requires money movement or asset generation, this tool is overkill because it demands the complexity of ECDSA key management.

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Stark Bank. 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.

VINKIUS INFRASTRUCTURE

Cloud Hosted

Managed infra

V8 Isolated

Sandboxed per request

Zero-Trust Proxy

No stored credentials

DLP Enforced

Policy on every call

GDPR Compliant

EU data residency

Token Compression

~60% cost reduction

How we secure it →

Works with Claude, ChatGPT, Cursor, and more

The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.

This server provides 9 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.

Available Capabilities

stark_create_boleto stark_create_corporate_card stark_create_pix_charge stark_create_transfer stark_get_balance stark_get_statement stark_list_boletos stark_list_pix_charges stark_list_transfers

Manual payments require jumping between five different dashboards.

Today, executing a simple payroll run means logging into your corporate card portal to check limits, then switching tabs to the payment gateway to enter recipient details, and finally opening the accounting system just to generate an invoice. You end up copying amounts between three different screens, which is slow and ripe for copy-paste errors.

With the Stark Bank MCP Server, you describe the entire transaction in plain language—'Pay salaries for all employees using Pix.' Your agent handles the balance check (`stark_get_balance`), runs `stark_create_transfer`, and logs the outcome. You get a single, confirmed result.

Stark Bank MCP Server: Manage Corporate Payments from Chat

The manual process for generating an invoice (Boleto) involves contacting finance to get the correct structure and expiration date, then manually uploading customer data. This cycle takes hours of back-and-forth communication.

Now, your agent runs `stark_create_boleto` with a target CPF and expiration date. It handles the entire payload creation instantly. The payment asset exists in the system—no emails needed.

Common Questions About Stark Bank MCP

How do I securely pass the Stark Bank ECDSA Private Key to MCP? +

Inside Stark Bank, when you generate your API project, the website will generate a Public/Private Keypair or ask you to provide one. You must grab the Private Key (often starting with -----BEGIN EC PRIVATE KEY-----) and paste that entire raw multiline text into the STARK_PRIVATE_KEY input inside the MCP client perfectly as it is.

Can the bot process Corporate Card requests automatically? +

Yes! If you instruct the agent to orchestrate the generation using the tool stark_create_corporate_card, the API instantly spins up a valid, active Corporate Virtual Card attached to your Master Balance in real-time.

How does the Stark Bank transfer function differ from basic gateway Pix? +

Stark Transfer allows hyper granular outbounds. Instead of just pushing a basic Pix key, the stark_create_transfer can route massive payrolls, TED systems tracking BankCode, ISPB nodes and branch validation—giving you raw underlying banking protocol access.

Will Stark API throttle the connection if the Agent lists too many historic Boletos? +

StarkBank allows huge enterprise-grade API ceilings per second. Pulling hundreds of statements using stark_list_boletos naturally respects rate limits easily while functioning inside LLM chat turns.

How do I specify the date range when using `stark_get_statement`? +

You must pass a start and end timestamp for accurate data retrieval. The function accepts structured parameters defining the cash flow window you want to analyze. This gives you a detailed, raw JSON export of all movements—deposits, withdrawals, transfers—within that exact period.

If `stark_create_transfer` fails, how do I identify the failure reason? +

The MCP returns specific error codes and messages detailing the failure. Most common issues include insufficient funds or invalid recipient identifiers (e.g., wrong bank code). Always check the returned payload for an 'error' key before assuming a payment failed entirely.

Does `stark_create_boleto` support batch processing for multiple recipients? +

Yes, it is designed to handle arrays of data. You provide the full list of required payees and amounts in a single payload. This lets your agent automate mass payroll or billing cycles efficiently.

What is the primary use case for `stark_create_pix_charge`? +

This tool generates dynamic, immediate payment charges rather than initiating a direct transfer. You use it when you need to bill a customer or create an outstanding invoice link that must be paid later.

More in this category

You might also like

Built & Managed by Vinkius 30s setup 9 tools

We've already built the connector for Stark Bank. Just plug in your AI agents and start using Vinkius.

No hosting. No infrastructure. No complex setup.
All 9 tools are live and waiting. You're up and running in seconds.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients

Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.

Zero hosting required Full MCP catalog included Enterprise-grade security Auto-updated by Vinkius

Built, hosted, and secured by Vinkius. You just connect and go.