Modal Labs MCP: What It Is, Setup and Cost (2026)
Nov 12, 202614 min read
"Modal Labs MCP" means an MCP server, a Python function an AI client can call as a tool, running on Modal's serverless compute.
What Modal Labs MCP actually is
MCP is the protocol, and Modal is only where the server lives, much as a workflow built in Activepieces is defined by its logic rather than by the machine that happens to run it.
The bracket is what the phrase means, and the client sits outside it.
Every one of those servers needs somewhere to run, and that is why people search for it.
The registry tracked by Dataku listed 50 servers in November 2024 and 180 by January 2025, representing more than a threefold expansion in just two months, so competition for tools in this ecosystem is intensifying rapidly.
By March the registry held 520, then 1,100 in May, 1,800 in July and 2,600 in September 2025. That's roughly fifty-fold growth in ten months, and the hosting question grew with it.
Two meanings of Modal Labs MCP
Read one way, the phrase means servers you deploy yourself on Modal, where the bill is Modal's compute and the design mistakes are yours.
Read the other way, it means MCP access to Modal's own documentation, which only lets an assistant read about Modal. The first is a hosting decision and the second is a lookup convenience.
Wanting the hosting without writing the server code sends some teams to Activepieces, which turns any of its 747 integrations into an agent tool without a server to write, but that's a separate choice.
As of 2026-11-12, Modal's docs and pricing describe no managed MCP product with its own price line. The pricing there is for compute, so an MCP server costs whatever its function costs to run.
Treat the registry counts above as a third-party tally, since they come from Dataku and not a vendor page.
Everything below works on Activepieces' free plan. Start without code or a credit card.
Which Modal plan fits you
On a Modal bill, the plan fee is the small part.
Starter costs $0 and Team costs $250 a month, and metered compute lands on top of either, so the fee tells you what you unlock, not what you'll pay.
Read the last column of the table first, because that's what pushes you up a tier. It maps four common situations to a plan and its catch.
| Situation | Plan | Monthly fee | Catch |
|---|---|---|---|
| Solo | Starter | $0 | Container caps limit how many MCP server instances run at once |
| Team of 5 | Team | $250 | Compute is billed on top of the fee |
| Team of 25 needing SSO | Enterprise | Set by quote | SSO sits above Team, so the fee is not the number to budget around |
| Heavy GPU | Team | $250 | GPU time is metered on top and dominates the bill |
If you are one person testing an MCP server, Starter at $0 fits. You hit the container caps before you hit a bill, so a prototype stays cheap until it needs to serve several agents at once.
For a team of 5, Team at $250 is the sensible floor once several people deploy shared servers. Budget for compute separately, because the fee buys headroom and not usage.
For a team of 25, SSO is the feature that moves you off Team. Single sign-on matters here because 25 people holding agent credentials is an access-control problem, so confirm the tier with Modal before committing.
For heavy or GPU-bound usage the plan barely changes the bill. GPU hours are the cost, so estimate your runtime before comparing plans.
How an MCP server runs on Modal
On Modal, an MCP server is a Python function deployed as a web endpoint that serves MCP over HTTP. You pay for the seconds a container runs, not for the server existing.
Of the six steps in the lifecycle, the last two decide the bill:
You pay for the seconds a container runs, not for the server existing.
- Define the container image with the packages the server needs.
- Attach secrets for the credentials your tools use.
- Write a Python web endpoint that serves MCP over HTTP.
- Deploy it.
- The first request cold-starts a container.
- An idle container scales to zero.
Nothing runs between requests, so a rarely used server costs nothing while it waits.
You pay for that in latency. The first call after an idle spell waits for a container to start. A person supervising an agent will tolerate the pause, but a tight tool-calling loop will feel it, so test that path before you promise anything.
Because secrets reach the function as environment variables, API keys stay out of the image and the repository. The endpoint's still a public URL, so check a token on every request. Otherwise anyone who finds the address can call tools that hold your credentials.
How Modal MCP pricing is billed
You are billed per second of container runtime, and the GPU you pick sets the rate.
According to Modal, a T4 is $0.000164 per second, about $0.59 an hour, and an L4 is $0.000222, about $0.80, making the L4 roughly 35 percent more expensive per hour.
Further up, an A100 40GB is $0.000583 and an A100 80GB is $0.000694, roughly $2.10 and $2.50 an hour, meaning the 80GB variant costs roughly $0.40 more per hour. An H100 is $0.001097, near $3.95 an hour, and a B200 is $0.001736, near $6.25.
So the cheapest GPU isn't much cheaper than the next one up, and the top card costs roughly ten times the bottom. Start with the smallest GPU that fits your model, because a larger one multiplies every second of idle-adjacent work.
Where teams use Modal-hosted MCP servers
When the work is bursty and a small GPU, or no GPU, is enough, Modal-hosted MCP servers earn their place, because you pay for the calls rather than the waiting.
Three patterns recur. Code sandboxes let an agent run untrusted code in an isolated container instead of on a developer's laptop. GPU inference as a tool lets an agent call a model it can't run itself, such as an embedding or transcription model.
Third, data-heavy lookups put a large dataset next to the compute that searches it, so the agent receives an answer instead of a download.
Most of these already exist unsanctioned as local stdio servers on individual laptops, which is fast to start and impossible to govern. The sanctioned alternative is a trade, not a ban.
Read the idle cost and first-call latency columns together: they're the same trade seen from two sides.
| Option | Setup effort | Idle cost | GPU access | First-call latency | Maintenance owner |
|---|---|---|---|---|---|
| Modal | Moderate: write the server as Python functions and deploy | None while scaled to zero | Yes, chosen per function | Slower on the first call after idle, while a container starts | You own the code; Modal owns the infrastructure |
| Self-managed container | High: image, hosting, networking, scaling | You pay for the machine whether it is used or not | Only if you provision GPU hosts | Fast, since it stays warm | You own everything |
| Local stdio server | Lowest: run a process | None beyond the laptop | Only the developer's own hardware | Process start only | Each individual developer |
| Activepieces MCP | Low: connect to a hosted service | $0 on the Free plan (1,000 credits a month); Plus is $20 a month flat | Not applicable to your own models | Depends on the hosted flow | Shared with the vendor |
If your agent can tolerate a cold first call, Modal removes the idle bill. If it can't, you're choosing between a warm container and a paid-for machine.
Easier to see it running than to read about it: set it up free, no card.
Mistakes that break or inflate Modal MCP deployments
Choosing between a warm container and a paid-for machine is the first of six mistakes, and each traces to the hosting model, not to MCP. Each is paired below with its fix.
- No auth: require OAuth or a token on every request.
- Cold start over client timeout: keep one container warm, or raise the client timeout.
- Warm container billed idle: keep warm only what a user is waiting on.
- Long job in a synchronous call: return a job ID and let the client poll.
- Hardcoded secrets: keep keys in Modal Secrets, not in the image or repo.
- Free credits treated as a budget: treat them as a trial and set your own monthly ceiling.
The first four need explaining.
Start with auth. mcp.tc counts 536 public MCP servers, 364 of them remote, and 273 of those remote servers require OAuth. That's 75%, so an open endpoint is the outlier, and clients will expect a login flow.
When a container starts from zero, it may answer after the client has given up, and the user sees a failed tool call. Pay for one warm instance on the tools people wait on.
Leave a container warm and it bills whether or not anyone calls it, so one forgotten instance becomes a monthly line item. Keep warmth only where latency matters, and let everything else scale to zero.
When a tool call runs for minutes, it ties up the connection and invites a timeout. Start the work in the background, return an identifier, and give the agent a second tool to check status.
Where Activepieces fits beside Modal MCP
Think of it as sitting beside Modal rather than replacing it: Activepieces covers the business-app side, such as Slack, Gmail and Sheets actions among its 747 integrations, meaning you're unlikely to need custom integration code for standard business software, while Modal covers custom Python and GPUs.
The two also connect: an Activepieces workflow can call a Modal endpoint over plain HTTP.
Two doors in front of the client
In front of the AI client are two doors.
One leads to an Activepieces MCP server for app actions, a platform MoneyGram, Moneypenny, Alan and FundingSocieties run in production, and one to a Modal MCP server for your own code, and a workflow behind the first door can reach through to Modal.
Taking the first door means you don't write or host glue code for every app. Which door you lean on depends on who is using it.
Which Modal MCP approach fits your team
For a solo prototype, use Activepieces for the app actions, where the Free plan is $0 with unlimited flows and 1,000 credits a month, and write only the one function that needs custom logic on Modal.
The catch is that you now run two systems, so keep the Modal side to what a prebuilt integration can't do.
For a team of 5, put shared connections, such as one Slack or Gmail credential, in Activepieces, so the agent never holds a personal login.
Least privilege here is a design choice: expose only the actions the agent needs. The catch is that the exposed set grows quietly unless someone owns it.
For a team of 25 needing SSO, single sign-on and admin controls are what push a team off the easy path.
Hosted tiers and self-hosting differ on them, so check what your tier includes before you promise it internally. Self-hosting trades a plan limit for operating work.
For heavy or GPU-bound usage, send the work to Modal.
Activepieces orchestrates and doesn't supply GPUs, so route the heavy step through an HTTP call and keep the workflow thin; a run is 1 credit however many steps it has, so the extra step doesn't add to the credit count.
What to do on Monday with Modal MCP
Decide which Modal MCP you mean, deploy one small authenticated server, and measure it for a day against your credits before you commit to anything larger. That's how you find out whether the heavy step belongs on Modal at all.
First, settle the meaning: either an MCP server you host on Modal's serverless compute, or whatever MCP access Modal offers for its own documentation. Only the first one generates a bill and a security surface.
- Pick the meaning that applies to you: hosting your own server, or reading Modal's docs through an assistant.
- Read the current pricing page and write down the date you read it.
- Deploy one small server with authentication in front of it, exposing a single narrow tool.
- Run it for a day, recording cold-start delay and what the day cost against your credits.
- Set a spend limit before anyone else gets access.
- Decide whether you need Modal, or whether the app integrations you already use cover the job.
Since Modal sells compute, not a managed MCP product, an existing integration is the cheaper answer when your tool is a thin lookup against a service you already use, and the checklist will tell you so.
Frequently asked questions
Is Modal Labs MCP free to use?
Not as a single thing, because the MCP part costs nothing and the hosting part doesn't. The protocol is open; what you pay for is the compute your server uses on Modal, billed by usage.
To test, the Starter plan is enough, but a server that stays warm all day is a running cost you should price before you commit.
Don't expect Modal's own MCP access to run your tools, because it is aimed at its documentation. Treat it as a way for your coding assistant to read Modal's docs.
It's separate from hosting your own MCP server on Modal, and its current status is worth checking in Modal's docs before you rely on it.
Can Claude or Cursor connect to an MCP server on Modal?
Yes, if the server is exposed over HTTP. Modal serves a web endpoint at a URL, and a client that supports remote MCP servers connects to that URL with whatever authentication you put in front of it.
If a client only launches local stdio processes, it needs a small local bridge to reach the server, which is extra setup you should plan for.
Where it lives is the difference between Modal MCP and a local server. A local server runs on one person's machine with that person's credentials, and it disappears when they close the laptop.
A server on Modal is shared, reachable by URL, and billed by usage. That makes it useful for a team, and it also makes access control and secrets handling your job rather than your laptop's.
If the tools your client needs are CRM, email or Sheets actions, you may not need a Modal server at all.
Every connector in Activepieces is already an agent tool: a integration you connect once runs as a step in a flow and is also a tool schema on the project's MCP server, open to Claude, ChatGPT, Cursor or an agent you built.
So there is no catalog to publish to, no export step and no function to host, which is the work a Modal server would have cost you.
The same integration action serves both uses, and you can see it in packages/integrations in the open source repo, whose core is MIT-licensed; Modal stays for the custom Python and GPU work it's built for.
