# Hono (/docs/guides/frameworks/hono)

> For the complete Prisma documentation index, see [llms.txt](https://www.prisma.io/docs/llms.txt). A markdown version of any docs page is available by appending `.md` to its URL.

Build a Hono API on Prisma 8 with the hono template, add your own routes, and deploy it to Prisma Compute.

Location: Guides > Frameworks > Hono

## Introduction [#introduction]

In this guide, you scaffold a Hono API backed by Prisma 8, initialize and seed a PostgreSQL database, serve data over HTTP, add your own POST route, and deploy the API to [Prisma Compute](https://www.prisma.io/docs/compute). The `hono` template generates the server for you, so most of the work is understanding the pieces and extending them.

Every command, route, and response below was run end to end against a live Prisma Postgres database.

## Prerequisites [#prerequisites]

* [Node.js](https://nodejs.org) 24 or later, or [Bun](https://bun.sh/) (this guide uses Bun for speed; npm works the same)
* A PostgreSQL connection string, or nothing at all: the scaffold can create a [Prisma Postgres](https://www.prisma.io/docs/postgres) database for you

## Use with your agent [#use-with-your-agent]

To delegate this guide to your coding agent, copy the prompt below and hand it over:

```text
Create a new Hono API with Prisma 8, seed it, and deploy it to Prisma Compute.

1. Scaffold: `npx create-prisma@latest create my-hono-api --template hono --provider postgres --yes`. Then run `npx prisma@latest init` in `my-hono-api` so the Prisma agent skills are installed and stay current, and use them. Get a database connection string: use the one I give you, or create a Prisma Postgres database with `npx create-db@latest` and show me the claim URL it prints. Export it as `DATABASE_URL` in the shell; the generated scripts read the environment variable, not `.env`.
2. In `my-hono-api`, run `npm run db:init` with `DATABASE_URL` exported. Sample users are seeded automatically on the app's first query; there is no separate seed script.
3. Start `npm run dev` in the background, wait until it reports ready, verify `curl http://localhost:3000/users` returns the seeded users, then stop the dev server.
4. Add a POST /users route that creates a user from the request body, following https://www.prisma.io/docs/guides/frameworks/hono.md, restart the dev server, and verify it with curl.
5. Deploy: check `npx prisma@latest auth whoami`; if I am not signed in, stop and ask me to run `npx prisma@latest auth login`. Then run `npm run build` followed by `npx prisma@latest deploy module.ts` and verify the live URL's /users endpoint. The deployed app provisions and seeds its own Prisma Postgres database; do not pass the local DATABASE_URL. If the deploy fails with `HostedStateBootstrapError`, a project with the module's name exists in my workspace but its hosted state cannot be verified; re-run the deploy with `--name <a unique name>`.
```

## 1. Scaffold the project [#1-scaffold-the-project]

```bash
bunx create-prisma@latest create my-hono-api --template hono --provider postgres
```

Pick your contract authoring style and package manager at the prompts. The template generates a Hono server in `src/index.ts` with two routes (`GET /` and `GET /users`), the Prisma 8 setup in `src/prisma/`, and package scripts for the database steps.

```bash
cd my-hono-api
```

Next, set the database connection for the local steps. Use your own PostgreSQL connection string, or create a Prisma Postgres database with `npx create-db@latest`; it prints a connection string and a claim URL you can open to keep the database. Export the variable in the shell you work in; the generated scripts read the environment variable, not `.env`:

```bash
export DATABASE_URL="<your connection string>"
```

## 2. Initialize the database [#2-initialize-the-database]

```bash
bun run db:init
```

```text no-copy
"summary": "Applied 5 operation(s) across 1 space(s), database signed"
```

If `db:init` stops with `Connection terminated unexpectedly`, a database you just created is still starting; wait a few seconds and run it again. The command is safe to repeat and reports `Applied 0 operation(s)` when there is nothing left to do.

## 3. Run the server [#3-run-the-server]

```bash
bun run dev
```

The server starts on port 3000 (set `PORT` to change it). Check both routes:

```bash
curl http://localhost:3000/users
```

```json no-copy
[
  { "id": "1", "email": "alice@prisma.io", "username": "alice", "name": "Alice", "createdAt": "2026-07-06T23:37:32.440Z" },
  { "id": "2", "email": "bob@prisma.io", "username": "bob", "name": "Bob", "createdAt": "2026-07-06T23:37:32.474Z" },
  { "id": "3", "email": "carol@prisma.io", "username": "carol", "name": "Carol", "createdAt": "2026-07-06T23:37:32.507Z" }
]
```

The route handler is ordinary Hono code calling an ordinary Prisma 8 query; there is no framework adapter in between.

## 4. Add a POST route [#4-add-a-post-route]

Add a route that creates a user from the request body. Add this to `src/index.ts` above the `serve(...)` call:

```ts title="src/index.ts"
app.post("/users", async (c) => {
  const body = await c.req.json<{ email: string; name?: string }>();
  const { db } = await import("./prisma/db");
  const user = await db.orm.public.User.create({
    email: body.email,
    name: body.name ?? null,
  });
  return c.json(user, 201);
});
```

Restart the server and create a user:

```bash
curl -X POST http://localhost:3000/users \
  -H "content-type: application/json" \
  -d '{"email":"dev@prisma.io","name":"Dev"}'
```

```json no-copy
{ "createdAt": "2026-07-06T23:37:56.184Z", "email": "dev@prisma.io", "id": 4, "name": "Dev", "username": null }
```

`.create(...)` returns the full inserted record, database defaults included, so the response needs no second query.

## 5. Deploy to Prisma Compute [#5-deploy-to-prisma-compute]

Hono is supported on [Prisma Compute](https://www.prisma.io/docs/compute). The scaffold already declares the app for [Prisma Composer](https://www.prisma.io/docs/composer) in `module.ts` and `service.ts`, so deploying is building and handing that declaration to the CLI. Sign in once (it opens a browser):

  

#### bun

```bash
bunx prisma@latest auth login
```

#### pnpm

```bash
pnpm dlx prisma@latest auth login
```

#### yarn

```bash
yarn dlx prisma@latest auth login
```

#### npm

```bash
npx prisma@latest auth login
```

Then build and deploy from the project directory:

  

#### bun

```bash
bun run build
bunx prisma@latest deploy module.ts
```

#### pnpm

```bash
pnpm run build
pnpm dlx prisma@latest deploy module.ts
```

#### yarn

```bash
yarn build
yarn dlx prisma@latest deploy module.ts
```

#### npm

```bash
npm run build
npx prisma@latest deploy module.ts
```

```text no-copy
my-hono-api
├─ database   postgres-database db_abc123
└─ app        compute-service cps_abc123
              https://xyz.ewr.prisma.build
```

The deploy creates a project named after your module in your workspace, and re-running the deploy reuses it: the CLI finds the hosted state it stored on the first run and converges the project to your module. If a project with that name exists but the CLI cannot identify or verify its stored state (one left behind by a different checkout, for example), the deploy stops with `HostedStateBootstrapError`; deploy under another name with `--name <unique-name>`, or rename the module in `module.ts`. The deploy also provisions its own Prisma Postgres database on the platform, declared in `module.ts`; the `DATABASE_URL` from your local steps is not involved. Verify the live endpoint returns the seeded users (the deployed database seeds on its first query):

```bash
curl https://xyz.ewr.prisma.build/users
```

For previews per Git branch and deploy-on-push, see [Deploy your first app](https://www.prisma.io/docs/prisma-compute/deploy).

## Common gotchas [#common-gotchas]

> [!WARNING]
> In a long-running server, don't call `db.runtime().close()` in route handlers; the client's connection pool is shared across requests. Close it only on process shutdown.

## Prompt your coding agent [#prompt-your-coding-agent]

Run [`npx prisma@latest init`](https://www.prisma.io/docs/cli/init) once to install the [Prisma 8 skills](https://www.prisma.io/docs/ai/tools/skills#available-skills-for-prisma-8) for your coding agent and keep them matching your installed packages. Prompts that map to this guide:

* "Using the prisma-8 skill, add GET /users/:id that returns one user or a 404."
* "Expose GET /users/:id/posts using the Post model that ships with the starter contract."
* "Wrap the signup route's writes in a [transaction](https://www.prisma.io/docs/orm/fundamentals/transactions)."

## Next steps [#next-steps]

* [Learn the fundamentals](https://www.prisma.io/docs/orm/fundamentals/reading-data): filtering, sorting, pagination, and writes.
* [Read the Prisma 8 overview](https://www.prisma.io/docs/orm) for the concepts behind contracts and typed queries.

## Related pages

- [`Astro`](https://www.prisma.io/docs/guides/frameworks/astro): Set up Prisma 8 in an Astro app with create-prisma, from scaffold to rendered data, and deploy it to Prisma Compute.
- [`Elysia`](https://www.prisma.io/docs/guides/frameworks/elysia): Build an Elysia API on Prisma 8 with the elysia template and deploy it to Prisma Compute.
- [`NestJS`](https://www.prisma.io/docs/guides/frameworks/nestjs): Set up Prisma 8 in a NestJS app with create-prisma, from scaffold to seeded API to a live deploy on Prisma Compute.
- [`Next.js`](https://www.prisma.io/docs/guides/frameworks/nextjs): Set up Prisma 8 in a Next.js app with create-prisma, from scaffold to rendered data, and deploy it to Prisma Compute.
- [`Nuxt`](https://www.prisma.io/docs/guides/frameworks/nuxt): Set up Prisma 8 in a Nuxt app with create-prisma, from scaffold to rendered data, and deploy it to Prisma Compute.