---
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/dev-portal"
sourceUrl: "https://zuplo.com/dev-portal"
pageType: "product"
generatedAt: "2026-10-23"
---

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

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.

- [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
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

Ship a portal your developers actually want to read. Free Zuplo project, point
it at your spec, and you're hosting docs.acme.com tomorrow.

- [Start for Free](https://portal.zuplo.com/signup)
- [Read the Docs](https://zuplo.com/docs/dev-portal/introduction)