---
title: 'Using the CLI'
description: 'How to start a bknd instance using the CLI.'
---

The bknd package includes a command-line interface (CLI) that allows you to run a bknd instance and perform various tasks.

```
npx bknd
```

Here is the output:
```
$ npx bknd
Usage: bknd [options] [command]

⚡ bknd cli v0.13.0

Options:
  -V, --version          output the version number
  -h, --help             display help for command

Commands:
  user <action>          create/update users, or generate a token (auth)
  types [options]        generate types
  schema [options]       get schema
  run [options]          run an instance
  debug <subject>        debug bknd
  create [options]       create a new project
  copy-assets [options]  copy static assets
  config [options]       get default config
  help [command]         display help for command
```

## Starting an instance (`run`)
To see all available `run` options, execute `npx bknd run --help`.

```
$ npx bknd run --help
Usage: bknd run [options]

Options:
  -p, --port <port>      port to run on (default: 1337, env: PORT)
  -m, --memory           use in-memory database
  -c, --config <config>  config file
  --db-url <db>          database url, can be any valid libsql url
  --db-token <db>        database token
  --server <server>      server type (choices: "node", "bun", default: "bun")
  --no-open              don't open browser window on start
  -h, --help             display help for command
```

To order in which the connection is determined is as follows:
1. `--db-url`
2. `--config` or reading the filesystem looking for `bknd.config.[js|ts|mjs|cjs|json]`
3. `--memory`
4. Environment variables `DB_URL` and `DB_TOKEN` in `.env` or `.dev.vars`
5. Fallback to file-based database `data.db`

### File-based database
By default, a file-based database `data.db` is used when running without any arguments. You can specify a different file name or path using the `--db-url` option. The database file will be created in the current working directory if it does not exist.

```
npx bknd run --db-url file:data.db
```

### Using configuration file (`bknd.config.*`)
You can create a configuration file on the working directory that automatically gets picked up: `bknd.config.[js|ts|mjs|cjs|json]`

Here is an example of a `bknd.config.ts` file:

```ts
import type { BkndConfig } from "bknd/adapter";

export default {
   // you can either specify the connection directly
   connection: {
      url: "file:data.db",
   },
   // or use the `app` function which passes the environment variables
   app: ({ env }) => ({
      connection: {
         url: env.DB_URL,
      }
   })
} satisfies BkndConfig;
```
The `app` function is useful if you need a cross-platform way to access the environment variables. For example, on Cloudflare Workers, you can only access environment variables inside a request handler. If you're exclusively using a node-like environment, it's safe to access the environment variables directly from `process.env`.


If you're using `npx bknd run`, make sure to create a file in a file format that `node` can load, otherwise you may run into an error that the file couldn't be found:

```sh
[INF] 2025-03-28 18:02:21 Using config from bknd.config.ts
[ERR] 2025-03-28 18:02:21 Failed to load config: Error [ERR_MODULE_NOT_FOUND]: Cannot find package 'bknd.config.ts' imported from [...]
    at packageResolve (node:internal/modules/esm/resolve:857:9)
    at [...] {
  code: 'ERR_MODULE_NOT_FOUND'
}
```

If you still want to use a `.ts` extension, you can start the CLI e.g. using `node` (>=v22.6.0):

```sh
node --experimental-strip-types node_modules/.bin/bknd run
```

Or with `tsx`:

```sh
npx tsx node_modules/.bin/bknd run
```

### Turso/LibSQL database
To start an instance with a Turso/LibSQL database, run the following:
```
npx bknd run --db-url libsql://your-db.turso.io --db-token <your-token>
```
The `--db-token` option is optional and only required if the database is protected.


### In-memory database
To start an instance with an ephemeral in-memory database, run the following:
```
npx bknd run --memory
```
Keep in mind that the database is not persisted and will be lost when the process is terminated.

## Generating types (`types`)
To see all available `types` options, execute `npx bknd types --help`.

```
$ npx bknd types --help
Usage: bknd types [options]

generate types

Options:
  -o, --outfile <outfile>  output file (default: "bknd-types.d.ts")
  --no-write               do not write to file
  -h, --help               display help for command
```

To generate types for the database, run the following:
```
npx bknd types
```

This will generate types for your database schema in `bknd-types.d.ts`. The generated file could look like this:

```typescript bknd-types.d.ts
import type { DB } from "bknd/core";
import type { Insertable, Selectable, Updateable, Generated } from "kysely";

declare global {
  type BkndEntity<T extends keyof DB> = Selectable<DB[T]>;
  type BkndEntityCreate<T extends keyof DB> = Insertable<DB[T]>;
  type BkndEntityUpdate<T extends keyof DB> = Updateable<DB[T]>;
}

export interface Todos {
  id: Generated<number>;
  title?: string;
  done?: boolean;
}

interface Database {
  todos: Todos;
}

declare module "bknd/core" {
  interface DB extends Database {}
}
```

Make sure to add the generated file in your `tsconfig.json` file:

```json tsconfig.json
{
   "include": [
      "bknd-types.d.ts"
   ]
}
```

You can then use the types by importing them from `bknd/core`:

```typescript
import type { DB } from "bknd/core";

type Todo = DB["todos"];
```

All bknd methods that involve your database schema will be automatically typed.