> For AI agents: the complete documentation index is available at https://dotpress.dev/llms.txt, the full documentation bundle is available at https://dotpress.dev/llms-full.txt.

# Hono

`@dotpress/adapter-hono` runs your app on [Hono](https://hono.dev) 4.13 or later, on Node.js and [AWS Lambda](https://dotpress.dev/adapters/aws-lambda.md). Hono 5 is tested against its release candidate.

## On Node.js


```sh [npm]
npm install @dotpress/core @dotpress/adapter-hono hono @hono/node-server zod
```

```sh [yarn]
yarn add @dotpress/core @dotpress/adapter-hono hono @hono/node-server zod
```

```sh [pnpm]
pnpm add @dotpress/core @dotpress/adapter-hono hono @hono/node-server zod
```

```sh [bun]
bun add @dotpress/core @dotpress/adapter-hono hono @hono/node-server zod
```

```sh [deno]
deno add npm:@dotpress/core npm:@dotpress/adapter-hono npm:hono npm:@hono/node-server npm:zod
```

```ts
import { createApp, defineRoute } from '@dotpress/core'
import { honoAdapter } from '@dotpress/adapter-hono/node'

defineRoute({ path: '/hello', handler: () => ({ message: 'Hello' }) })

const app = await createApp({ adapter: honoAdapter() })
await app.listen(3000)
```

The `@dotpress/adapter-hono/node` entry serves the app with [`@hono/node-server`](https://github.com/honojs/node-server). The main entry, `@dotpress/adapter-hono`, has no Node.js server: it is the one to use on AWS Lambda, where the bundle stays small.

## Options

| Option              | Description                                                                                                        |
| ------------------- | ------------------------------------------------------------------------------------------------------------------ |
| `app`               | An existing Hono application. `new Hono()` by default.                                                             |
| `beforeRoutes(app)` | Registers native middlewares and routes before the Dotpress routes.                                                |
| `afterRoutes(app)`  | Registers native middlewares and routes after the Dotpress routes, before the not-found handler.                   |
| `bodyLimit`         | Maximum request body size, in bytes. 1 MiB by default.                                                             |
| `getIp(c)`          | The client IP address (`ctx.req.ip`). By default, the address given by the runtime: the socket address on Node.js. |

## Hono middlewares

The [Hono example](https://dotpress.dev/examples/hono.md) shares its adapter options between Node.js and AWS Lambda, with a native middleware and a native route:

```ts file="<root>/../examples/hono/src/app.ts"
import type { HonoAdapterOptions } from '@dotpress/adapter-hono'
import { createApp, type HttpAdapter, type Logger } from '@dotpress/core'
import type { Hono } from 'hono'
import { secureHeaders } from 'hono/secure-headers'
import { createNoteStore } from './notes.ts'
import { notesRouter } from './routes.ts'

/** Options of the Hono adapter, the same on Node.js and AWS Lambda. */
export const honoOptions: HonoAdapterOptions<Hono> = {
  // Native Hono middlewares and routes, before the Dotpress routes.
  beforeRoutes: (app) => {
    app.use('*', secureHeaders())
    app.get('/health', (c) => c.json({ status: 'ok' }))
  },
}

/**
 * Creates the app on a Hono adapter: `honoAdapter()` of
 * `@dotpress/adapter-hono/node` in `node.ts`, of `@dotpress/adapter-hono`
 * in `lambda.ts` and the tests.
 */
export const createNotesApp = <TAdapter extends HttpAdapter>(
  adapter: TAdapter,
  options: { logger?: Logger } = {}
) =>
  createApp({
    adapter,
    ...(options.logger && { logger: options.logger }),
    routers: [notesRouter(createNoteStore())],
  })

```

```ts file="<root>/../examples/hono/src/node.ts"
// The Node.js entry: @hono/node-server serves the app.
import { honoAdapter } from '@dotpress/adapter-hono/node'
import { createNotesApp, honoOptions } from './app.ts'

const port = Number(process.env.PORT ?? 3000)

const app = await createNotesApp(honoAdapter(honoOptions))
await app.listen(port)
console.log(`Notes API: http://localhost:${port}/notes`)

// Waits for pending requests, then runs the onClose hooks of the plugins.
for (const signal of ['SIGINT', 'SIGTERM'] as const) {
  process.once(signal, () => void app.close())
}

```

## Behavior

- **Routes are matched by Dotpress**, with the same rules on every adapter: Hono options such as `strict` do not apply. Use the `basePath` option of `createApp()` rather than `app.basePath()`.
- **Bodies are read by the adapter**: JSON, forms, text and multipart uploads. A body already read by a native middleware through Hono (`c.req.json()`, `c.req.parseBody()`…) is taken from its cache. Routes declared with `rawBody: true` need the exact bytes: let the adapter read the body, or read it with `c.req.arrayBuffer()` or `c.req.blob()` in a native middleware.
- **`HTTPException` client errors** (`4xx`) thrown by native middlewares use the Dotpress error format and keep their status, message and headers (the `WWW-Authenticate` header of `bearerAuth()`…). Other errors are unexpected (`500`). The adapter takes over `app.notFound()` and `app.onError()`.
- **`ctx.req.ip`** does not read proxy headers such as `X-Forwarded-For`: behind a proxy, read them in `getIp(c)`, and only trust the proxies you run.
- **`ctx.raw`** is the Hono context.
- **`close()`** waits for pending requests and closes the responses being streamed; `adapter.server()` returns the Node.js HTTP server.

## Other runtimes

The main entry only relies on Hono and Web-standard APIs. `adapter.fetch` handles a Web `Request`, like `app.fetch` in Hono, for runtimes that take a `fetch` handler:

```ts
import { honoAdapter } from '@dotpress/adapter-hono'

const adapter = honoAdapter()
await createApp({ adapter, routers })

export default { fetch: adapter.fetch }
```

:::warning
Dotpress 2.0 is tested on Node.js and AWS Lambda only: other runtimes (Bun, Deno, edge runtimes) are not officially supported yet. See [the design decision](https://dotpress.dev/reference/design-decisions/edge.md).
:::

## On AWS Lambda

The same app runs on AWS Lambda with `createLambdaHandler()` of `@dotpress/adapter-hono/lambda`: see [AWS Lambda](https://dotpress.dev/adapters/aws-lambda.md).