micro

OverviewHistoryStatsSecurity

npx skills add openai/plugins --skill micro

Documentation

SKILL.md

npx skills add ...

Documentation

SKILL.md

Expert guidance for micro — asynchronous HTTP microservices framework by Vercel. Use when building lightweight HTTP servers, API endpoints, or microservices using the micro library.

npx skills add openai/plugins --skill micro

Documentation

SKILL.mdView source

micro — Asynchronous HTTP Microservices

You are an expert in micro, Vercel's lightweight framework for building asynchronous HTTP microservices in Node.js. micro makes it easy to write single-purpose HTTP endpoints with minimal boilerplate.

Installation

npm install micro

Basic Usage

Create a module that exports a request handler:

// index.ts
import { serve } from 'micro'
 
const handler = (req: Request) => {
  return new Response('Hello, World!')
}
 
serve(handler)

Or use the classic API:

import { IncomingMessage, ServerResponse } from 'http'
 
export default (req: IncomingMessage, res: ServerResponse) => {
  res.end('Hello, World!')
}

Run with:

npx micro

Core API

`json(req)` — Parse JSON Body

import { json } from 'micro'
 
export default async (req: IncomingMessage, res: ServerResponse) => {
  const body = await json(req)
  return { received: body }
}

`text(req)` — Parse Text Body

import { text } from 'micro'
 
export default async (req: IncomingMessage, res: ServerResponse) => {
  const body = await text(req)
  return `You said: ${body}`
}

`buffer(req)` — Parse Raw Body

import { buffer } from 'micro'
 
export default async (req: IncomingMessage, res: ServerResponse) => {
  const raw = await buffer(req)
  return `Received ${raw.length} bytes`
}

`send(res, statusCode, data)` — Send Response

import { send } from 'micro'
 
export default (req: IncomingMessage, res: ServerResponse) => {
  send(res, 200, { status: 'ok' })
}

`createError(statusCode, message)` — HTTP Errors

import { createError } from 'micro'
 
export default (req: IncomingMessage, res: ServerResponse) => {
  if (!req.headers.authorization) {
    throw createError(401, 'Unauthorized')
  }
  return { authorized: true }
}

Development with micro-dev

micro-dev provides hot-reloading for development:

npm install --save-dev micro-dev
 
# Run in dev mode
npx micro-dev index.js

Composition

Chain multiple handlers with function composition:

import { IncomingMessage, ServerResponse } from 'http'
 
const cors = (fn: Function) => async (req: IncomingMessage, res: ServerResponse) => {
  res.setHeader('Access-Control-Allow-Origin', '*')
  return fn(req, res)
}
 
const handler = async (req: IncomingMessage, res: ServerResponse) => {
  return { hello: 'world' }
}
 
export default cors(handler)

package.json Setup

{
  "main": "index.js",
  "scripts": {
    "start": "micro",
    "dev": "micro-dev"
  },
  "dependencies": {
    "micro": "^10.0.0"
  },
  "devDependencies": {
    "micro-dev": "^3.0.0"
  }
}

Key Points

Return values are sent as responses — return strings, objects (auto-serialized to JSON), or Buffers
Async by default — handlers can be async functions, errors are caught automatically
Thrown errors become HTTP errors — use createError() for proper status codes
No routing built-in — micro is a single-endpoint server; use a router like micro-router for multi-route services
Body parsing is explicit — use json(), text(), or buffer() to parse request bodies
Composable — wrap handlers with higher-order functions for middleware-like behavior

Official Resources

micro GitHub

npx skills add openai/plugins --skill micro

Documentation

SKILL.md

Expert guidance for micro — asynchronous HTTP microservices framework by Vercel. Use when building lightweight HTTP servers, API endpoints, or microservices using the micro library.

npx skills add openai/plugins --skill micro

Documentation

SKILL.mdView source

micro — Asynchronous HTTP Microservices

Installation

npm install micro

Basic Usage

Create a module that exports a request handler:

// index.ts
import { serve } from 'micro'
 
