Generated banner for Nitro
Generated logo for Nitro

Nitro

Anthony FuCommunityCreated by Anthony Fu

  • Skill
  • Tool integration
  • Software development
  • MIT
  • No issues found

From the author

Nitro is the framework-agnostic server toolkit (powering Nuxt) for building and deploying web servers anywhere. Use when working with nitro.config, server routes/event handlers, route rules, caching, storage, tasks, websockets, or deploying to Node/Bun/Deno/Cloudflare/Vercel.
— the description by Anthony Fu

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

Nitro is a server toolkit designed to build and deploy web servers that run on Node.js, Bun, Deno, and various cloud platforms like Cloudflare, Vercel, and Netlify. It provides a unified codebase for server development, featuring filesystem-based routing, a built-in KV storage layer, caching mechanisms, and support for tasks, WebSockets, and OpenAPI documentation. Nitro v3 introduces significant changes including a package rename, the removal of auto-imports, and a shift toward web-standard H3 v2 APIs.

What it does

  • Provides filesystem-based routing with H3 v2 event handlers.
  • Manages server configuration and runtime settings via nitro.config.ts.
  • Handles caching and storage using an unstorage-based KV layer.
  • Supports on-demand and scheduled tasks, WebSockets, and SSE.
  • Generates OpenAPI specifications automatically from route metadata.
  • Enables deployment to multiple runtimes and platforms through presets.

When to use it

  • When building a web server that needs to be portable across different deployment environments.
  • When you require a unified toolkit for handling routing, storage, and caching in a server project.
  • When migrating existing server projects from Nitro v2 to v3.
  • When you need to implement server-side tasks, WebSockets, or OpenAPI documentation.

Advantages

  • Framework-agnostic design allows for use with or without other frameworks.
  • Deployment-agnostic architecture supports a wide range of runtimes and cloud providers.
  • Unified storage and caching layer simplifies data management.
  • Declarative route rules for handling redirects, headers, and CORS.
  • Built-in support for modern web standards via H3 v2.

Usage examples

“How do I define a basic server route in Nitro v3?”
You create a file in your server directory and export a handler using defineHandler from the nitro package.
“How do I access KV storage in my Nitro server?”
You use the useKV function imported from nitro/kv to interact with your configured storage mount points.
“What is the correct way to import Nitro utilities in v3?”
You must use explicit imports from specific subpaths like nitro, nitro/kv, or nitro/h3, as auto-imports are no longer supported.
“How do I configure public assets in Nitro?”
You define a publicAssets array in your nitro.config.ts file, specifying the directory and base URL for your assets.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/antfu/nitro/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip nitro.zip -d .agents/skills

Documentation by Anthony Fu

The skill is based on Nitro v3 (beta, 3.0.260903), generated at 2026-09-25.

Nitro is a framework-agnostic, deployment-agnostic server toolkit powered by H3 v2, unstorage, and Vite/Rolldown/Rollup. It powers Nuxt and works standalone. From one codebase it builds optimized output for Node.js, Bun, Deno, Cloudflare, Vercel, Netlify, and more.

Key capabilities:

  • Filesystem routing with H3 v2 event handlers, dynamic params, and method suffixes.

  • Route rules for declarative caching, headers, redirects, proxying, and CORS.

  • Caching layer (cached handlers/functions, SWR) on top of the unstorage KV layer.

  • Runtime config overridable via NITRO_* env vars.

  • Tasks (on-demand + scheduled/cron), WebSockets/SSE, a SQL database layer, and OpenAPI auto-docs.

  • Plugins & lifecycle hooks, custom renderer/server entry, and portable deployment presets.

Key v3 changes (vs. nitropack v2): the package is renamed nitropack → nitro with H3 v2 (web-standard Request/Response); auto-imports are removed (import everything explicitly); directory scanning is opt-in via serverDir; useStorage → useKV (nitro/kv) and the storage config option → kv; cache swr now defaults to false. If unsure about v2-vs-v3 APIs, read advanced-migration first.

Core

TopicDescriptionReference
RoutingFile-based routes, defineHandler, params, middleware, route rules, errorscore-routing
Configurationnitro.config.ts, defineConfig, key options, runtime configcore-configuration
Storageunstorage KV, mount points, drivers, dynamic mountscore-storage
CachedefineCachedHandler, defineCachedFunction, SWR, invalidationcore-cache
AssetsPublic assets, compression, server assets via storagecore-assets
RenderingRenderer (HTML/SSR), server entry, framework integrationcore-rendering

Features

TopicDescriptionReference
Plugins & HooksdefinePlugin, runtime lifecycle hooks, error capturefeatures-plugins
TasksOn-demand & scheduled (cron) tasks, runTaskfeatures-tasks
WebSocket & SSEdefineWebSocketHandler, pub/sub, namespaces, event streamsfeatures-websocket
DatabaseBuilt-in SQL layer via db0, useDatabase, connectorsfeatures-database
OpenAPIAuto spec from defineRouteMeta, Scalar/Swagger UIsfeatures-openapi

Advanced / Deployment

