---
title: "A developer portal that ships every time you do"
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-08-03"
---

# A developer portal that ships every time you do

> Docs that drift from your API are worse than none. Zuplo includes a developer
> portal in every project that regenerates from your OpenAPI spec on every
> deploy, ships self-serve API key management, and is customizable in React — 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)

## Why this matters

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.

Common pain points this solves:

- **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.

## What you get

A docs site, an API console, and 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 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, and 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. The
  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:

```typescript
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>
  );
}
```

Built-in capabilities:

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

## What makes Zuplo different

- **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.

## FAQ

**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
- Read the developer portal docs: https://zuplo.com/docs/dev-portal/introduction
- See the full billing story:
  [/features/api-monetization](/features/api-monetization)