const handler = (req: Request) => {
  return new Response('Hello, World!')
}
 
serve(handler)

Or use the classic API:

import { IncomingMessage, ServerResponse } from 'http'
 
export default (req: IncomingMessage, res: ServerResponse) => {
  res.end('Hello, World!')
}

Run with:

npx micro

Core API

`json(req)` — Parse JSON Body

import { json } from 'micro'
 
export default async (req: IncomingMessage, res: ServerResponse) => {
  const body = await json(req)
  return { received: body }
}

`text(req)` — Parse Text Body

import { text } from 'micro'
 
export default async (req: IncomingMessage, res: ServerResponse) => {
  const body = await text(req)
  return `You said: ${body}`
}

`buffer(req)` — Parse Raw Body

import { buffer } from 'micro'
 
export default async (req: IncomingMessage, res: ServerResponse) => {
  const raw = await buffer(req)
  return `Received ${raw.length} bytes`
}

`send(res, statusCode, data)` — Send Response

import { send } from 'micro'
 
export default (req: IncomingMessage, res: ServerResponse) => {
  send(res, 200, { status: 'ok' })
}

`createError(statusCode, message)` — HTTP Errors

import { createError } from 'micro'
 
export default (req: IncomingMessage, res: ServerResponse) => {
  if (!req.headers.authorization) {
    throw createError(401, 'Unauthorized')
  }
  return { authorized: true }
}

Development with micro-dev

micro-dev provides hot-reloading for development:

npm install --save-dev micro-dev
 
# Run in dev mode
npx micro-dev index.js

Composition

Chain multiple handlers with function composition:

import { IncomingMessage, ServerResponse } from 'http'
 
const cors = (fn: Function) => async (req: IncomingMessage, res: ServerResponse) => {
  res.setHeader('Access-Control-Allow-Origin', '*')
  return fn(req, res)
}
 
const handler = async (req: IncomingMessage, res: ServerResponse) => {
  return { hello: 'world' }
}
 
export default cors(handler)

package.json Setup

{
  "main": "index.js",
  "scripts": {
    "start": "micro",
    "dev": "micro-dev"
  },
  "dependencies": {
    "micro": "^10.0.0"
  },
  "devDependencies": {
    "micro-dev": "^3.0.0"
  }
}

Key Points

Return values are sent as responses — return strings, objects (auto-serialized to JSON), or Buffers
Async by default — handlers can be async functions, errors are caught automatically
Thrown errors become HTTP errors — use createError() for proper status codes
No routing built-in — micro is a single-endpoint server; use a router like micro-router for multi-route services
Body parsing is explicit — use json(), text(), or buffer() to parse request bodies
Composable — wrap handlers with higher-order functions for middleware-like behavior

Official Resources

micro GitHub

micro

Documentation

Documentation

micro

Documentation

micro — Asynchronous HTTP Microservices

Installation

Basic Usage

Core API

json(req) — Parse JSON Body

text(req) — Parse Text Body

buffer(req) — Parse Raw Body

send(res, statusCode, data) — Send Response

createError(statusCode, message) — HTTP Errors

Development with micro-dev

Composition

package.json Setup

Key Points

Official Resources

Documentation

Documentation

micro — Asynchronous HTTP Microservices

Installation

Basic Usage

Core API

json(req) — Parse JSON Body

text(req) — Parse Text Body

buffer(req) — Parse Raw Body

send(res, statusCode, data) — Send Response

createError(statusCode, message) — HTTP Errors

Development with micro-dev

Composition

package.json Setup

Key Points

Official Resources

`json(req)` — Parse JSON Body

`text(req)` — Parse Text Body

`buffer(req)` — Parse Raw Body

`send(res, statusCode, data)` — Send Response

`createError(statusCode, message)` — HTTP Errors

`json(req)` — Parse JSON Body

`text(req)` — Parse Text Body

`buffer(req)` — Parse Raw Body

`send(res, statusCode, data)` — Send Response

`createError(statusCode, message)` — HTTP Errors