Stark Bank MCP. Automate Payments, Cards, and Transfers in Brazil.
Gemini Works with every AI agent you already use
…and any MCP-compatible client
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.
Sends corporate transfers (TED/Pix) to designated recipients or suppliers using structured payment codes.
Creates new virtual Corporate Cards or generates payable invoices (Boletos) for specific customer accounts.
Retrieves the current, real-time monetary balance and detailed financial statements from your Stark account.
Pulls structured lists showing payment tracking for outgoing transfers or issued Pix charges.
Ask AI about this MCP
Supported MCP Clients
OAuth 2.0 Compatible Gemini Waiting for input…
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.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using Stark Bank on Vinkius019d760dstark create boleto
Generates a batch of official bank Boletos for invoicing purposes.
019d760dstark create corporate card
Creates a new virtual Corporate Credit Card instantly using enterprise technology.
019d760dstark create pix charge
Builds an immediate, dynamic Pix charge request from the Stark Bank system.
019d760dstark create transfer
Initiates payment transfers (TED or Pix) to suppliers or employees.
019d760dstark get balance
Checks the current total monetary balance available in your bank account.
019d760dstark get statement
Pulls a detailed, raw JSON statement of all cash flow activity.
019d760dstark list boletos
Lists the accounting progression and current status of generated Boletos.
019d760dstark list pix charges
Retrieves a history log of all created Pix charges.
019d760dstark 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
Make Your AI Do More
Start with Stark Bank, then connect any of our 4,900+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 4,900+ 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
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
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.
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.
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.
019d760d-5da8-7145-bc56-3e2691c45b4f 
How Stark Bank MCP Works
- 1 First, you use your Stark Bank Dashboard to retrieve a
Project ID. - 2 Next, generate an
ECDSA Private/Public Keypair in the bank's API settings and paste the raw private key into your MCP credentials. - 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.
Triggers high-volume payroll transfers across large arrays of workers instantly from a single chat prompt.
Generates and manages payments, like Boletos or corporate cards, by feeding specific customer details into the AI agent.
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_boletoandstark_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_chargesandstark_list_transfers. Your agent knows exactly where those payments landed.
Real-World Use Cases
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.
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.
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.
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.
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.
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.