The End of the Developer Portal: How MCP and OAuth Give Users Back the Keys
Every integration means registering an app in another platform's developer portal and waiting for review. MCP with OAuth lets a platform publish one server that any client can connect to, with the user in charge.
The Model Context Protocol (MCP), paired with modern OAuth, removes the step where every company has to register an app in every platform’s developer portal before its users can connect. A platform publishes one MCP server, any MCP client can connect to it, and the user approves the access on the platform’s own consent screen. Integrations get cheaper to build, and the user, not a middleman, decides what connects to their accounts.
The developer-portal tax
Every founder who has built an integration knows the ritual. You want your product to talk to Zoom, so you open the Zoom Marketplace, create an app, fill in redirect URLs, pick scopes, write a privacy policy, record a screencast and wait for review. Then you do it again for Google. Then again for Facebook, where app review, business verification and use-case approval can take weeks.
None of this work makes your product better for users. It is a tax paid to each platform, once per platform, by every company that wants to connect to it. Multiply it across thousands of startups and you get a quiet drag on the whole software industry.
I think MCP, paired with modern OAuth, is the first real chance to stop paying it.
How we got here: one app per platform, per company
Today’s integration model was designed for a world where a handful of companies built against a handful of APIs. Each platform invented its own developer portal, its own scopes, its own review process and its own SDK. Each integrating company registers a separate “app” with each one and holds a separate set of keys.
That model created a predictable side effect: middlemen. Because registering and maintaining dozens of platform apps is expensive, a layer of companies grew up whose main job is to hold those registrations for you. Automation tools, unified-API vendors and connector marketplaces all sell the same thing underneath: “we already went through Facebook’s and Zoom’s review, so you don’t have to.”
The cost lands on users too. Your access ends up scattered across platform dashboards you rarely visit, granted to apps whose names you don’t recognise, often through an intermediary you never chose directly.
What MCP and OAuth change
MCP flips the direction of integration. Instead of every company building a custom connector to every platform, each platform publishes one MCP server, and any MCP-compatible client can use it: Claude, ChatGPT, an IDE, an internal agent, or another product.
The important part is how authorisation works. The MCP specification builds on OAuth 2.1 and on standards that let a client discover a server’s authorisation details automatically and identify itself without a manual sign-up step. In practice that means a client can connect to a new MCP server without its developer first creating an app in that platform’s portal and waiting for approval.
The user’s flow stays familiar: click connect, see the platform’s own consent screen, approve the access, done. What disappears is the hidden step before it, where a company had to register, get reviewed and hold credentials on the user’s behalf.
Why MCP beats the per-platform app model
| Traditional platform apps | MCP with OAuth | |
|---|---|---|
| Setup per platform | Register an app, configure scopes, pass review | Connect to a published server |
| Who builds the integration | Every company, for every platform | The platform, once |
| Interface | A different API and SDK per platform | One protocol for all servers |
| Time to first connection | Days to weeks | Minutes |
| Who holds access | Often a third-party connector | The user and the client they chose |
| Revoking access | Hunt through each platform’s settings | Disconnect the client or server directly |
The advantages compound:
- No registration treadmill. Small teams can integrate with large platforms without a dedicated person managing developer portals.
- Build once, work everywhere. A platform that ships an MCP server is instantly usable by every MCP client, not just the few partners it approved.
- Fewer middlemen. When connecting is standard and cheap, there is less reason to route your data through a company whose value is holding API keys.
- Less maintenance. One protocol to support instead of a dozen SDKs that each change on their own schedule.
- A natural fit for AI agents. MCP tools describe themselves, so an agent can understand what a service does without custom glue code.
Users hold the keys
The deeper shift is about who is in charge. In the old model, the integrating company decides which platforms you can connect, because it decides which apps to register. In the MCP model, the user decides. If a service has an MCP server and you use an MCP client, you can connect them yourself.
Access also becomes legible. Each connection is a direct OAuth grant between you, the client you use and the service you trust, shown on that service’s own consent screen. You can see what you granted, narrow it and revoke it without filing a ticket with an intermediary.
That is what account ownership should have meant all along: your data, your connections, your call.
What MCP doesn’t fix yet
It would be dishonest to claim the developer portal is already dead. Three things still stand in the way.
- Platforms have to opt in. MCP only removes the registration step when a platform publishes an MCP server that accepts clients without manual approval. Many don’t yet, and some will keep allow-lists for business or safety reasons.
- Gatekeeping won’t vanish entirely. Platforms still need to stop spam, scraping and abuse. Expect review processes to shift from “approve each app” towards rate limits, trust signals and per-scope controls, not to disappear.
- Security needs care. Letting AI agents act on your accounts brings new risks, such as prompt injection and over-broad permissions. Clear scopes and visible consent matter more, not less.
The direction is still right. The question is how fast platforms follow it.
Why we built Keepp on MCP
I’m the founder of Keepp, and I’ve paid the developer-portal tax firsthand. Keepp gives creators and small businesses a single page at keepp.link/yourname where people can book appointments, buy products, pay through Stripe, join Zoom or Google Calendar meetings and chat with you.
To make that work, we had to do exactly what this article complains about: register and maintain separate apps with Google, Zoom, Stripe and Telegram, each with its own review and rules.
So we chose to sit on the other side of the problem. Keepp offers its own MCP server. Our users can connect Keepp to the AI assistant they already use and run their business by conversation: build or redesign their page, add a product, change their booking hours or check their catalogue. They grant that access through standard OAuth, and they can revoke it whenever they want. No developer account, no app registration, no middleman.
We think every platform should offer the same, and we’d rather lead by example than wait. If you want the details of how we built it, read what we learned letting Claude and ChatGPT edit live websites over MCP.
A request to platforms
To the teams behind Facebook, Zoom and every platform with a developer portal: publish an MCP server, support open client registration and put users in charge of who connects to their accounts. You will reach every AI client at once, and your users will thank you.
To builders: stop treating integrations as a moat built from API keys. The moat is the product.
The developer portal had a good run. It’s time to hand the keys back to the people who own the accounts.
Like what you read? Add Keepp as a preferred source on Google to see more of our posts in your search results.