---
title: "Developer Portal: Auto-Generated API Docs & Self-Serve Keys"
description:
  "Auto-generated docs from your OpenAPI, interactive API explorer, self-serve API keys, custom React pages, and your custom domain — built into every Zuplo project. Zero hosting to operate."
canonicalUrl: "https://zuplo.com/features/developer-portal"
sourceUrl: "https://zuplo.com/features/developer-portal"
pageType: "feature"
generatedAt: "2026-10-21"
---

# A developer portal that ships every time you do

> Docs that drift from your API are worse than none. Get a portal that regenerates from your OpenAPI on every deploy — so developers can grab a key and make their first call in minutes.

![Zuplo developer portal — interactive API reference with code samples](https://zuplo.com/media/posts/2025-07-01-new-zuplo-developer-portal/api-reference.png)

![Interactive API playground — make a live request from the docs](https://zuplo.com/media/posts/2025-07-01-new-zuplo-developer-portal/playground.png)

## The portal is the API for everyone outside your team

Every developer's first impression of your API is your portal. If the docs are stale, the keys are slow, or the experience feels stitched together, the rest of your product can't recover the trust. The portal is the product surface — it should ship with the gateway.

### Docs out of date the moment you ship

Every release adds a manual sync — update the spec, regenerate the docs, redeploy the static site, watch the search index reindex. Two of those steps eventually get skipped, and your customers' first impression is wrong.

### Customers waiting for keys

Sales-led API key issuance — emails, Slack DMs, plaintext keys — is how trial users abandon. The signup-to-first-call gap is where most developer-led growth dies.

### Three vendors for one experience

Docs in Mintlify. Pricing on Stripe. API keys in a custom dashboard. Three login flows, three sets of credentials, three places that drift. Customers feel the seams; your team maintains the seams.

### Customization or maintainability — pick one

Off-the-shelf doc tools look great until you need a custom landing page or a usage dashboard. Then you fork it, maintain a private copy, and inherit a 6-month upgrade backlog the next time the upstream changes.

## A docs site, an API console, a self-serve onboarding flow — one experience

### Always in sync with your spec

OpenAPI is the source of truth. The same OpenAPI file that powers your gateway powers your developer portal — every new endpoint, schema change, and parameter update appears in the docs at the moment the gateway ships. Zero publishing step. Zero docs lag.

### Self-serve, key to invoice

Customers sign up, create keys, run their first call, subscribe to a paid plan, watch their usage — all from one branded portal at your domain, without filing a ticket or talking to your team.

### Customizable to React, hosted by Zuplo

Drop in MDX, custom React pages, any theme — but the build, deploy, and hosting are managed for you. Customization ceiling of an open framework, with the operational cost of a SaaS.

## Beautiful custom pages, just a prompt away

The portal ships with a rich component library — cards, callouts, code blocks, tabs, hero sections, pricing tables, search. Tell your AI assistant to build a /changelog or /case-studies page using those components and you get a polished page that already matches your brand. No design system to invent, no React boilerplate to write.

Wire the page into navigation:

```ts
export default {
  topNavigation: [
    { id: "docs", label: "Docs" },
    { id: "api", label: "API Reference" },
    { id: "pricing", label: "Pricing" },
  ],
  // Built-in pricing, subscriptions, usage dashboard
  plugins: [monetizationPlugin()],
  customPages: [
    { path: "/changelog", component: "src/Changelog.tsx" },
    { path: "/case-studies", component: "src/CaseStudies.tsx" },
  ],
};
```

`src/Changelog.tsx` · using built-in components:

```tsx
import { Hero, Card, Stack, Badge } from "@zuplo/ui";

export default function Changelog() {
  return (
    <Stack>
      <Hero title="What's new" subtitle="Updates, weekly" />
      <Card>
        <Badge>v2.4.0</Badge>
        <h3>Streaming responses on /generate</h3>
        <p>...</p>
      </Card>
    </Stack>
  );
}
```

- Auto-generated from OpenAPI
- Self-serve API keys
- Try it · live API explorer
- Markdown / MDX / React
- Custom domain · managed cert
- Built-in usage dashboards

[Read the Developer Portal Docs](https://zuplo.com/docs/dev-portal/introduction)

## A portal you can ship with, not against

### The same portal that ships zuplo.com/docs

What you see at zuplo.com/docs is the developer portal that ships with every Zuplo project — battle-tested, performant, and built on an open framework on top of Vite + React. You're never locked into a black-box doc tool.

### One gateway, multiple audiences

Public retail self-serve, partner with sales-reviewed onboarding, internal team behind SSO — all served by the same gateway with different visible API surface, different sign-in, and different brand. Run them as separate portal deployments or as one portal that branches on the user's identity.

### First-class API key + plans UX

Self-serve key management is included — not a paid add-on. Enable monetization and you also get pricing, subscription management, and a usage dashboard. Stripe-quality UX, without writing a Stripe Customer Portal integration.

### Your domain, your brand

Custom domain via CNAME in minutes. Theme tokens for fonts, colors, spacing. Custom React pages for everything the auto-generation doesn't cover. The portal feels like part of your product, not a vendor's hosted site.

## What teams use this for

**"We need docs at docs.acme.com that match our marketing site."** Configure the custom domain (CNAME → cname.zuplodocs.com), drop your design tokens into the portal theme, and the portal serves at docs.acme.com with the same fonts, colors, and brand the rest of your product uses.

**"The marketing team owns the home page; engineering owns the docs."** Marketing writes MDX or custom React pages for landing/quickstart/marketing surfaces. Engineering owns the OpenAPI spec that drives the reference. Both ship through the same Git repo with the same review process.

**"We need a public retail portal AND a sales-reviewed partner portal."** Run two portals against the same gateway. Public at developers.acme.com — self-serve signup, free-tier API key minted on signup, only the public spec visible. Partners at partners.acme.com — sign-in via your IdP, applications go through an approval queue, the full API surface and contract pricing become visible after approval. Same gateway, same OpenAPI source of truth, two distinct audience experiences.

**"Internal teams should see endpoints we don't expose externally."** Stand up an internal portal at internal-apis.acme.com behind your corporate SSO. Wire in the internal-only OpenAPI specs alongside the public ones. Engineers see every endpoint and every internal service; external developers never know they exist. No duplicated docs site, no second source of truth.

## Frequently Asked Questions

### What is a developer portal?

A developer portal is the front door to your API — docs, API key signup, an interactive explorer, and (if you monetize) pricing and usage dashboards. The best portals reduce "time to first call" from days to minutes. Zuplo includes one in every project, auto-generated from your OpenAPI spec, hosted on your domain, customizable in React. The portal that ships zuplo.com/docs is the same one you get out of the box.

### How do I auto-generate API docs from an OpenAPI spec?

Point your portal at your OpenAPI document and the reference docs, code samples, and "Try it" panel generate themselves. With Zuplo, the gateway and the docs read from the same OpenAPI file — edit the spec, deploy, the portal updates. No publishing step, no manual sync, no chance of docs drifting from the API. Unlike standalone tools (Redocly, ReadMe, Stoplight), the docs and the gateway are one system.

### How do I let API customers self-serve their API keys?

The Zuplo developer portal includes self-serve key management out of the box — customers sign in with Auth0, Okta, Clerk, Entra, or any IdP, then create, roll, and revoke their own keys. Customers don't file tickets to your team and your team doesn't run a key vending machine. You can also embed the open-source React component in your existing dashboard if you don't want a separate portal site.

### How do I customize the developer portal for my brand?

Configure a custom domain (CNAME), apply your design tokens (colors, fonts, spacing), drop in MDX or custom React pages for guides and tutorials, and the portal renders inside your brand instead of as a vendor microsite. Zuplo's portal is built on Vite + React, so the customization ceiling is essentially "whatever you can write in React." AccuWeather, BlockDaemon, and dozens of other companies run portals that feel native to their product.

### Does the developer portal include a Pricing page?

Yes — enable Zuplo's monetization plugin and the portal gains a self-serve Pricing page with checkout, Subscription Management, a real-time Usage Dashboard, and plan-aware API keys. Customers subscribe, upgrade, and watch their quota burn without your team in the loop. See [/features/api-monetization](/features/api-monetization) for the full billing story.

### Can I run multiple developer portals from the same API?

Yes. Most companies have more than one developer audience — public retail self-serve, partners with sales-reviewed onboarding, internal teams behind SSO. With Zuplo, deploy the portal as many times as you have audiences, each with its own theme, sign-in, and visible OpenAPI surface. They all read from the same gateway and key store, so consumers, plans, and analytics stay unified across audiences.

### What's the best developer portal for an API?

The best portal auto-generates from OpenAPI (no manual sync), supports self-serve API keys, integrates billing, runs on your domain with your branding, and is extensible enough to add custom React pages. Zuplo includes all of this and replaces what most companies build by stitching Redocly + their own dashboard + Stripe Customer Portal. AccuWeather migrated from Apigee + custom code to Zuplo and shipped a ChatGPT app on top in three clicks.

### Is there an API playground / interactive explorer?

Yes — every operation in the Zuplo developer portal has a "Try it" panel that hits your live API (or test environment) with the user's actual API key. Inputs and headers are pre-populated from your OpenAPI spec; the response renders inline with status, latency, and a JSON path explorer. Customers can test their integration before writing any client code.

## Next steps

- [Start for Free](https://portal.zuplo.com/signup) — free Zuplo project, point it at your spec, and you're hosting docs.acme.com tomorrow.
- [Read the Docs](https://zuplo.com/docs/dev-portal/introduction)