Platform API MCP Configuration
The Platform API MCP configuration provides a hosted JSON schema that connects AI assistants — including Claude Desktop, Cursor, Windsurf, and VS Code Copilot — to the Platform API API via the Model Context Protocol. This configuration maps 10 API endpoints as callable tools, including Enumerate all active channels of the application, Get metadata of a channel, Get message history for a channel, and more. No authentication credentials are needed — it works out of the box. The configuration is auto-generated from the Platform API OpenAPI specification (v1.1.0) and has a quality score of 34/99 (fair documentation coverage). Use the hosted URL below to auto-load this schema into any compatible MCP client.
Quick Specs Reference
Hosted Config URL
Use this hosted URL in any client that supports remote MCP schema auto-loading.
https://mcpbridge.org/config/ably-io-platform.jsonOne-Click Client Setup
Copy the configurations below to wire your local coding assistant directly.
Claude Desktop
claude_desktop_config.json{
"mcpServers": {
"ably-io-platform": {
"command": "npx",
"args": [
"-y",
"@mcp/ably-io-platform"
],
"env": {
"PLATFORM_API_API_KEY": "your_platform_api_api_key"
}
}
}
}Cursor & VS Code
MCP Server URL Setup{
"mcpServers": {
"ably-io-platform": {
"url": "https://mcpbridge.org/config/ably-io-platform.json"
}
}
}Raw Configuration JSON
For local command line wrappers or dynamic shell bindings.
{
"mcpServers": {
"ably-io-platform": {
"command": "npx",
"args": ["-y","@mcp/ably-io-platform"],
"env": {
"PLATFORM_API_API_KEY": "your_platform_api_api_key"
}
}
}
}Required Environment Keys
Substitute these secrets inside your configuration directory environment definitions.
PLATFORM_API_API_KEYyour_platform_api_api_key with your secret key credentialMapped Web APIs & Tools
The following routes will be exposed directly as protocol tools for the LLM.
/channelsEnumerate all active channels of the application
/channels/{channel_id}Get metadata of a channel
/channels/{channel_id}/messagesGet message history for a channel
/channels/{channel_id}/messagesPublish a message to a channel
/channels/{channel_id}/presenceGet presence of a channel
/channels/{channel_id}/presence/historyGet presence history of a channel
/keys/{keyName}/requestTokenRequest an access token
/push/channelSubscriptionsList channel subscriptions
/push/channelSubscriptionsSubscribe a device to a channel
/push/channelSubscriptionsDelete a registered device's update token
Similar Configurations
Notion API
Create and manage Notion pages, databases, and blocks through your AI agent.
https://mcpbridge.org/config/notion.jsonLinear API
Manage issues, projects, and workflows in Linear through your AI agent.
https://mcpbridge.org/config/linear.jsonControl API v1
The Control API v1, provided by Ably, is a comprehensive programmatic interface designed for the administrative management and automation of Ably’s real-time messaging infrastructure. It serves as the central nervous system for controlling core resources within an Ably account, enabling developers and platform engineers to dynamically provision and configure applications, manage authentication credentials (keys), organize message flow with namespaces, and establish operational rules. Its primary function is to transition infrastructure management from manual, dashboard-driven tasks to scalable, code-first operations. This makes it indispensable for enterprise use cases such as automated environment provisioning for development and testing, multi-tenant SaaS platforms requiring isolated customer channels, and large-scale IoT deployments where device groups (represented by namespaces) or security credentials (keys) must be managed programmatically in response to dynamic demand. The API currently operates in a Beta state, indicating it is feature-rich but subject to refinement based on developer feedback. When integrated as tools for an AI coding assistant via the Model Context Protocol (MCP), the Control API unlocks a powerful paradigm of infrastructure-as-conversation, dramatically accelerating development workflows and reducing context-switching. An AI agent, armed with these tools, becomes a co-pilot capable of directly querying and modifying your Ably topology based on natural language instructions. This transforms abstract architectural decisions into immediate, executable actions. For instance, a developer can instruct the AI to "list all applications in our account and generate a new API key scoped to the 'production' namespace for the payments service," bypassing manual dashboard navigation and potential configuration errors. The value lies in the AI's ability to understand context, chain operations (e.g., "find the app ID for 'user-service', then list its keys, and finally create a new key with read-only permissions"), and act as a contextual expert, thereby compressing development cycles and enhancing operational accuracy. Practical workflows enabled by this MCP server are numerous and directly impactful. An AI agent can perform dynamic resource auditing by querying all keys and their permissions to generate a security report, stating, "AI agent can query all keys to audit privilege distribution across namespaces." It can automate environment cleanup by instructing, "AI agent can delete all test namespaces older than 30 days to reduce clutter and costs." In a CI/CD pipeline context, a developer could prompt, "AI agent can create a temporary, restricted key for a staging environment and then revoke it after tests complete," ensuring ephemeral credentials and enforcing security hygiene. For multi-tenant management, the AI can handle customer onboarding by executing, "AI agent can create a new namespace for a new tenant, generate a scoped key, and provide the configuration details back to the provisioning system." Critical to the deployment of this API is the absence of a built-in authentication method, which mandates that developers implement and enforce robust security controls externally. Authentication and authorization must be rigorously applied, ideally using Ably API keys with the smallest possible set of privileges required for the specific task, adhering strictly to the principle of least privilege. For an MCP server integration, this means the server should be configured with a high-privilege key only in a secure, isolated backend environment, while exposing a minimal set of safe, well-vetted tools to the AI. Additional security best practices include using short-lived tokens where possible, enforcing IP allowlists on API keys, and meticulously logging all API actions for audit trails. Developers must treat the Control API as a powerful and sensitive management plane, where a misconfigured tool or overly broad permission could lead to significant operational or security incidents.
https://mcpbridge.org/config/ably-net-control.jsonAdyen Test Cards API
The Adyen Test Cards API, provided by the global payment platform Adyen, is a specialized utility designed to streamline the payment integration development and testing lifecycle. Its core capability is the programmatic generation of custom test card numbers, a critical requirement for developers and QA engineers building and validating payment flows in sandbox or test environments. By exposing a dedicated endpoint, `POST /createTestCardRanges`, the API eliminates the manual process of sourcing static test card numbers from documentation or community lists. This is particularly valuable for enterprise-scale applications where testing must cover a complex matrix of scenarios, including various card schemes (Visa, Mastercard, etc.), card types (credit, debit, prepaid), issuer countries, and specific transaction outcomes like approvals, declines, and 3D Secure challenges. Typical use cases span from automated continuous integration (CI) pipelines that require unique test data for each run, to teams developing payment interfaces that must simulate a wide array of real-world customer payment methods. Exposing this API as a tool via the Model Context Protocol (MCP) transforms it into a powerful, dynamic resource for AI-powered coding assistants like Claude Desktop, Cursor, or Cline. The primary value lies in automating and contextualizing a previously manual and context-switching task. Instead of a developer having to leave their IDE to visit the Adyen docs, copy a card number, and then return to write a test case, they can delegate this to the AI agent. The agent gains the ability to "think" with test data as a first-class citizen. For example, a developer can instruct the AI to generate a complete, realistic test suite for a new checkout feature. The AI can then dynamically call the `createTestCardRanges` endpoint to procure the exact test cards needed for specific test cases—such as a German Visa card for a successful payment test and a US Mastercard configured to trigger a 3DS challenge—all within the same conversational or scripted workflow. This creates a more fluid, efficient, and less error-prone development process. Practical workflows enabled by this MCP integration are numerous and directly accelerate development. A developer could issue a command like, "Create a Jest test file for our payment form that validates successful and failed transactions." The AI agent would not only scaffold the test file but also proactively use the Test Cards API to populate it with a fresh set of dynamic test card numbers for each scenario. Another workflow involves updating an existing test suite: "Our testing has identified that we need to cover more issuer country variations. Update the payment simulation tests to include cards from Brazil, Japan, and the UK." The agent would then generate and insert the appropriate test cards into the relevant test files. Furthermore, for compliance or 3D Secure testing, a developer could request, "Generate a set of test cards specifically for testing Visa Secure authentication," and the agent would provide a curated list ready for integration. This turns the AI from a code generator into a contextual test data engineer. While the `POST /createTestCardRanges` endpoint itself does not require authentication, its integration within a broader development ecosystem must adhere to strict security best practices. Developers should treat the generated test card data as confidential to their sandbox environment and never commit it to public version control. When setting up an MCP server that exposes this tool, it is critical to configure it with the principle of least privilege; the server should only have network access to Adyen's sandbox API endpoints and nowhere else. If the MCP server requires a general Adyen API key for other operations, that key should be a dedicated test account key with minimal permissions. Rate limiting should be configured to prevent excessive calls to the Adyen endpoint. All configuration, especially API keys and server endpoints, must be managed through secure environment variables or secret management services, never hardcoded. Developers should also be aware that while the generated cards are for testing, they are modeled on real card number structures and must be handled with the same respect for data privacy as live payment data within their internal systems.
https://mcpbridge.org/config/adyen-com-testcardservice.json