NaaP - Network as a Platform

The official Livepeer network portal and plugin platform. Build, install, and publish modular tools for managing Livepeer infrastructure - gateway monitoring, orchestrator management, analytics, and more.

NaaP is an official Livepeer project maintained in the livepeer/naap repository. The platform is live at operator.livepeer.org, with full developer documentation at operator.livepeer.org/docs.

The platform gives operators, developers, and governance participants a single interface for managing Livepeer infrastructure. It is extensible by design: any team can build and publish a plugin that inherits auth, navigation, theming, and database infrastructure from the shell.

NaaP is in active beta development. Breaking changes to the plugin SDK may occur between releases. Check the NaaP changelog before upgrading.

How NaaP works

NaaP is a micro-frontend architecture. The shell application is a Next.js 15 host. Plugins are compiled to UMD bundles and loaded at runtime via a plugin registry. Each plugin gets a ShellContext object on mount - this is the entire interface between a plugin and the platform.

The shell provides these services to every plugin via ShellContext:

interface ShellContext {
  auth: IAuthService;           // Authentication and authorisation
  navigate: NavigateFunction;   // Client-side navigation
  eventBus: IEventBus;          // Inter-plugin communication
  theme: IThemeService;         // Theme management
  notifications: INotificationService; // Toast notifications
  integrations: IIntegrationService;   // AI, storage, email
  logger: ILoggerService;       // Structured logging
  permissions: IPermissionService;     // Permission checking
  tenant?: ITenantService;      // Tenant context
  team?: ITeamContext;          // Team context
}

Plugins own a full vertical slice: frontend React components, backend API logic, and an isolated PostgreSQL schema within the shared database. In production (Vercel), plugin backends run as Next.js API route handlers at /api/v1/[plugin-name]/*. In local development, the shell proxies the same routes to standalone Express backends on ports 4001-4012.

The following diagram shows the complete request flow from browser to database.

Installed plugins

NaaP ships with 12 plugins covering developer, operator, monitoring, and governance use cases. The Plugin Marketplace plugin manages installation of additional community plugins.

Building a plugin

NaaP has full tooling for plugin development and publishing. If you are building a network tool - a monitoring dashboard, a governance interface, an AI pipeline manager - shipping it as a NaaP plugin gives you shared auth, navigation, and database infrastructure with zero setup.

Install the CLI and scaffold a plugin:

npm install -g @naap/plugin-sdk
naap-plugin create my-plugin
naap-plugin dev

The dev server hot-reloads your plugin inside the shell at http://localhost:3000. The start.sh script manages the full platform locally:

git clone https://github.com/livepeer/naap.git && cd naap && ./bin/start.sh

First run handles everything: dependency installation, PostgreSQL via Docker, schema creation, .env generation, plugin bundle builds, and platform start. Subsequent starts take 6-8 seconds.

Every plugin declares a plugin.json manifest:

{
  "id": "my-plugin",
  "name": "My Plugin",
  "version": "0.1.0",
  "category": "developer",
  "permissions": ["network:read"]
}

Plugins access shell services through the SDK hooks:

import { useShell, useAuth, useEventBus } from '@naap/plugin-sdk';

export function MyPlugin() {
  const { navigate, notifications } = useShell();
  const { user } = useAuth();
  const eventBus = useEventBus();
  // ...
}

All plugin API calls go through /api/v1/my-plugin/* using the standard response envelope:

// Success: { success: true, data: T, meta?: { page, limit, total } }
// Error:   { success: false, error: { code, message } }

NaaP also ships AI prompt templates for building plugins without writing boilerplate. The Prompts section in the NaaP docs covers 8 templates covering frontend plugins, full-stack apps, UI design, testing, and publishing - paste them into any AI assistant.

Full development guides are at operator.livepeer.org/docs/guides/your-first-plugin. The SDK hooks reference is at operator.livepeer.org/docs/api-reference/sdk-hooks.

Resources

Related pages

pymthouse

Identity, billing, and payment signing infrastructure. Integrates with NaaP’s Developer API Manager as a billing provider via OAuth.

AI authentication guide

Set up API authentication for AI inference requests in your Livepeer application.

Builder opportunities

Explore grants, RFPs, and open-source contribution paths for ecosystem builders.

Governance and Foundation

Governance structures and treasury mechanisms that fund Livepeer ecosystem projects.