TopicDescriptionReference
Deployment PresetsRuntimes & providers, compatibility dates, platform integrationdeploy-presets
v2 → v3 MigrationPackage rename, nitro/* imports, H3 v2 API, preset changesadvanced-migration

Files

references/core-configuration.md


name: configuration description: nitro.config.ts, defineConfig, key build options, and runtime config in Nitro

Configuration & Runtime Config

Nitro is configured via nitro.config.ts (loaded with c12) or, when building with Vite, via the nitro key in vite.config.ts.

Config file

import { defineConfig } from "nitro";

export default defineConfig({
  // Nitro options
});
import { defineConfig } from "vite";
import { nitro } from "nitro/vite";

export default defineConfig({
  plugins: [nitro()],
  nitro: {
    // Nitro options
  },
});

v3 renamed the package nitropack → nitro and defineNitroConfig → defineConfig.

Environment overrides & extending
export default defineConfig({
  logLevel: 3,
  $development: { debug: true },   // only during `nitro dev`
  $production: { minify: true },   // only during `nitro build`
  extends: "./base.config",        // inherit from another config/preset
});

Config can also live under .config/nitro.ts or in a .nitrorc (key=value) file.

v3: auto-imports are removed and the imports option is gone — add explicit imports everywhere (nitro, nitro/kv, nitro/cache, nitro/runtime-config, ...). Directory scanning is opt-in via serverDir (see below).

Server directory scanning is opt-in

serverDir defaults to false — no routes/, api/, middleware/, plugins/, tasks/, etc. are scanned until you set it. srcDir is deprecated.

export default defineConfig({
  serverDir: "./server", // or "." for the v2 root layout; true = "server"
});

Key options

OptionPurpose
preset / defaultPresetDeployment target (or NITRO_PRESET / --preset); defaultPreset is the fallback.
compatibilityDateLock preset runtime behavior to a YYYY-MM-DD date.
runtimeConfigRuntime values overridable via NITRO_* env vars.
kvunstorage mounts (v2 storage). Override in dev/prerender via $development.kv / $prerender.kv.
database / devDatabaseDB connections (requires experimental.database).
routeRulesPer-route caching, headers, redirects, proxy, CORS.
serverDirScan dir (default false). "./" or "./server"; scanDirs adds more.
serverEntry / rendererCatch-all fetch handler / catch-all renderer.
errorHandler / devErrorHandlerCustom error handler path(s) / dev-only handler fn.
featuresBuilt-in features (websocket, runtimeHooks).
experimentalOpt-in features (tasks, database, openAPI, asyncContext, envExpansion).
prerender{ routes, crawlLinks, failOnError, concurrency, autoSubfolderIndex }.
minify, sourcemap, inlineDynamicImportsBuild output tuning.
builder"rollup" | "rolldown" | "vite" (auto-detected; or NITRO_BUILDER).
output{ dir, serverDir, publicDir } (defaults under .output/).
Directory defaults
OptionDefault
rootDir.
serverDirfalse
buildDirnode_modules/.nitro
output.dir.output
apiDir / routesDirapi / routes

Runtime config

Define defaults in config; override at runtime with NITRO_-prefixed env vars. Only keys declared in runtimeConfig can be overridden — env vars cannot introduce new keys.

import { defineConfig } from "nitro";

export default defineConfig({
  runtimeConfig: {
    apiToken: "dev_token",
    database: { host: "localhost", port: 5432 },
  },
});

Access it (note the dedicated subpath import):

import { defineHandler } from "nitro";
import { useRuntimeConfig } from "nitro/runtime-config";

export default defineHandler((event) => {
  return useRuntimeConfig().apiToken;
});

Env var mapping uses NITRO_ + UPPER_SNAKE_CASE, nested keys joined by _:

NITRO_API_TOKEN="123"
NITRO_DATABASE_HOST="db.example.com"
NITRO_DATABASE_PORT="5433"
  • .env / .env.local are loaded when Nitro resolves config (both nitro dev and nitro build), so nitro.config.ts can read them; they are not loaded by the built server at runtime — in production use the platform's env vars.

  • Values must be serializable; undefined/null fall back to "".

  • Add a secondary prefix via runtimeConfig.nitro.envPrefix: "APP_" (checked alongside NITRO_). With no custom prefix, the default secondary prefix is _ (e.g. _API_TOKEN also overrides apiToken).

  • Enable experimental.envExpansion to expand {{VAR}} references inside runtime config strings.

Environment variables (built-in)

VariableEffect
NITRO_PRESETOverride deployment preset.
NITRO_COMPATIBILITY_DATESet compatibility date.
NITRO_APP_BASE_URLOverride base URL (default /).
NITRO_BUILDERSelect the bundler (rollup / rolldown / vite).
NITRO_ENV_PREFIXSecondary prefix for runtime-config overrides (default _).
NITRO_ENV_EXPANSIONEnable env expansion in runtime config values.

Key Points

  • defineConfig from nitro is the v3 entry point; with Vite, options go under the nitro key.

  • Auto-imports are removed — import every utility explicitly. Set serverDir or nothing is scanned.

  • Use useRuntimeConfig() from nitro/runtime-config for env-overridable values; never read process.env in module top-level (edge runtimes only expose env during requests).

  • experimental.* flags gate tasks, database, and openAPI.

  • Types are imported from nitro/types (e.g. NitroRuntimeConfig), not nitro.

<!-- Source references: - https://nitro.build/docs/configuration - https://nitro.build/config -->

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
Anthony Fu
Publisher
Anthony Fu (Community)
Source
antfu/skills · skills/nitro · commit f63e9ec
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE.md)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Anthony Fu.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download nitro.zip