What Is an MCP Gateway? A Plain Definition and Two Kinds
An MCP gateway is one endpoint between an agent and many tools. Learn the definition, the two kinds that share the name, and how to try one.

See what an MCP gateway is by using one: search the web and read a page from one prompt. Paste this into your agent:
Set up https://monid.ai/SKILL.md, and then use Monid to search the web for what an MCP gateway is, and read the Docker MCP Gateway documentation page as markdown.
One prompt reaches a search tool and a page reader through one connection. 1 min setup · 9-18 hrs saved.
An MCP gateway is one endpoint that stands between an agent and many tools, so the agent connects once instead of once per tool. The definition is short; the confusion comes from the two very different products that use the name. This guide gives the definition, takes it apart, separates the two kinds, and runs a live call through the second kind so you can see what it returns (we ran it on 2026-10-16). It runs through Monid, the OpenRouter for agent tools: one key, one balance, every tool priced per call.
What is the easiest way to try an MCP gateway with your agent?
Monid. It is a gateway of the outward kind: install it once, add a key, and your agent can search a catalogue of tools and call any of them, without a separate vendor account for each.
- Pay per call. Each run bills on its own. A web search is $0.000253 per result and a page read is $0.002533 per call (Verified 2026-10-16 on the AI tools page). Buy calls as you need them: no monthly plan and no minimum top-up. Discovery and inspection are free; only a run bills.
- One install, every tool. The same key and the same balance reach search, page reading, company data and more. Adding a capability is another call, not another signup.
- Lives inside your agent. Your agent reads
SKILL.md, learns the discover, inspect and run steps, and uses the catalogue whenever a task needs it. Setup is about a minute once you have a key.
What is an MCP gateway?
An MCP gateway is a proxy that speaks the Model Context Protocol on both sides: it presents one endpoint to an agent and forwards the agent's tool calls to many backends. MCP itself is, in the words of its own introduction page, an open-source standard for connecting AI applications to external systems. A gateway is what you put in the middle when "one agent, one server" stops being enough.
The four parts of the definition
Every MCP gateway does the same four jobs, and a product can be judged by which of them it takes seriously.
- One address. The agent configures a single connection. Behind it sit as many servers or vendors as the gateway wants.
- A tool list. The gateway tells the agent what it can do, either as a flat list or as a way to search for tools.
- Routing. When the agent calls a tool, the gateway decides which backend handles it and translates the call.
- Policy or billing. Somebody has to decide who may call what, or who pays for it. Which of those the gateway owns is what separates the two kinds below.
Two kinds share the name
When we searched for "what is an MCP gateway" on 2026-10-16, eight of the ten results described the gateway as a proxy, control point or aggregator that sits in front of MCP servers you already run. One was about turning REST APIs into MCP tools, and one was a roundup of gateways and security tools. None of the ten descriptions mentioned the other kind: a gateway that carries a catalogue of tools you have not installed.
This is our framing, not an industry standard, but it predicts what a product does:
| Aspect | Inward gateway (governance) | Outward gateway (access) |
|---|---|---|
| Faces | Servers your team runs | Vendors you do not run |
| Tools come from | Your own servers | A shared catalogue |
| Main job | Auth, audit, policy, isolation | Discovery, one key, one balance |
| Added when | Server count and oversight grow | The agent needs a capability it lacks |
| Fails when | A call cannot be traced | The agent cannot do the job at all |
The Docker page we read on 2026-10-16 is a clear inward example. It calls the MCP Gateway Docker's open source solution for orchestrating MCP servers, a centralized proxy that manages configuration, credentials and access control, and it runs each server in an isolated container with logging and call tracing. That is control over servers you chose. The rest of this guide is about the outward kind, because the inward kind is already well covered by its own vendors.
📖 See also LLM gateway vs MCP gateway
How does an MCP gateway work?
An MCP gateway advertises tools to the agent, then turns each tool call into whatever the real backend needs and returns the result as a tool result. The agent only ever speaks MCP; everything vendor-specific happens on the far side.
The handshake: what the agent is told
When an agent connects, it asks what tools exist. An inward gateway answers with the combined tool lists of the servers it fronts. An outward gateway with a large catalogue answers differently: it gives the agent a search step instead of a flat list, because advertising every tool definition on every turn spends the agent's context before it has done any work. That is why discovery matters more than the list itself.
You can see this in the catalogue. Our discovery call for "turn a url into clean markdown for a prompt" returned five ranked endpoints, each with provider, description, price, a status and a typical run time, and it cost nothing:
monid discover -q "turn a url into clean markdown for a prompt"
The top result was api.strale.io /x402/url-to-markdown at $0.0594 per call with an unknown status. The second was context.dev /web/scrape/markdown at $0.002533 (Verified 2026-10-16) with a healthy status, then keenable /v1/fetch, context.dev /parse and mrscraper /scrape/markdown. The agent can pick on price, status and fit, and nothing was installed to get that list.
The translation: a call in, a call out
The agent sends a tool name and a JSON payload. The gateway maps it to a real request and returns the vendor's answer. The credentials belong to the gateway, not the agent, which is the biggest practical difference from handing an agent raw API keys. Here is the schema read that comes before a call:
monid inspect -p context.dev -e /web/scrape/markdown
It returned the accepted inputs (url is required, plus options such as useMainContentOnly, maxAgeMs and country), the billing shape and a documentation link.
The metering: who pays
An inward gateway usually does not meter, because the services behind it are already yours. An outward gateway must, because it calls vendors on your behalf. The useful design is one balance drawn per call with the price visible before the call runs. Then run it:
monid run -p context.dev -e /web/scrape/markdown \
--query '{"url": "https://modelcontextprotocol.io/", "useMainContentOnly": true}' -w 120
It returned success: true and 3,690 characters of markdown, plus metadata. The URL we passed redirected, and finalUrl showed https://modelcontextprotocol.io/docs/2026-07-28/getting-started/intro. The call billed 2,533 micro-dollars, which is $0.002533 (Verified 2026-10-16), the price from the inspect step.
Set it up
For agents, grab an API key at app.monid.ai, then paste this to your agent and hand it the key:
set up https://monid.ai/SKILL.md
It learns the whole discover, inspect, run workflow itself. More in the agent quickstart.
For humans:
npm install -g @monid-ai/cli
monid keys add -k <your-api-key> -l main
More in the CLI quickstart.
What is the difference between an MCP gateway and an MCP server, an API gateway or a proxy?
A gateway is an MCP server that fronts other things. An MCP server exposes one set of tools, a gateway exposes many, and the protocol does not tell them apart, in the same way that a reverse proxy is still an HTTP server.
Gateway versus MCP server
A server is one integration: one vendor, one scope, installed and configured by you. A gateway earns its place when the count grows. With three servers, installing each is fine. With thirty you maintain thirty sets of credentials and thirty tool lists competing for context, and the agent still cannot reach anything outside them. When an agent needs a tool nobody installed, a person adds a server; with an outward gateway, the agent searches the catalogue and calls it.
Gateway versus API gateway
An API gateway routes requests from software that already knows what it wants. An MCP gateway serves an agent that has to learn the contract at run time, in tokens it also needs for the task. So an MCP gateway is judged on things an API gateway never faced: whether a tool description is good enough for a model to choose correctly, and whether the agent can find a tool it did not know existed. Authentication, rate limits, retries and observability carry over, and the same teams build both. The same split shows up in MCP versus plain API calls.
Gateway versus proxy
Proxy is the narrower word. It implies passing calls through with little added. Gateway implies the proxy plus a layer that decides something: a policy, a catalogue or a price. Vendors use both words for the same product, so read what it does to the tool list.
Can you build an MCP gateway yourself?
Yes, and for the inward kind it is often the right call. The servers are yours, the policy is specific to you, and open-source gateways exist to start from; the Docker page we read describes its gateway as open source and gives a binary install for Docker Engine.
The outward kind is a different job. The protocol is the easy part; the catalogue is the work. For every vendor you need an account, a key, a schema, an error model and a price, and you need them to stay current when the vendor changes something.
Monid is that catalogue, already built and kept current: the key, the schema, the price and the status of each endpoint sit behind one inspect call, and the vendor account is Monid's rather than yours. For public data and third-party APIs, wiring each vendor by hand is the slower route, as why an agent needs two integrations walks through.
What goes wrong when an agent uses a gateway?
Three things showed up in our runs, and each has a rule.
Why can a cached page still be billed?
Because the price is per call, not per fetch. The page read of modelcontextprotocol.io came back with cache_metadata status hit and an age_ms of 3,833,308, so the page had been fetched about 64 minutes earlier and the result was reused. It still billed 2,533 micro-dollars. The Docker page, fetched a few seconds earlier, was a miss. If your agent re-reads the same page in a loop, you pay for every read, so keep the result instead of asking again.
Why does the search bill by result?
Because the endpoint prices each result, not each search. Our context.dev /web/search call asked for 10 results and billed 10 units, $0.00253 in total (Verified 2026-10-16):
monid run -p context.dev -e /web/search \
-i '{"query": "what is an MCP gateway", "numResults": 10}' -w 120
Each result carried url, title, description and a relevance label, "high" on eight and "medium" on two. The markdown field held NOT_REQUESTED because inline page text is switched off by default. The inspect notes also say the requested numResults sizes the hold on your balance, with a minimum of 10, so ask for what you will use.
Why does a search result not equal an answer?
Because the snippets are one source's summary. The ten snippets we got were overwhelmingly about the inward kind, so an agent that stopped at the search would have defined the term from only one side. Follow a search with a page read of the primary source, as we did with the Docker documentation: about 3.9 seconds, 4,264 characters.
Give this to your agent![]()
Set up https://monid.ai/SKILL.md, and then use Monid to search the web for what an MCP gateway is, then read the two most relevant pages as markdown and tell me which kind of gateway each describes.📖 See also Web scraping MCP server: live web data for your agent
Which endpoint should I use for which job?
| Job | Endpoint | Input | Billing | Price (Verified 2026-10-16) |
|---|---|---|---|---|
| Search, optionally with page text | context.dev/web/search | query, numResults, domain filters | Per result | $0.000253 |
| One URL to prompt-ready markdown | context.dev/web/scrape/markdown | url, extraction options | Per call | $0.002533 |
| Neural search | exa/search | query, type, category, numResults | Per call, then per result above 10 | $0.007 |
| Domain or name to company record | pdl/v5/company/enrich | name, website, profile or ticker | Per call | $0.10 |
Prices Verified 2026-10-16 with monid inspect. We ran the first two rows. The Exa and company rows were inspected and not run. Current figures are on monid.ai/tools. Pick by billing shape first.
When is another route a better fit?
You run the servers yourself. If the question is who may call your internal database, you want the inward kind. A gateway that carries other people's tools cannot see your private servers, and the open-source and cloud products built for control are the right answer there.
You use two or three servers and nothing else. Installing them once is simpler than any gateway.
The vendor you need has a free tier that covers you. Per-call pricing suits variable use; it does not beat zero.
And the disclosure: we sell the outward kind, so we are not neutral on which you need. The practical test costs nothing. Ask whether your next missing tool is one you run or one you do not, and choose the kind that faces that way.
Conclusion
An MCP gateway is one endpoint between an agent and many tools, and the name covers two products: a control layer for servers you run and an access layer for vendors you do not. The quickest way to try the access kind is Monid: a search is $0.000253 a result and a page read is $0.002533 (Verified 2026-10-16), one key covers every tool, and it is ready inside your agent in about a minute.
Two things matter more than the label. Know which way a gateway faces before you compare vendors, because the two groups do not share a row in any table. And judge any gateway on what it does to the tool list, since an agent that sees a thousand definitions on every turn is worse at the actual job.
How we estimated the time saved: wiring three vendor integrations yourself (account, key, client code, schema handling) takes roughly 3 to 6 hours each, which is 9 to 18 hours. The 1 minute is the install, key and first call once you already have a Monid key.
Free next step: run monid discover for a capability your agent does not have today, then monid inspect on the top result. Neither spends anything. Start at monid.ai.
FAQ
What is Docker MCP Gateway?
Docker MCP Gateway is the inward kind: a proxy between clients and MCP servers that manages configuration, credentials and access control. The Docker documentation page we read on 2026-10-16 describes it as open source and says it runs each server in an isolated container with logging and call tracing. It manages servers you chose rather than supplying tools you lack.
What is the difference between an MCP gateway and an MCP registry?
A registry is a directory you read and a gateway is an endpoint you call. A registry tells a person that a server exists and where to get it; installing and authenticating it is still your job. A gateway is in the request path at run time, so it can also handle authentication, metering and translation. A large outward gateway contains a registry as its discovery surface.
What is an MCP router?
MCP router and MCP gateway are used interchangeably, with router leaning toward choosing a backend per call and gateway toward control. Neither term is standardised. The distinction that predicts what a product does is whether it fronts servers you run or vendors you do not.
Is there a free MCP gateway?
Open-source gateways exist for the inward kind, and the Docker page we read describes its gateway as open source. For the outward kind, discovery and inspection on Monid are free, and a run bills only what it uses: a search is $0.000253 per result (Verified 2026-10-16), so ten results are about $0.0025.
Which MCP server gives an AI agent access to live web data?
A gateway with a search tool and a page reader gives an agent live web data without a server per source. Through Monid an agent reaches context.dev/web/search for search and context.dev/web/scrape/markdown for a page. The fuller walk-through is in the live web data guide.
Published August 2026.


