Zuplo MCP. Manage every API key and deployment from chat.
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Just plug in your AI agents and start using Vinkius.
Zuplo connects your API gateway management to any AI client via MCP. This platform lets you manage your entire programmable API infrastructure—gateways, edge deployments, and consumer identities—using natural conversation.
You can list projects, check real-time latency metrics, provision new API keys, or audit configuration files without logging into a complex cloud console.
If you deal with microservices that need tight control over authentication and deployment cycles, this is what your agent needs.
What your AI agents can do
Create consumer
Creates a new API key consumer identity within your Zuplo account.
Create deployment
Initiates a new configuration deployment to the global edge network.
Delete consumer
Revokes and deletes an existing API key consumer identity.
The tool lists every project and gateway you have configured in your account.
You can create, list, or delete consumer identities and their associated API key credentials.
The system pushes new configuration changes to the global edge network immediately.
You retrieve real-time metrics, including traffic volume, latency figures, and error rates for any gateway.
The agent lists all defined environments (e.g., 'production', 'staging') and confirms their operational health.
You can list the exact declarative config files that dictate your gateway's routing rules and policies.
Ask AI about this MCP
Supported MCP Clients
Gemini Waiting for input…
Zuplo MCP Server: 10 Tools for API Management
These tools let your AI client manage the full lifecycle of your programmable API gateways, from creating consumers to monitoring latency.
019d762ccreate consumer
Creates a new API key consumer identity within your Zuplo account.
019d762ccreate deployment
Initiates a new configuration deployment to the global edge network.
019d762cdelete consumer
Revokes and deletes an existing API key consumer identity.
019d762cget metrics
Retrieves real-time performance data, such as latency and traffic volume, for a specified gateway.
019d762clist consumers
Lists all active API key consumer identities associated with your projects.
019d762clist custom domains
Retrieves and lists the custom DNS domains configured for your Zuplo projects.
019d762clist deployments
Shows a history of past deployment attempts and their current status.
019d762clist environments
Lists all defined project environments (e.g., 'working', 'production') for audit purposes.
019d762clist files
Retrieves and lists the specific configuration files that define your gateway's policies and routing.
019d762clist projects
Lists all Zuplo projects configured in your account, providing a high-level view of your API assets.
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 Zuplo, 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
You connect your Zuplo account to any AI client using this MCP Server. Your agent lets you manage every part of your programmable API setup—the gateways, the edge deployments, and who gets access—just by talking to it. You don't gotta log into some massive cloud console; your agent handles all the heavy lifting.
Project Oversight & Audit:
You can start by getting a full picture of what you're running. Your agent lists every Zuplo project configured in your account, giving you an immediate high-level view of your API assets and overall setup. You can check out all defined environments—like 'working,' 'staging,' or 'production'—to verify their operational status at a glance.
To see exactly what defines your system's rules, you can list the specific configuration files that dictate your gateway’s routing logic and policies. You also get access to retrieve and list any custom DNS domains attached to your Zuplo projects.
API Access Control:
Need to manage who uses your API? Your agent handles all consumer identities. It lists every active API key consumer identity associated with your projects, letting you know exactly who has credentials. If you need a new user, it creates a brand-new API key consumer identity in your Zuplo account.
When someone leaves or changes roles, your agent revokes and deletes the existing consumer identity.
Deployment & Performance:
Want to push updates? You can initiate a new configuration deployment directly to the global edge network; this pushes those new rules out immediately. Before you do that, you can check the history of past attempts by listing all deployments and seeing their current status. For real-time health checks, your agent retrieves live performance data for any specified gateway.
This includes critical metrics like latency figures, total traffic volume, and error rates.
Deep Configuration Management:
If you need to dig into the guts of your setup, your agent provides those options. You can list all Zuplo projects configured in your account to audit every service endpoint. Your agent shows a history of past deployment attempts through list_deployments, confirming if changes stuck or failed.
The system tracks and lists all defined project environments using list_environments. To manage access, you've got the ability to create new consumer identities via create_consumer and delete them with delete_consumer. You can also list current consumers using list_consumers, getting a clear picture of your API key usage. Finally, if you need to confirm which domains are attached, it lists all custom DNS domains for your projects through list_custom_domains.
It's simple: Your AI client sends the command, and this server executes the action directly against your Zuplo platform.
How Zuplo MCP Works
- 1 Subscribe to this server on Vinkius and provide your Zuplo API Key.
- 2 Ask your AI agent to perform a task (e.g., 'Check the latency for proj-101').
- 3 The agent executes the necessary tool calls against your Zuplo account and returns the status or data.
The bottom line is, you manage complex API infrastructure by simply talking to your AI client instead of navigating cloud dashboards.
Who Is Zuplo MCP For?
Platform engineers who are sick of clicking through five different consoles just to check a single latency metric. DevOps teams that need to audit consumer keys and deployment history without writing complex shell scripts. This is for anyone who needs full visibility into their API lifecycle, fast.
Checks edge metrics using get_metrics or verifies environment health by running list_environments. They use this to keep the core system stable.
Triggers deployments via create_deployment and audits config files using list_files, bypassing manual CLI steps.
Manages consumer access by calling delete_consumer or auditing domains with list_custom_domains. They own the lifecycle safety checks.
What Changes When You Connect
- Real-time visibility. Stop guessing about performance. Use
get_metricsto pull live latency (p95) and throughput data directly, telling you if an endpoint is slowing down right now. - Instant governance. Forget logging into the console just to see who has access. Running
list_consumersgives you a clear list of every API key consumer identity, so you can audit permissions rapidly. - Zero-friction deployment. Need to push a config change? Calling
create_deploymenttriggers the update immediately. You don't write a CI/CD script; you just talk to your agent. - Full lifecycle control. The combination of
list_projects,list_environments, andlist_custom_domainslets you audit your entire API footprint, from the top-level project down to specific domain setups. - Auditability on demand. When something breaks, use
list_filesto pull the exact declarative configuration that failed. This saves hours of digging through logs just to find a bad routing rule.
Real-World Use Cases
The quick security audit
A security architect needs to know who has access to the payment gateway's API keys. Instead of clicking into three different sections, they simply prompt their agent: 'List all consumers for Payment-Gateway-Main.' The agent runs list_consumers and provides an immediate list, allowing them to flag or revoke specific accounts using delete_consumer.
The hotfix deployment
A developer finds a critical bug in the production environment. They don't have time for a full CI/CD build. They prompt: 'Deploy config version 4.2 to Production.' The agent executes create_deployment, pushing the fix to the edge network and minimizing downtime.
Checking system health
The ops team lead gets an alert about high latency. They tell their agent: 'Check the p95 metrics for User-Auth-Edge.' The agent runs get_metrics and reports, 'Average p95 is 42ms; error rate is stable at 0.05%,' confirming that the issue was transient and not resource-related.
Onboarding a new partner
A business unit needs to give a new external vendor access to a specific API project. They prompt: 'Create an API key consumer for Acme Corp.' The agent runs create_consumer, provisions the identity, and provides the necessary details without needing manual console steps.
The Tradeoffs
Assuming state integrity
A user tries to update a consumer key by just running 'Update Acme Corp'. Since there's no dedicated 'update' tool, the request fails, and they waste time trying different vague commands.
→
To modify a resource, you must validate the current state first. Use list_consumers to get the ID, then use delete_consumer, and finally call create_consumer with the updated parameters. This ensures you manage the full lifecycle.
Ignoring environment context
A developer accidentally runs a production-breaking deployment script against the working environment because they didn't verify which project was active.
→
Always check the boundaries first. Use list_environments to confirm the target environment (e.g., 'working') and then use that confirmed context when calling create_deployment. Don't skip the verification step.
Using metrics for diagnosis only
A user runs get_metrics because they see high latency, but stops there. They assume the problem is network-related and don't check the configuration.
→
After getting metrics, you must validate the source code logic. Use list_files to review the specific routing rules or policy definitions that might be causing unexpected slowdowns.
When It Fits, When It Doesn't
Use this server if your API management requires granular control over consumer identities and deployment state. If your current process involves manually checking key permissions across multiple dashboards, you need this. The strength is in the read capabilities: list_consumers, get_metrics, and list_files give unparalleled visibility into what's running.
However, don't use it if all you need is basic monitoring without needing to manage credentials or deployments. For simple metrics tracking on a single service, an endpoint-specific dashboard might suffice. If your workflow requires atomic 'patching' (i.e., updating only one field of a resource without deleting and recreating the whole thing), be aware this toolset forces the delete-then-create pattern for modification—a process that carries risk and should always be wrapped in error handling.
It’s built for engineers who need to manage the entire lifecycle, from initial project setup (list_projects) through real-time performance validation (get_metrics).
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Zuplo. 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 10 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.
Available Capabilities
Auditing API access credentials shouldn't require logging into five different consoles.
Today, checking who can access a specific endpoint means hopping between the Billing dashboard to check consumer keys, then switching to the Gateway console to verify which project they belong to. You manually copy IDs and cross-reference dates just to build a simple access report for an audit.
With Zuplo MCP, you tell your agent: 'List all consumers for Project X.' The system runs `list_consumers` instantly, giving you a clean list of identities and their status without any context switching. You get the data directly in your chat window.
Zuplo MCP Server gives you total control over deployments.
Manually updating an API gateway often means creating a branch, pushing code, triggering a build, and then manually selecting the 'Deploy' option for the correct environment. This is slow, error-prone, and requires remembering which button to click last.
Now, you just tell your agent: 'Create deployment of latest config.' The system handles the entire sequence—validation, pushing to edge nodes, and reporting success—all from a single chat command.
Common Questions About Zuplo MCP
How do I check if my API gateway is performing well using get_metrics? +
To check performance, prompt your agent with the specific project ID: 'Get edge metrics for proj-101.' The tool runs get_metrics and reports key figures like average p95 latency and total request volume over a specified period.
What is the difference between list_consumers and list_projects? +
list_projects shows every top-level API asset you own in Zuplo. list_consumers only lists the specific user identities (API keys) that have been granted access within one of those projects.
Can I update a consumer key using delete_consumer and create_consumer? +
Yes, this is the standard pattern. You must run list_consumers to get the old ID, then use delete_consumer first, followed immediately by create_consumer with all the updated parameters.
Do I need list_custom_domains before deploying an API? +
If your project relies on a specific custom URL (e.g., api.clientname.com), you should run list_custom_domains first to verify the domain is configured and ready for traffic routing.
What if I need to see which files define my gateway policy? +
Use the list_files tool. This shows you the specific declarative configuration files—the actual logic—that control how your API routes requests and enforces policies.
If a deployment fails, how do I track its history using list_deployments? +
The list_deployments tool gives you the full audit trail. It provides status (success or failure), timestamps, and the associated configuration ID for every attempt, letting you pinpoint exactly where things broke.
What specific permissions or scopes can I check for a consumer using list_consumers? +
The list_consumers function provides more than just IDs. It details the associated API key's scope, including rate limits and allowed endpoints, which is crucial for auditing access control.
How does list_environments show me if a project environment is actually running? +
When you run list_environments, it reports the current operational status (e.g., 'Active,' 'Degraded,' or 'Maintenance'). This lets you verify real-time health, not just confirm that an environment exists.
Can I check my API gateway metrics through the agent? +
Yes. The get_metrics tool allows your AI agent to retrieve real-time traffic and latency data for any specific project ID, helping you monitor gateway performance directly through chat.
How do I create a new consumer identity for API key authentication? +
You can use the create_consumer tool. Provide the project ID and a JSON payload with the consumer's details, and Zuplo will provision the new identity for your API gateway instantly.
Is it possible to see my project's configuration files via conversation? +
Absolutely. Use the list_project_files tool to retrieve the declarative configuration files for your API project, allowing you to audit routing and policy definitions through your agent.
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.
More in this category
PlanetScale
Provision, branch, and manage serverless MySQL databases dynamically via AI.
LinearB
Export software delivery metrics, manage deployments, and report incidents via the LinearB API.
Buildkite
Automate CI/CD pipelines via Buildkite — manage builds, agents, and deployments directly from any AI agent.
You might also like
Typeform
Conversational form management — fetch submissions, inspect form layouts, and automate Typeform operations elegantly.
Monzo Banking
Universal Monzo intelligence — check balances, accounts, and transactions via AI.
Typesense Vector Search
Automate vector similarity searches via Typesense — index documents, manage collections, and execute semantic queries directly from your AI agent.