200+ MCP servers on Cloudflare's edge — one endpoint, every tool, no local processes.
Connect any combination to Claude, Cursor, Windsurf, or your own AI agent. Your API keys stay encrypted in Aerostack's vault. Tools appear automatically namespaced: discord__send_message, stripe__create_invoice, hubspot__search_contacts.
200+ hosted Workers + 50 proxy entries. All edge-deployed, sub-50ms globally.
Any AI agent can discover and use all 200+ servers through the Aerostack Registry MCP. No browsing, no manual config — your agent searches and calls tools directly.
Add this to your MCP client config (Claude Desktop, Cursor, Windsurf, etc.):
{
"mcpServers": {
"aerostack-registry": {
"url": "https://mcp.aerostack.dev",
"transport": "streamable-http"
}
}
}No API key needed for discovery. Your agent now has access to 3 meta-tools:
| Tool | What It Does |
|---|---|
search_registry |
Semantic search across all MCPs, functions, skills, and agents. Ask "send Slack message" or "process payments" and get ranked matches. |
get_tool_schema |
Get full parameter documentation for any tool — input schema, descriptions, examples. |
call_function |
Execute any published community function directly (requires Bearer token). |
Agent: "I need to send a Slack message and create a Stripe invoice"
↓
search_registry("send slack message") → mcp-slack (post_message, 3 params)
search_registry("create stripe invoice") → mcp-stripe (create_invoice, 4 params)
↓
get_tool_schema("mcp-slack") → full parameter docs
get_tool_schema("mcp-stripe") → full parameter docs
↓
Agent now knows exactly how to call both tools
To actually call the tools (not just discover them), create a workspace at aerostack.dev and connect:
{
"mcpServers": {
"my-workspace": {
"url": "https://mcp.aerostack.dev/s/YOUR_USERNAME/YOUR_WORKSPACE",
"headers": {
"Authorization": "Bearer mwt_YOUR_WORKSPACE_TOKEN"
}
}
}
}All tools from all your servers appear automatically. Claude sees discord__send_message, stripe__create_invoice, hubspot__search_contacts — and chains them together.
The registry is discovery-only — searching and browsing is open, but executing tools requires explicit authorization from the workspace owner.
Discovery (open) Execution (gated)
───────────────── ─────────────────
search_registry ✅ tools/call ❌ without token
get_tool_schema ✅ tools/call ✅ with workspace token
Every tool in your workspace has a toggle. Enable what's safe, disable what's destructive.
Without Aerostack, an AI agent with a Database MCP can DROP TABLE users. With a GitHub MCP, it can delete repos and force-push to main. With Slack, it can delete channels and export private conversations.
With Aerostack, you choose exactly which tools the agent can call.
Workspace: "production-bot"
┌─────────────────────────────────────────────────────────┐
│ mcp-slack │
│ ┌──────────────────────────┬────────────┬────────────┐ │
│ │ Tool │ Type │ Access │ │
│ ├──────────────────────────┼────────────┼────────────┤ │
│ │ list_channels │ read-only │ ✅ enabled │ │
│ │ post_message │ write │ ✅ enabled │ │
│ │ search_messages │ read-only │ ✅ enabled │ │
│ │ get_channel_history │ read-only │ ✅ enabled │ │
│ │ delete_message │ destructive│ ❌ disabled│ │
│ │ kick_user │ destructive│ ❌ disabled│ │
│ └──────────────────────────┴────────────┴────────────┘ │
│ │
│ mcp-stripe │
│ ┌──────────────────────────┬────────────┬────────────┐ │
│ │ list_customers │ read-only │ ✅ enabled │ │
│ │ get_invoice │ read-only │ ✅ enabled │ │
│ │ create_payment_link │ write │ ✅ enabled │ │
│ │ delete_customer │ destructive│ ❌ disabled│ │
│ │ issue_refund │ destructive│ ❌ disabled│ │
│ └──────────────────────────┴────────────┴────────────┘ │
└─────────────────────────────────────────────────────────┘
AI agent sees: 6 tools (only the enabled ones)
AI agent cannot: call delete_message, kick_user, delete_customer, issue_refund
See the full breakdown with real examples: Agent Security →
| Control | How |
|---|---|
| Which MCPs are exposed | Add/remove servers from your workspace — only added servers are callable |
| Which tools are visible | Per-tool toggles — expose list_channels but hide delete_channel |
| Who can call | Workspace tokens (mwt_) — generate, revoke, rotate anytime |
| What secrets are shared | Per-workspace encrypted secrets — your Stripe key is never shared with the Slack MCP |
| Rate limits | Per-token rate limiting — prevent abuse from any single consumer |
| Access tiers | Public (open), Key-required (token gated), or Paid (subscription) |
- API keys are encrypted at rest in Aerostack's vault
- Injected as
X-Mcp-Secret-*headers at runtime — never in the request body, never in logs - Each MCP server only receives the secrets it needs — Slack gets
SLACK_BOT_TOKEN, never your Stripe key - Workspace owners can rotate secrets without reconfiguring clients
An agent connecting to your workspace can only:
- See tools you've explicitly enabled
- Call tools with the permissions you've granted
- Use secrets you've configured for that workspace
They cannot: access other workspaces, see your secret values, bypass tool allowlists, or call MCPs you haven't added.
| Folder | Type | Maintained by |
|---|---|---|
proxy/ |
Official hosted MCPs — proxy config + README only, no code | 3rd party |
mcp-{service}/ |
CF Workers we build and maintain | Aerostack team |
These aren't just API wrappers. When you connect multiple MCPs, an LLM can orchestrate them together — and that's where the real products emerge.
Stack: mcp-whatsapp + mcp-zendesk + mcp-hubspot + mcp-stripe
Customer messages you on WhatsApp. Your bot:
- Looks up who they are in HubSpot by phone number
- Checks their Stripe subscription status and open invoices
- Finds their Zendesk tickets
- Answers with full context — name, plan, history, balance
If the issue is complex: creates a Zendesk ticket, notifies your Slack, tells the customer a human will follow up in 1 hour.
Zero code. Five secrets.
Stack: mcp-discord + mcp-notion + mcp-github + mcp-linear
Drops into your dev community server and:
- Answers questions by searching your Notion knowledge base
- Turns
#report-a-bugmessages into Linear/GitHub issues automatically - Posts weekly changelogs pulled from GitHub releases
- Welcomes new members with role-based onboarding based on what they say they do
Members feel heard. Your team stops manually triaging Discord.
Stack: mcp-telegram + mcp-pipedrive + mcp-calendly + mcp-resend
Your sales team runs on Telegram. The bot:
- Qualifies inbound leads with 3 questions
- Creates or updates the deal in Pipedrive automatically
- Books a discovery call via Calendly, sends confirmation via Resend
- Posts a summary to the team when a high-value lead books
Your SDRs focus on calls, not data entry.
Stack: mcp-whatsapp + mcp-shopify + mcp-stripe + mcp-mailchimp
Customer asks "where's my order?" on WhatsApp:
- Shopify: finds the order, gets tracking link
- Stripe: confirms payment cleared
- Answers with order status, tracking, and ETA
If their card failed: sends a Stripe payment retry link via WhatsApp buttons. Adds them to a Mailchimp "at-risk" segment for follow-up.
Stack: mcp-slack + mcp-github + mcp-sentry + mcp-railway + mcp-linear
Sentry fires an error. Your Slack bot:
- Gets the full Sentry event with stacktrace
- Searches GitHub for the file and recent commits
- Creates a Linear issue with full context pre-filled
- Checks Railway deployment logs for that time window
- Posts a summary in
#incidentswith links to everything
From alert to triage: under 10 seconds.
Stack: mcp-telegram (or mcp-whatsapp) + mcp-calendly (or mcp-cal-com) + mcp-google-calendar + mcp-sendgrid
Patient/client messages to book, reschedule, or cancel:
- Checks availability in real time
- Books the slot, adds to Google Calendar
- Sends confirmation email via SendGrid
- Sends reminder 24h before via Telegram/WhatsApp
Works for clinics, consultants, coaches, salons — any appointment-based business.
Stack: mcp-salesforce + mcp-sendgrid + mcp-gmail + mcp-calendly
Pull a list of leads from Salesforce. For each:
- Draft a personalized email using their account context
- Send via SendGrid or Gmail
- Track opens; when they click "Book a call" → Calendly link
- Update Salesforce opportunity stage automatically
Personalized outreach at scale. No marketing automation tool needed.
Stack: mcp-stripe + mcp-whatsapp (or mcp-telegram) + mcp-hubspot
Every morning, check Stripe for failed payments. For each:
- Look up customer in HubSpot for their preferred channel
- Send a WhatsApp/Telegram message with a one-click retry link
- If no response in 48h: escalate to email, create HubSpot task for sales
Churns recovered automatically before they even cancel.
These are the inbound channels. Every product above starts here.
| Server | Tools | Key Capability | Secrets |
|---|---|---|---|
| Discord | 23 | Send messages, manage channels, roles, members, threads | DISCORD_BOT_TOKEN |
| Telegram | 28 | Send/receive messages, inline keyboards, polls, moderation | TELEGRAM_BOT_TOKEN |
| WhatsApp Business | 24 | Session messages, templates, interactive buttons/lists, media | WHATSAPP_ACCESS_TOKEN, WHATSAPP_PHONE_NUMBER_ID |
| Slack | 12 | Post to channels, search, manage users and reactions | SLACK_BOT_TOKEN |
| Twilio | 6 | SMS send/receive, voice, phone number lookup | TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN |
Discord use cases:
- Community Q&A bot backed by your Notion/Airtable knowledge base
- Bug report collector → auto-creates GitHub/Linear issues
- Paid member verification → Stripe webhook → Discord role grant
- Dev team standup bot — pulls GitHub PRs and Linear issues every morning
Telegram use cases:
- Customer support for markets where WhatsApp isn't dominant (Russia, Iran, parts of Asia)
- Internal team alerts with inline approve/reject buttons
- Inline bot mode: users type
@yourbotanywhere to search your product catalog (Shopify) - Payment invoices sent and confirmed directly in chat (Stripe payment links)
WhatsApp use cases:
- E-commerce post-purchase flow: order confirmation → shipping update → review request
- Appointment reminders for clinics, salons, coaches (2B users can't be ignored)
- Payment collection in markets where WhatsApp is the primary communication layer
- Rich interactive menus for food ordering, product browsing
Before your bot responds, it should know who it's talking to.
| Server | Tools | Key Capability | Secrets |
|---|---|---|---|
| HubSpot | 12 | Contacts, deals, companies, notes, activities | HUBSPOT_ACCESS_TOKEN |
| Salesforce | 25 | Leads, contacts, accounts, opportunities, tasks, SOQL | SALESFORCE_ACCESS_TOKEN, SALESFORCE_INSTANCE_URL |
| Pipedrive | 20 | Persons, deals, organizations, activities, pipelines | PIPEDRIVE_API_TOKEN |
| Intercom | 22 | Contacts, conversations, messages, tags, companies | INTERCOM_ACCESS_TOKEN |
When a message arrives:
Phone: +44 7911 123456
↓
HubSpot: search_contacts(phone) → Sarah Chen, Enterprise plan
↓
Intercom: list_conversations(contact_id) → 2 open threads
↓
Stripe: get_customer(email) → $299/mo, renews April 5
↓
Claude now knows who Sarah is before saying hello
| Server | Tools | Key Capability | Secrets |
|---|---|---|---|
| Zendesk | 28 | Tickets, users, orgs, knowledge base, views, macros, CSAT | ZENDESK_SUBDOMAIN, ZENDESK_EMAIL, ZENDESK_API_TOKEN |
Zendesk use cases:
- Auto-create tickets from any messaging channel with full context pre-filled
- AI triage: read the knowledge base first, try to self-serve before escalating
- CSAT follow-up: closed ticket → send WhatsApp satisfaction survey 1 hour later
- Escalation path: detect anger/legal keywords → urgent ticket + Slack alert + human handoff
| Server | Tools | Key Capability | Secrets |
|---|---|---|---|
| Calendly | 15 | Event types, availability, scheduled events, invitees, webhooks | CALENDLY_API_TOKEN |
| Cal.com | 15 | Bookings, availability, event types, schedules (open-source) | CAL_COM_API_KEY |
| Google Calendar | 10 | Calendars, events, CRUD, free/busy, quick add | GOOGLE_ACCESS_TOKEN |
The scheduling flow:
"Can we talk tomorrow afternoon?"
↓
Calendly: get_event_type_availability(tomorrow, 12pm-5pm)
↓
"I have 2pm, 3pm, or 4:30pm free. Which works?"
↓
User picks 3pm
↓
Calendly: book the slot → confirmation sent automatically
HubSpot: update deal → next_step = "Discovery call Mar 15 3pm"
| Server | Tools | Key Capability | Secrets |
|---|---|---|---|
| Resend | 8 | Transactional email, domains, API keys | RESEND_API_KEY |
| SendGrid | 20 | Send, templates, contacts, lists, analytics, senders | SENDGRID_API_KEY |
| Gmail | 20 | Read, send, reply, forward, labels, drafts, threads | GMAIL_ACCESS_TOKEN |
| Mailchimp | 15 | Audiences, members, campaigns, tags | MAILCHIMP_API_KEY |
Use Resend for simple transactional (receipts, OTPs, welcome emails). Use SendGrid at scale with templates, personalization, and delivery analytics. Use Gmail when you need to read customer replies and act on them. Use Mailchimp for newsletters, drip campaigns, and audience segmentation.
Email + Bot combo: Customer asks a question on WhatsApp → resolved in chat → follow-up summary email sent via SendGrid 5 minutes later. Professional touch, zero effort.
| Server | Tools | Key Capability | Secrets |
|---|---|---|---|
| Stripe | 14 | Customers, invoices, subscriptions, payment links | STRIPE_SECRET_KEY |
| PayPal | 15 | Orders, captures, refunds, invoices, payouts | PAYPAL_CLIENT_ID, PAYPAL_CLIENT_SECRET |
| Razorpay | 15 | Orders, payments, refunds, customers, payouts | RAZORPAY_KEY_ID, RAZORPAY_KEY_SECRET |
| Shopify | 12 | Products, orders, customers, fulfillments | SHOPIFY_ACCESS_TOKEN, SHOPIFY_SHOP_DOMAIN |
Market coverage:
- Stripe → US, EU, global SaaS
- PayPal → 400M users, preferred in Germany/Eastern Europe/LatAm
- Razorpay → India (1.4B population, dominant payment gateway)
- Shopify → any product/order context
Payment recovery flow (automated):
Stripe: list_subscriptions(status: past_due) → 12 customers
For each:
WhatsApp: send_template("payment_failed", {name, amount, retry_link})
HubSpot: create_task("Follow up on payment", due: tomorrow)
If no action in 48h:
Gmail: send_email(personalized recovery email)
If still no action in 7 days:
Zendesk: create_ticket(priority: high, "At-risk customer")
| Server | Tools | Key Capability | Secrets |
|---|---|---|---|
| Linear | 12 | Issues, projects, teams, cycles, labels | LINEAR_API_KEY |
| Jira | 12 | Issues, projects, sprints, transitions, comments | JIRA_EMAIL, JIRA_API_TOKEN, JIRA_DOMAIN |
| Notion | 10 | Pages, databases, search, blocks | NOTION_TOKEN |
| Airtable | 10 | Records, tables, bases, views | AIRTABLE_API_KEY |
Notion + Discord combo: Your community asks questions in Discord. Your bot searches Notion for the answer. If no match: creates a Notion page stub so the team knows what to document next.
Linear + Sentry combo: Every new Sentry error → search Linear for duplicate → if none, create issue with error context, stacktrace, affected users count, and link to Sentry event. Your on-call engineer sees a Linear issue, not an email flood.
| Server | Tools | Key Capability | Secrets |
|---|---|---|---|
| GitHub | 14 | Repos, issues, PRs, commits, branches, files | GITHUB_TOKEN |
| Vercel | 14 | Projects, deployments, domains, env vars | VERCEL_TOKEN |
| Railway | 12 | Projects, services, deployments, logs, variables | RAILWAY_API_TOKEN |
| Sentry | 12 | Orgs, projects, issues, events, releases | SENTRY_AUTH_TOKEN |
| Cloudflare | 18 | Workers, KV, R2, D1 databases | CF_API_TOKEN, CF_ACCOUNT_ID |
The deployment bot: PR merged → Vercel deploys → bot posts in Slack:
- Link to preview deployment
- Changed files from GitHub
- Any new Sentry errors in the last 30 minutes
- Railway service health for dependent services
One message. Complete picture. No tab switching.
| Server | Tools | Key Capability | Secrets |
|---|---|---|---|
| Supabase | 12 | Select, insert, update, delete, RPC, storage | SUPABASE_URL, SUPABASE_ANON_KEY |
| PlanetScale | 10 | Databases, branches, deploy requests | PLANETSCALE_TOKEN |
Bot memory pattern with Supabase: Every bot conversation stored in Supabase. Query conversation history by user ID. Build full audit trail of what your AI agent did and why.
| Server | Tools | Key Capability | Secrets |
|---|---|---|---|
| Typeform | 16 | Forms, responses, webhooks, workspaces | TYPEFORM_API_TOKEN |
| Klaviyo | 18 | Profiles, lists, events, campaigns, flows | KLAVIYO_API_KEY |
| Mailchimp | 15 | Audiences, members, campaigns, tags | MAILCHIMP_API_KEY |
Typeform → trigger a bot flow: Customer submits a form. Webhook fires. Your bot reads the response, creates a HubSpot contact, books a Calendly slot, sends a confirmation email. All automated, zero code.
Klaviyo use cases:
- Sync bot interactions to Klaviyo profiles for behavioral email sequences
- Trigger flows when a bot conversation ends without resolution
- Segment customers by bot interaction history for targeted campaigns
| Server | Tools | Key Capability | Secrets |
|---|---|---|---|
| Google Sheets | 18 | Read, write, append, find, format, batch update | GOOGLE_SHEETS_ACCESS_TOKEN |
| Notion | 10 | Pages, databases, search, blocks | NOTION_TOKEN |
| Airtable | 10 | Records, tables, bases, views | AIRTABLE_API_KEY |
Google Sheets as a lightweight database: Append every bot conversation as a row. Build live dashboards showing resolution rates, escalations, top questions. No data warehouse needed.
| Server | Tools | Key Capability | Secrets |
|---|---|---|---|
| Figma | 12 | Files, nodes, comments, components, styles, images | FIGMA_ACCESS_TOKEN |
| OpenAI | 10 | Chat, models, embeddings, images, moderation | OPENAI_API_KEY |
| Anthropic | 12 | Messages, tool use, batches, models, admin | ANTHROPIC_API_KEY |
Anthropic MCP — recursive agents: Use Claude as a tool inside your own Claude agent. Spin up sub-agents for specific tasks (translation, classification, summarization) while the main agent orchestrates the full conversation.
Quick-start combinations for the most common products:
Secrets needed: WHATSAPP_ACCESS_TOKEN, WHATSAPP_PHONE_NUMBER_ID,
HUBSPOT_ACCESS_TOKEN, ZENDESK_SUBDOMAIN,
ZENDESK_EMAIL, ZENDESK_API_TOKEN
MCPs: mcp-whatsapp, mcp-hubspot, mcp-zendesk
Secrets needed: DISCORD_BOT_TOKEN, NOTION_TOKEN,
GITHUB_TOKEN, LINEAR_API_KEY
MCPs: mcp-discord, mcp-notion, mcp-github, mcp-linear
Secrets needed: WHATSAPP_ACCESS_TOKEN, WHATSAPP_PHONE_NUMBER_ID,
SHOPIFY_ACCESS_TOKEN, SHOPIFY_SHOP_DOMAIN,
STRIPE_SECRET_KEY, SENDGRID_API_KEY
MCPs: mcp-whatsapp, mcp-shopify, mcp-stripe, mcp-sendgrid
Secrets needed: TELEGRAM_BOT_TOKEN, PIPEDRIVE_API_TOKEN,
CALENDLY_API_TOKEN, RESEND_API_KEY
MCPs: mcp-telegram, mcp-pipedrive, mcp-calendly, mcp-resend
Secrets needed: SLACK_BOT_TOKEN, SENTRY_AUTH_TOKEN,
GITHUB_TOKEN, LINEAR_API_KEY, RAILWAY_API_TOKEN
MCPs: mcp-slack, mcp-sentry, mcp-github, mcp-linear, mcp-railway
Secrets needed: WHATSAPP_ACCESS_TOKEN, WHATSAPP_PHONE_NUMBER_ID,
STRIPE_SECRET_KEY, HUBSPOT_ACCESS_TOKEN
MCPs: mcp-whatsapp, mcp-stripe, mcp-hubspot
Sign up at aerostack.dev. Add secrets once. Connect any servers. Paste one endpoint into your AI client:
{
"mcpServers": {
"aerostack": {
"url": "https://aerostack.run/api/gateway/ws/YOUR_WORKSPACE_SLUG",
"headers": {
"Authorization": "Bearer mwt_YOUR_WORKSPACE_TOKEN"
}
}
}
}All tools from all your servers appear automatically. Claude sees discord__send_message, stripe__create_invoice, hubspot__search_contacts — and it knows how to chain them.
Each server is a Cloudflare Worker that:
- Accepts JSON-RPC 2.0 POST requests
- Reads secrets from
X-Mcp-Secret-*headers (injected by the Aerostack gateway) - Calls the target API with your credentials
- Returns MCP-formatted tool results
No runtime dependencies. No npm packages in production. No cold start delay. Pure fetch() at the edge.
Protocol: MCP 2024-11-05
Methods: initialize, tools/list, tools/call
Health: GET /health
- Fork this repo
- Copy a template:
cp -r mcp-github mcp-YOUR_SERVICE - Edit
src/index.ts— implementTOOLSarray andcallTool() - Update
aerostack.tomlwith correct worker name - Run
npm test— all tests must pass - Submit a PR describing the service and which tools you built
Open mcp-{slug}/src/index.ts, add to TOOLS and callTool(). Submit a PR.
const TOOLS = [
{
name: 'tool_name',
description: 'What this tool does',
inputSchema: {
type: 'object',
properties: {
param: { type: 'string', description: '...' },
},
required: ['param'],
},
},
];
async function callTool(name: string, args: Record<string, unknown>, token: string) {
switch (name) {
case 'tool_name': {
const res = await fetch('https://api.example.com/endpoint', {
headers: { Authorization: `Bearer ${token}` },
});
return res.json();
}
}
}cd mcp-YOUR_SERVICE
npm install
npm test # unit tests (no real credentials needed)
npm run dev # local wrangler dev serverIf you work at one of the companies in this catalog — claim the server and take over maintenance.
You get: verified company profile on Aerostack Hub, full code control, your branding, and option to add paid tiers.
Email hello@aerostack.dev with your company domain. Verified and transferred in 48h.
MIT