Accelerate does not work with a local database. However, in a development environment, you can still use Prisma Client with the Accelerate client extension. This setup will not provide Accelerate's connection pooling and caching features.
The following steps outline how to use Prisma ORM and Prisma Accelerate with a local PostgreSQL database.
1. Update the `DATABASE_URL` environment variable with your local database's connection string:
```bash
DATABASE_URL="postgres://username:password@127.0.0.1:5432/localdb"
```
2. Generate a Prisma Client:
#### bun
```bash
bunx prisma generate
```
#### pnpm
```bash
pnpm dlx prisma generate
```
#### yarn
```bash
yarn dlx prisma generate
```
#### npm
```bash
npx prisma generate
```
3. Set up Prisma Client with the Accelerate client extension:
```typescript
import { PrismaClient } from "@prisma/client";
import { withAccelerate } from "@prisma/extension-accelerate";
const prisma = new PrismaClient().$extends(withAccelerate());
```
> The extended instance of Prisma Client will use the local database. Hence, Prisma Accelerate will not be used in your development environment to respond to your Prisma Client queries.
If an Accelerate connection string is used as the `DATABASE_URL` environment variable, Prisma Client will route your queries through Accelerate.
Using Prisma Accelerate locally in an edge function [#using-prisma-accelerate-locally-in-an-edge-function]
When using an edge function, e.g., [Vercel's edge runtime](https://vercel.com/docs/functions/runtimes/edge-runtime), for your development environment, update your Prisma Client import as follows:
```typescript
import { PrismaClient } from "@prisma/client/edge";
```
Generally, edge function environments lack native support for existing APIs enabling TCP-based database connections. Prisma Accelerate provides a connection string that allows querying your database over HTTP, a protocol supported in all edge runtimes.
## Related pages
- [`Caching queries`](https://www.prisma.io/docs/accelerate/caching): Learn everything you need to know to use Accelerate's global database caching
- [`Compare Accelerate`](https://www.prisma.io/docs/accelerate/compare): Learn how Prisma Accelerate compares to other connection poolers like pgbouncer
- [`Connection Pooling`](https://www.prisma.io/docs/accelerate/connection-pooling): Learn about everything you need to know to use Accelerate's connection pooling
- [`Evaluating`](https://www.prisma.io/docs/accelerate/evaluating): Learn about evaluating Prisma Accelerate
- [`Examples`](https://www.prisma.io/docs/accelerate/examples): Check out ready-to-run examples for Prisma Accelerate
# Static IP (/docs/accelerate/static-ip)
Location: Accelerate > Static IP
You can enable static IP for Accelerate when your security setup requires IP allowlisting or if you're implementing firewalls that only permit access from trusted IPs, ensuring controlled and secure database connections.
> [!NOTE]
> To enable static IP support for Accelerate within an existing or a new project environment, your workspace will need to be on our Pro or Business plans. Take a look at the [pricing page](https://www.prisma.io/pricing#accelerate) for more information.
Enable static IP in Accelerate [#enable-static-ip-in-accelerate]
You can opt-in to use static IP for Accelerate in the [Platform Console](https://pris.ly/pdp) in two ways:
1. When enabling Accelerate for your project environment: [#1-when-enabling-accelerate-for-your-project-environment]
1. Specify your database connection string and connection pool region.
2. Enable static IP by toggling the **Static IP** switch in the **Network restrictions** section.
3. Click on the **Enable Accelerate** button.
2. For projects already using Accelerate: [#2-for-projects-already-using-accelerate]
1. Navigate to the Accelerate **Settings** tab in the project environment.
2. Enable static IP by toggling the **Static IP** switch in the **Network restrictions** section.
Enabling static IP for Accelerate will provide you with a list of static IPv4 and IPv6 addresses.
Once you have these addresses, configure your database firewall to allow incoming connections only from these IPs and any other trusted IPs that need access to your database.
> [!NOTE]
> Since you cannot enable static IP for an existing Accelerate-enabled environment, we recommend opting for static IP when enabling Accelerate in a new environment. Use the same database URL as your existing Accelerate environment to instantly access static IP support for Accelerate.
## Related pages
- [`Caching queries`](https://www.prisma.io/docs/accelerate/caching): Learn everything you need to know to use Accelerate's global database caching
- [`Compare Accelerate`](https://www.prisma.io/docs/accelerate/compare): Learn how Prisma Accelerate compares to other connection poolers like pgbouncer
- [`Connection Pooling`](https://www.prisma.io/docs/accelerate/connection-pooling): Learn about everything you need to know to use Accelerate's connection pooling
- [`Evaluating`](https://www.prisma.io/docs/accelerate/evaluating): Learn about evaluating Prisma Accelerate
- [`Examples`](https://www.prisma.io/docs/accelerate/examples): Check out ready-to-run examples for Prisma Accelerate
# debug (/docs/cli/debug)
Location: CLI > debug
The `prisma debug` command prints information helpful for debugging and bug reports.
> [!NOTE]
> Available from version 5.6.0 and newer.
Usage [#usage]
```bash
prisma debug [options]
```
Options [#options]
| Option | Description |
| -------------- | -------------------------------------- |
| `-h`, `--help` | Display help message |
| `--config` | Custom path to your Prisma config file |
| `--schema` | Custom path to your Prisma schema |
Examples [#examples]
Display debug information [#display-debug-information]
#### bun
```bash
bunx prisma debug
```
#### pnpm
```bash
pnpm dlx prisma debug
```
#### yarn
```bash
yarn dlx prisma debug
```
#### npm
```bash
npx prisma debug
```
Output:
```text
-- Prisma schema --
Path: /prisma/schema.prisma
-- Local cache directory for engines files --
Path: /.cache/prisma
-- Environment variables --
When not set, the line is dimmed and no value is displayed.
When set, the line is bold and the value is inside the `` backticks.
For general debugging
- CI:
- DEBUG:
- NODE_ENV:
- RUST_LOG:
- RUST_BACKTRACE:
- NO_COLOR:
- TERM: `xterm-256color`
- NODE_TLS_REJECT_UNAUTHORIZED:
- NO_PROXY:
- http_proxy:
- HTTP_PROXY:
- https_proxy:
- HTTPS_PROXY:
For hiding messages
- PRISMA_DISABLE_WARNINGS:
- PRISMA_HIDE_PREVIEW_FLAG_WARNINGS:
- PRISMA_HIDE_UPDATE_MESSAGE:
For downloading engines
- PRISMA_ENGINES_MIRROR:
- PRISMA_BINARIES_MIRROR (deprecated):
- PRISMA_ENGINES_CHECKSUM_IGNORE_MISSING:
- BINARY_DOWNLOAD_VERSION:
For custom engines
- PRISMA_SCHEMA_ENGINE_BINARY:
- PRISMA_MIGRATION_ENGINE_BINARY:
For Prisma Client
- PRISMA_SHOW_ALL_TRACES:
For Prisma Migrate
- PRISMA_SCHEMA_DISABLE_ADVISORY_LOCK:
For Prisma Studio
- BROWSER:
-- Terminal is interactive? --
true
-- CI detected? --
false
```
Use with older versions [#use-with-older-versions]
If using an older Prisma version:
#### bun
```bash
bunx prisma@latest debug
```
#### pnpm
```bash
pnpm dlx prisma@latest debug
```
#### yarn
```bash
yarn dlx prisma@latest debug
```
#### npm
```bash
npx prisma@latest debug
```
## Related pages
- [`db`](https://www.prisma.io/docs/cli/db): Manage your database schema and lifecycle during development
- [`dev`](https://www.prisma.io/docs/cli/dev): Start a local Prisma Postgres server for development
- [`format`](https://www.prisma.io/docs/cli/format): Format and validate your Prisma schema file with consistent structure
- [`generate`](https://www.prisma.io/docs/cli/generate): Generate artifacts like Prisma Client based on your Prisma schema
- [`init`](https://www.prisma.io/docs/cli/init): Set up a new Prisma project in the current directory
# format (/docs/cli/format)
Location: CLI > format
The `prisma format` command formats your Prisma schema file. It validates, formats, and persists the schema.
Usage [#usage]
```bash
prisma format [options]
```
Options [#options]
| Option | Description |
| -------------- | -------------------------------------- |
| `-h`, `--help` | Display help message |
| `--config` | Custom path to your Prisma config file |
| `--schema` | Custom path to your Prisma schema |
Examples [#examples]
Format the default schema [#format-the-default-schema]
#### bun
```bash
bunx prisma format
```
#### pnpm
```bash
pnpm dlx prisma format
```
#### yarn
```bash
yarn dlx prisma format
```
#### npm
```bash
npx prisma format
```
Output on success:
```text
Environment variables loaded from .env
Prisma schema loaded from prisma/schema.prisma
Formatted prisma/schema.prisma in 116ms
```
Format a specific schema [#format-a-specific-schema]
#### bun
```bash
bunx prisma format --schema=./alternative/schema.prisma
```
#### pnpm
```bash
pnpm dlx prisma format --schema=./alternative/schema.prisma
```
#### yarn
```bash
yarn dlx prisma format --schema=./alternative/schema.prisma
```
#### npm
```bash
npx prisma format --schema=./alternative/schema.prisma
```
Error output [#error-output]
If the schema has validation errors, formatting will fail:
```text
Environment variables loaded from .env
Prisma schema loaded from prisma/schema.prisma
Error: Schema validation error - Error (query-engine-node-api library)
Error code: P1012
error: The preview feature "unknownFeatureFlag" is not known. Expected one of: [...]
schema.prisma:3
|
2 | provider = "prisma-client"
3 | previewFeatures = ["unknownFeatureFlag"]
|
Validation Error Count: 1
```
## Related pages
- [`db`](https://www.prisma.io/docs/cli/db): Manage your database schema and lifecycle during development
- [`debug`](https://www.prisma.io/docs/cli/debug): Display Prisma debug information including schema paths, engine binaries, environment variables, and cache directories for troubleshooting
- [`dev`](https://www.prisma.io/docs/cli/dev): Start a local Prisma Postgres server for development
- [`generate`](https://www.prisma.io/docs/cli/generate): Generate artifacts like Prisma Client based on your Prisma schema
- [`init`](https://www.prisma.io/docs/cli/init): Set up a new Prisma project in the current directory
# generate (/docs/cli/generate)
Location: CLI > generate
The `prisma generate` command generates assets like Prisma Client based on the [`generator`](/orm/prisma-schema/overview/generators) and [`data model`](/orm/prisma-schema/data-model/models) blocks defined in your `schema.prisma` file.
Usage [#usage]
```bash
prisma generate [options]
```
How it works [#how-it-works]
1. Inspects the current directory to find a Prisma schema
2. Generates a customized Prisma Client based on your schema into the output directory specified in the generator block
Prerequisites [#prerequisites]
Add a generator definition in your `schema.prisma` file:
```prisma
generator client {
provider = "prisma-client"
output = "./generated"
}
```
Options [#options]
| Option | Description |
| ------------------ | ------------------------------------------------------ |
| `-h`, `--help` | Display help message |
| `--config` | Custom path to your Prisma config file |
| `--schema` | Custom path to your Prisma schema |
| `--sql` | Generate typed SQL module |
| `--watch` | Watch the Prisma schema and regenerate after changes |
| `--generator` | Generator to use (can be provided multiple times) |
| `--no-hints` | Hide hint messages (still outputs errors and warnings) |
| `--require-models` | Do not allow generating a client without models |
Examples [#examples]
Generate Prisma Client [#generate-prisma-client]
#### bun
```bash
bunx prisma generate
```
#### pnpm
```bash
pnpm dlx prisma generate
```
#### yarn
```bash
yarn dlx prisma generate
```
#### npm
```bash
npx prisma generate
```
Output:
```text
✔ Generated Prisma Client to ./node_modules/.prisma/client in 61ms
You can now start using Prisma Client in your code:
import { PrismaClient } from '../prisma/generated/client'
const prisma = new PrismaClient()
```
Generate with a custom schema path [#generate-with-a-custom-schema-path]
#### bun
```bash
bunx prisma generate --schema=./alternative/schema.prisma
```
#### pnpm
```bash
pnpm dlx prisma generate --schema=./alternative/schema.prisma
```
#### yarn
```bash
yarn dlx prisma generate --schema=./alternative/schema.prisma
```
#### npm
```bash
npx prisma generate --schema=./alternative/schema.prisma
```
Watch mode [#watch-mode]
Automatically regenerate when the schema changes:
#### bun
```bash
bunx prisma generate --watch
```
#### pnpm
```bash
pnpm dlx prisma generate --watch
```
#### yarn
```bash
yarn dlx prisma generate --watch
```
#### npm
```bash
npx prisma generate --watch
```
Output:
```text
Watching... /home/prismauser/prisma/schema.prisma
✔ Generated Prisma Client to ./node_modules/.prisma/client in 45ms
```
Generate specific generators [#generate-specific-generators]
Run only specific generators:
#### bun
```bash
bunx prisma generate --generator client
```
#### pnpm
```bash
pnpm dlx prisma generate --generator client
```
#### yarn
```bash
yarn dlx prisma generate --generator client
```
#### npm
```bash
npx prisma generate --generator client
```
Multiple generators:
#### bun
```bash
bunx prisma generate --generator client --generator zod_schemas
```
#### pnpm
```bash
pnpm dlx prisma generate --generator client --generator zod_schemas
```
#### yarn
```bash
yarn dlx prisma generate --generator client --generator zod_schemas
```
#### npm
```bash
npx prisma generate --generator client --generator zod_schemas
```
Generated assets [#generated-assets]
The `prisma-client` generator creates a customized client for working with your database. You can [customize the output folder](/orm/reference/prisma-schema-reference#fields-for-prisma-client-provider) using the `output` field in the generator block.
## Related pages
- [`db`](https://www.prisma.io/docs/cli/db): Manage your database schema and lifecycle during development
- [`debug`](https://www.prisma.io/docs/cli/debug): Display Prisma debug information including schema paths, engine binaries, environment variables, and cache directories for troubleshooting
- [`dev`](https://www.prisma.io/docs/cli/dev): Start a local Prisma Postgres server for development
- [`format`](https://www.prisma.io/docs/cli/format): Format and validate your Prisma schema file with consistent structure
- [`init`](https://www.prisma.io/docs/cli/init): Set up a new Prisma project in the current directory
# CLI Overview (/docs/cli)
Location: CLI Overview
The Prisma CLI provides commands for:
* **Project setup**: Initialize new Prisma projects
* **Code generation**: Generate Prisma Client and other artifacts
* **Database management**: Pull schemas, push changes, seed data
* **Migrations**: Create, apply, and manage database migrations
* **Development tools**: Local database servers, schema validation, formatting
Installation [#installation]
The Prisma CLI is available as an npm package. Install it as a development dependency:
#### bun
```bash
bun add prisma --dev
```
#### pnpm
```bash
pnpm add prisma --save-dev
```
#### yarn
```bash
yarn add prisma --dev
```
#### npm
```bash
npm install prisma --save-dev
```
> [!NOTE]
> Looking for [Prisma Compute](/compute) commands? Deployments to Compute use the separate [`@prisma/cli`](/compute/getting-started) beta package, which exposes the `prisma-cli` binary so it can coexist with `prisma`. See [Get started with `@prisma/cli`](/compute/getting-started) and the [Prisma Compute CLI reference](/compute/cli-reference).
Usage [#usage]
```bash
prisma [command]
```
Commands [#commands]
| Command | Description |
| --------------------------- | ---------------------------------------------------- |
| [`init`](/cli/init) | Set up Prisma for your app |
| [`dev`](/cli/dev) | Start a local Prisma Postgres server for development |
| [`generate`](/cli/generate) | Generate artifacts (e.g. Prisma Client) |
| [`db`](/cli/db) | Manage your database schema and lifecycle |
| [`migrate`](/cli/migrate) | Migrate your database |
| [`studio`](/cli/studio) | Browse your data with Prisma Studio |
| [`validate`](/cli/validate) | Validate your Prisma schema |
| [`format`](/cli/format) | Format your Prisma schema |
| [`version`](/cli/version) | Display Prisma version info |
| [`debug`](/cli/debug) | Display Prisma debug info |
Global flags [#global-flags]
These flags are available for all commands:
| Flag | Description |
| ------------------- | ----------------------------------- |
| `--help`, `-h` | Show help information for a command |
| `--preview-feature` | Run Preview Prisma commands |
Using a HTTP proxy [#using-a-http-proxy]
Prisma CLI supports custom HTTP proxies. This is useful when behind a corporate firewall.
Set one of these environment variables:
* `HTTP_PROXY` or `http_proxy`: Proxy URL for HTTP traffic (e.g., `http://localhost:8080`)
* `HTTPS_PROXY` or `https_proxy`: Proxy URL for HTTPS traffic (e.g., `https://localhost:8080`)
## Related pages
- [`Build faster with Prisma + AI`](https://www.prisma.io/docs/ai): Build faster with Prisma and AI coding tools like Cursor, Codex, and ChatGPT
- [`Choose a setup path`](https://www.prisma.io/docs/getting-started): Choose the fastest path to start using Prisma ORM, Prisma Postgres, or Prisma Compute in a new or existing TypeScript project.
- [`Console`](https://www.prisma.io/docs/console): Learn how to use the Console to manage and integrate Prisma products into your application.
- [`Guides`](https://www.prisma.io/docs/guides): A collection of guides for various tasks and workflows
- [`Introduction to Prisma Next`](https://www.prisma.io/docs/next): Prisma Next is the next major version of Prisma ORM, available in Early Access.
# init (/docs/cli/init)
Location: CLI > init
The `prisma init` command bootstraps a fresh Prisma project within the current directory.
Usage [#usage]
```bash
prisma init [options]
```
The command creates a `prisma` directory containing a `schema.prisma` file. By default, the project is configured for [local Prisma Postgres](/postgres/database/local-development), but you can choose a different database using the `--datasource-provider` option.
Options [#options]
| Option | Description |
| ----------------------- | --------------------------------------------------------------------------------------------------------- |
| `-h`, `--help` | Display help message |
| `--db` | Provision a fully managed Prisma Postgres database on the Prisma Data Platform |
| `--datasource-provider` | Define the datasource provider: `postgresql`, `mysql`, `sqlite`, `sqlserver`, `mongodb`, or `cockroachdb` |
| `--generator-provider` | Define the generator provider to use (default: `prisma-client`) |
| `--preview-feature` | Define a preview feature to use (can be specified multiple times) |
| `--output` | Define Prisma Client generator output path |
| `--url` | Define a custom datasource URL |
Flags [#flags]
| Flag | Description |
| -------------- | ----------------------------------------------- |
| `--with-model` | Add an example model to the created schema file |
Examples [#examples]
Set up a new Prisma project (default) [#set-up-a-new-prisma-project-default]
Sets up a new project configured for local Prisma Postgres:
#### bun
```bash
bunx --bun prisma init
```
#### pnpm
```bash
pnpm dlx prisma init
```
#### yarn
```bash
yarn dlx prisma init
```
#### npm
```bash
npx prisma init
```
Specify a datasource provider [#specify-a-datasource-provider]
Set up a new project with MySQL as the datasource provider:
#### bun
```bash
bunx --bun prisma init --datasource-provider mysql
```
#### pnpm
```bash
pnpm dlx prisma init --datasource-provider mysql
```
#### yarn
```bash
yarn dlx prisma init --datasource-provider mysql
```
#### npm
```bash
npx prisma init --datasource-provider mysql
```
Specify a generator provider [#specify-a-generator-provider]
Set up a project with the legacy `prisma-client-js` generator instead of the default `prisma-client` generator:
#### bun
```bash
bunx --bun prisma init --generator-provider prisma-client-js
```
#### pnpm
```bash
pnpm dlx prisma init --generator-provider prisma-client-js
```
#### yarn
```bash
yarn dlx prisma init --generator-provider prisma-client-js
```
#### npm
```bash
npx prisma init --generator-provider prisma-client-js
```
Specify preview features [#specify-preview-features]
Set up a project with specific preview features enabled:
#### bun
```bash
bunx --bun prisma init --preview-feature metrics
```
#### pnpm
```bash
pnpm dlx prisma init --preview-feature metrics
```
#### yarn
```bash
yarn dlx prisma init --preview-feature metrics
```
#### npm
```bash
npx prisma init --preview-feature metrics
```
Multiple preview features:
#### bun
```bash
bunx --bun prisma init --preview-feature views --preview-feature metrics
```
#### pnpm
```bash
pnpm dlx prisma init --preview-feature views --preview-feature metrics
```
#### yarn
```bash
yarn dlx prisma init --preview-feature views --preview-feature metrics
```
#### npm
```bash
npx prisma init --preview-feature views --preview-feature metrics
```
Specify a custom output path [#specify-a-custom-output-path]
Set up a project with a custom output path for Prisma Client:
#### bun
```bash
bunx --bun prisma init --output ./generated-client
```
#### pnpm
```bash
pnpm dlx prisma init --output ./generated-client
```
#### yarn
```bash
yarn dlx prisma init --output ./generated-client
```
#### npm
```bash
npx prisma init --output ./generated-client
```
Specify a custom datasource URL [#specify-a-custom-datasource-url]
Set up a project with a specific database URL:
#### bun
```bash
bunx --bun prisma init --url mysql://user:password@localhost:3306/mydb
```
#### pnpm
```bash
pnpm dlx prisma init --url mysql://user:password@localhost:3306/mydb
```
#### yarn
```bash
yarn dlx prisma init --url mysql://user:password@localhost:3306/mydb
```
#### npm
```bash
npx prisma init --url mysql://user:password@localhost:3306/mydb
```
Add an example model [#add-an-example-model]
Set up a project with an example `User` model:
#### bun
```bash
bunx --bun prisma init --with-model
```
#### pnpm
```bash
pnpm dlx prisma init --with-model
```
#### yarn
```bash
yarn dlx prisma init --with-model
```
#### npm
```bash
npx prisma init --with-model
```
Provision a Prisma Postgres database [#provision-a-prisma-postgres-database]
Create a new project with a managed Prisma Postgres database:
#### bun
```bash
bunx --bun prisma init --db
```
#### pnpm
```bash
pnpm dlx prisma init --db
```
#### yarn
```bash
yarn dlx prisma init --db
```
#### npm
```bash
npx prisma init --db
```
This requires authentication with the [Prisma Data Platform Console](https://console.prisma.io/?utm_source=docs\&utm_medium=content\&utm_content=cli).
Generated files [#generated-files]
After running `prisma init`, you'll have the following files:
prisma/schema.prisma [#prismaschemaprisma]
The Prisma schema file where you define your data model:
```prisma
generator client {
provider = "prisma-client"
output = "../generated/prisma"
}
datasource db {
provider = "postgresql"
}
```
prisma.config.ts [#prismaconfigts]
A TypeScript configuration file for Prisma:
```typescript
import "dotenv/config";
import { defineConfig, env } from "prisma/config";
export default defineConfig({
schema: "prisma/schema.prisma",
migrations: {
path: "prisma/migrations",
},
datasource: {
url: env("DATABASE_URL"),
},
});
```
.env [#env]
Environment variables file for your project:
```bash
DATABASE_URL="postgresql://user:password@localhost:5432/mydb"
```
.gitignore [#gitignore]
Git ignore file configured for Prisma projects:
```bash
node_modules
.env
/generated/prisma
```
## Related pages
- [`db`](https://www.prisma.io/docs/cli/db): Manage your database schema and lifecycle during development
- [`debug`](https://www.prisma.io/docs/cli/debug): Display Prisma debug information including schema paths, engine binaries, environment variables, and cache directories for troubleshooting
- [`dev`](https://www.prisma.io/docs/cli/dev): Start a local Prisma Postgres server for development
- [`format`](https://www.prisma.io/docs/cli/format): Format and validate your Prisma schema file with consistent structure
- [`generate`](https://www.prisma.io/docs/cli/generate): Generate artifacts like Prisma Client based on your Prisma schema
# studio (/docs/cli/studio)
Location: CLI > studio
The `prisma studio` command starts a local web server with a web app to interactively browse and manage your data.
Usage [#usage]
```bash
prisma studio [options]
```
> [!NOTE]
> Supported databases
>
> Prisma Studio currently supports PostgreSQL, MySQL, and SQLite. Support for CockroachDB and MongoDB is not available yet but may be added in future releases.
Prerequisites [#prerequisites]
Configure your database connection in `prisma.config.ts`:
```prisma file=schema.prisma
generator client {
provider = "prisma-client"
output = "../generated/prisma"
}
datasource db {
provider = "sqlite"
}
```
```typescript file=prisma.config.ts
import { defineConfig, env } from "prisma/config";
export default defineConfig({
schema: "prisma/schema.prisma",
migrations: {
path: "prisma/migrations",
},
datasource: {
url: env("DATABASE_URL"),
},
});
```
Options [#options]
| Option | Description | Default |
| ----------------- | ---------------------------------------------------- | -------------- |
| `-h`, `--help` | Display help message | |
| `-p`, `--port` | Port number to start Studio on | `5555` |
| `-b`, `--browser` | Browser to auto-open Studio in | System default |
| `--config` | Custom path to your Prisma config file | |
| `--url` | Database connection string (overrides Prisma config) | |
Examples [#examples]
Start Studio on the default port [#start-studio-on-the-default-port]
#### bun
```bash
bunx prisma studio
```
#### pnpm
```bash
pnpm dlx prisma studio
```
#### yarn
```bash
yarn dlx prisma studio
```
#### npm
```bash
npx prisma studio
```
Start Studio on a custom port [#start-studio-on-a-custom-port]
#### bun
```bash
bunx prisma studio --port 7777
```
#### pnpm
```bash
pnpm dlx prisma studio --port 7777
```
#### yarn
```bash
yarn dlx prisma studio --port 7777
```
#### npm
```bash
npx prisma studio --port 7777
```
Start Studio in a specific browser [#start-studio-in-a-specific-browser]
#### bun
```bash
bunx prisma studio --browser firefox
```
#### pnpm
```bash
pnpm dlx prisma studio --browser firefox
```
#### yarn
```bash
yarn dlx prisma studio --browser firefox
```
#### npm
```bash
npx prisma studio --browser firefox
```
Or using the `BROWSER` environment variable:
```bash
BROWSER=firefox prisma studio
```
Start Studio without opening a browser [#start-studio-without-opening-a-browser]
#### bun
```bash
bunx prisma studio --browser none
```
#### pnpm
```bash
pnpm dlx prisma studio --browser none
```
#### yarn
```bash
yarn dlx prisma studio --browser none
```
#### npm
```bash
npx prisma studio --browser none
```
Start Studio with a custom config file [#start-studio-with-a-custom-config-file]
#### bun
```bash
bunx prisma studio --config=./prisma.config.ts
```
#### pnpm
```bash
pnpm dlx prisma studio --config=./prisma.config.ts
```
#### yarn
```bash
yarn dlx prisma studio --config=./prisma.config.ts
```
#### npm
```bash
npx prisma studio --config=./prisma.config.ts
```
Start Studio with a direct database connection string [#start-studio-with-a-direct-database-connection-string]
#### bun
```bash
bunx prisma studio --url="postgresql://user:password@localhost:5432/dbname"
```
#### pnpm
```bash
pnpm dlx prisma studio --url="postgresql://user:password@localhost:5432/dbname"
```
#### yarn
```bash
yarn dlx prisma studio --url="postgresql://user:password@localhost:5432/dbname"
```
#### npm
```bash
npx prisma studio --url="postgresql://user:password@localhost:5432/dbname"
```
## Related pages
- [`db`](https://www.prisma.io/docs/cli/db): Manage your database schema and lifecycle during development
- [`debug`](https://www.prisma.io/docs/cli/debug): Display Prisma debug information including schema paths, engine binaries, environment variables, and cache directories for troubleshooting
- [`dev`](https://www.prisma.io/docs/cli/dev): Start a local Prisma Postgres server for development
- [`format`](https://www.prisma.io/docs/cli/format): Format and validate your Prisma schema file with consistent structure
- [`generate`](https://www.prisma.io/docs/cli/generate): Generate artifacts like Prisma Client based on your Prisma schema
# validate (/docs/cli/validate)
Location: CLI > validate
The `prisma validate` command validates the [Prisma Schema Language](/orm/prisma-schema/overview) of your Prisma schema file.
Usage [#usage]
```bash
prisma validate [options]
```
Options [#options]
| Option | Description |
| -------------- | -------------------------------------- |
| `-h`, `--help` | Display help message |
| `--config` | Custom path to your Prisma config file |
| `--schema` | Custom path to your Prisma schema |
Examples [#examples]
Validate the default schema [#validate-the-default-schema]
#### bun
```bash
bunx prisma validate
```
#### pnpm
```bash
pnpm dlx prisma validate
```
#### yarn
```bash
yarn dlx prisma validate
```
#### npm
```bash
npx prisma validate
```
Output on success:
```text
Environment variables loaded from .env
Prisma schema loaded from prisma/schema.prisma
The schema at /absolute/path/prisma/schema.prisma is valid
```
Validate a specific schema [#validate-a-specific-schema]
#### bun
```bash
bunx prisma validate --schema=./alternative/schema.prisma
```
#### pnpm
```bash
pnpm dlx prisma validate --schema=./alternative/schema.prisma
```
#### yarn
```bash
yarn dlx prisma validate --schema=./alternative/schema.prisma
```
#### npm
```bash
npx prisma validate --schema=./alternative/schema.prisma
```
Validate with a config file [#validate-with-a-config-file]
#### bun
```bash
bunx prisma validate --config=./prisma.config.ts
```
#### pnpm
```bash
pnpm dlx prisma validate --config=./prisma.config.ts
```
#### yarn
```bash
yarn dlx prisma validate --config=./prisma.config.ts
```
#### npm
```bash
npx prisma validate --config=./prisma.config.ts
```
Error output [#error-output]
If the schema has validation errors:
```text
Environment variables loaded from .env
Prisma schema loaded from prisma/schema.prisma
Error: Schema validation error - Error (query-engine-node-api library)
Error code: P1012
error: The preview feature "unknownFeatureFlag" is not known. Expected one of: [...]
schema.prisma:3
|
2 | provider = "prisma-client"
3 | previewFeatures = ["unknownFeatureFlag"]
|
Validation Error Count: 1
```
## Related pages
- [`db`](https://www.prisma.io/docs/cli/db): Manage your database schema and lifecycle during development
- [`debug`](https://www.prisma.io/docs/cli/debug): Display Prisma debug information including schema paths, engine binaries, environment variables, and cache directories for troubleshooting
- [`dev`](https://www.prisma.io/docs/cli/dev): Start a local Prisma Postgres server for development
- [`format`](https://www.prisma.io/docs/cli/format): Format and validate your Prisma schema file with consistent structure
- [`generate`](https://www.prisma.io/docs/cli/generate): Generate artifacts like Prisma Client based on your Prisma schema
# version (/docs/cli/version)
Location: CLI > version
The `prisma version` command outputs information about your current Prisma version, platform, and engine binaries.
Usage [#usage]
```bash
prisma version [options]
```
Or use the shorthand:
```bash
prisma -v [options]
```
Options [#options]
| Option | Description |
| -------------- | ----------------------------------------- |
| `-h`, `--help` | Display help message |
| `--json` | Output version information in JSON format |
Examples [#examples]
Display version information [#display-version-information]
#### bun
```bash
bunx prisma version
```
#### pnpm
```bash
pnpm dlx prisma version
```
#### yarn
```bash
yarn dlx prisma version
```
#### npm
```bash
npx prisma version
```
Output:
```text
Environment variables loaded from .env
prisma : 2.21.0-dev.4
@prisma/client : 2.21.0-dev.4
Current platform : windows
Query Engine : query-engine 2fb8f444d9cdf7c0beee7b041194b42d7a9ce1e6
Migration Engine : migration-engine-cli 2fb8f444d9cdf7c0beee7b041194b42d7a9ce1e6
Format Binary : prisma-fmt 60ba6551f29b17d7d6ce479e5733c70d9c00860e
Default Engines Hash : 60ba6551f29b17d7d6ce479e5733c70d9c00860e
Studio : 0.365.0
```
Display version using shorthand [#display-version-using-shorthand]
#### bun
```bash
bunx prisma -v
```
#### pnpm
```bash
pnpm dlx prisma -v
```
#### yarn
```bash
yarn dlx prisma -v
```
#### npm
```bash
npx prisma -v
```
Display version as JSON [#display-version-as-json]
#### bun
```bash
bunx prisma version --json
```
#### pnpm
```bash
pnpm dlx prisma version --json
```
#### yarn
```bash
yarn dlx prisma version --json
```
#### npm
```bash
npx prisma version --json
```
Output:
```json
{
"prisma": "2.21.0-dev.4",
"@prisma/client": "2.21.0-dev.4",
"current-platform": "windows",
"query-engine": "query-engine 60ba6551f29b17d7d6ce479e5733c70d9c00860e",
"migration-engine": "migration-engine-cli 60ba6551f29b17d7d6ce479e5733c70d9c00860e",
"format-binary": "prisma-fmt 60ba6551f29b17d7d6ce479e5733c70d9c00860e",
"default-engines-hash": "60ba6551f29b17d7d6ce479e5733c70d9c00860e",
"studio": "0.365.0"
}
```
## Related pages
- [`db`](https://www.prisma.io/docs/cli/db): Manage your database schema and lifecycle during development
- [`debug`](https://www.prisma.io/docs/cli/debug): Display Prisma debug information including schema paths, engine binaries, environment variables, and cache directories for troubleshooting
- [`dev`](https://www.prisma.io/docs/cli/dev): Start a local Prisma Postgres server for development
- [`format`](https://www.prisma.io/docs/cli/format): Format and validate your Prisma schema file with consistent structure
- [`generate`](https://www.prisma.io/docs/cli/generate): Generate artifacts like Prisma Client based on your Prisma schema
# Concepts (/docs/console/concepts)
Location: Console > Concepts
The Console workflows are based on five main concepts:
* [**User account**](#user-account): In order to use Prisma products, you need to have a Console user account. A *user* will typically create one user account to manage all their workspaces, projects and resources. The *user* can also be invited to join other workspaces to collaborate on the projects in that workspace.
* [**Workspaces**](#workspace): A user account can belong to multiple workspaces. A workspace typically represents a *team* of individuals working together on one or more projects. **Billing is on a workspace level**, i.e. the invoice for a workspace at the end of the month captures all costs associated with the projects in that workspace.
* [**Projects**](#project): A project belongs to a workspace. It typically represents the *application* or *service* a team is working on.
* [**Branches**](#branch): For projects that use [Prisma Compute](/compute), resources are grouped into branches. A branch is an isolated infrastructure boundary for one line of work, usually mapping to a Git branch.
* [**Resources**](#resources): Resources represent the actual services or databases within a project. For example, in Prisma Postgres, each project can contain multiple databases. For Prisma Compute, each branch contains apps and their deployments. For Accelerate, resources might correspond to different environments (like `Development`, `Staging`, or `Production`). **Connection strings are provisioned at the resource level**, and products are configured per resource as well (e.g., the database connection string used for Accelerate).
Here is a visual illustration of how these concepts relate to each other:
User account [#user-account]
A user account is the prerequisite for any interactions with Prisma products. You can use it to manage your workspaces (and their projects). A user account can be invited to collaborate on workspaces created by other users as well.
If you need to delete your user account, go [here](/console/more/support#deleting-your-pdp-account).
Workspace [#workspace]
You can create several workspaces. A workspace is an isolated space to host projects. A workspace can have multiple user accounts associated with it so that multiple users can collaborate on the projects in the workspace.
In each workspace, you can:
* view and manage all projects (and their resources) in that workspace.
* manage billing, i.e. select a [subscription plan](https://www.prisma.io/pricing?utm_source=docs\&utm_medium=platform-docs), configure payment methods, or view the invoice history.
* view the usage of your enabled Prisma products across all projects in that workspace.
* invite other users to collaborate in the workspace.
* access [Query Insights](/query-insights) to measure query performance and receive AI-powered recommendations (available with Prisma Postgres).
Project [#project]
In each workspace, you can create several projects. A project typically represents an application (a product or service). You typically have one [Prisma schema](/orm/prisma-schema/overview) per project.
In each project, you can:
* view and manage all resources (like databases) in that project.
The number of projects you can create in a workspace depends on the [subscription plan](https://www.prisma.io/pricing?utm_source=docs\&utm_medium=platform-docs) configured in that workspace.
Branch [#branch]
For projects that use [Prisma Compute](/compute), a branch groups the resources for one line of work:
```text
workspace → project → branch → { apps, databases }
```
A branch usually maps to a Git branch, but it's a real resource that owns the apps and databases for that work:
* The **first branch** in a project is the production branch, usually `main`. It's protected and durable.
* **Every other branch** is a preview branch by default: disposable infrastructure for testing changes before they merge.
* [Environment variables](/compute/environment-variables) are scoped to production, to preview, or to a single preview branch.
Learn more in [Branching](/compute/branching).
Resources [#resources]
Resources represent the actual services or databases within a project. The type of resources available depends on the Prisma products you're using:
* **For Prisma Postgres**: Each project can contain multiple databases. These databases are the primary resources you'll manage.
* **For Prisma Compute**: Each branch contains apps. An app is an HTTP service, and each built version of an app is a deployment. See [Prisma Compute](/compute).
* **For Accelerate**: Resources typically correspond to different deployment stages (like `Development`, `Staging`, or `Production`).
In each project, you can:
* Create and manage multiple resources (databases or environments)
* Generate connection strings specific to each resource
* Configure product-specific settings:
* **For Prisma Postgres databases**:
* View database metrics and performance
* Configure connection settings
* Manage database users and permissions
* **For Accelerate resources**:
* Set your database connection string
* Configure the region for connection pooling
* Adjust connection pool size and performance settings
* Set query duration and response size limits
* Enable static IP for secure connections
The number of resources you can create in a project depends on your [subscription plan](https://www.prisma.io/pricing?utm_source=docs\&utm_medium=platform-docs).
## Related pages
- [`Getting Started`](https://www.prisma.io/docs/console/getting-started): Quick start guide for setting up and using the Prisma Console
# Getting Started (/docs/console/getting-started)
Location: Console > Getting Started
This guide walks you through setting up your Console account and creating your first project.
Prerequisites [#prerequisites]
* A GitHub account (for authentication)
* A Prisma project (optional, but recommended)
Step 1: Create your account [#step-1-create-your-account]
1. Go to [console.prisma.io/login](https://console.prisma.io/login?utm_source=docs\&utm_medium=content\&utm_content=console)
2. Click **Sign in with GitHub**
3. Authorize Prisma Console to access your GitHub account
You now have a Console account with a default workspace.
Step 2: Set up a workspace [#step-2-set-up-a-workspace]
When you create an account, a default workspace is automatically created for you. You can create additional workspaces for different teams or organizations.
Create a workspace (optional) [#create-a-workspace-optional]
To create an additional workspace:
1. Click the workspace dropdown in the top navigation
2. Click **Create Workspace**
3. Enter a name for your workspace
4. Click **Create**
Step 3: Create a project [#step-3-create-a-project]
Projects organize your databases and environments within a workspace.
Using the Console web interface [#using-the-console-web-interface]
1. Navigate to your workspace
2. Click **Create Project**
3. Enter a project name
4. Click **Create**
Step 4: Create a resource [#step-4-create-a-resource]
Resources are the actual databases or environments within your project.
For Prisma Postgres [#for-prisma-postgres]
1. Navigate to your project
2. Click **Create Database**
3. Enter a database name
4. Select a region
5. Click **Create**
For Accelerate [#for-accelerate]
1. Navigate to your project
2. Click **Create Environment**
3. Enter an environment name (e.g., "production")
4. Click **Create**
Step 5: Generate a connection string [#step-5-generate-a-connection-string]
Connection strings authenticate your application's requests to Prisma products.
Using the Console web interface [#using-the-console-web-interface-1]
1. Navigate to your resource (database or environment)
2. Click **Connection Strings** tab
3. Click **Create Connection String**
4. Enter a name for the connection string
5. Copy the connection string and store it securely
6. Click **Done**
Step 6: Use the connection string in your application [#step-6-use-the-connection-string-in-your-application]
Add the connection string to your `.env` file:
```bash
# For Accelerate
DATABASE_URL="prisma://accelerate.prisma-data.net/?api_key=YOUR_API_KEY"
```
Next steps [#next-steps]
* Learn more about [Console concepts](/console/concepts)
* Explore [database metrics](/console/features/metrics)
* Check out the [CLI reference](/cli/console)
## Related pages
- [`Concepts`](https://www.prisma.io/docs/console/concepts): Understand the core concepts of the Prisma Console: user accounts, workspaces, projects, and resources
# Console (/docs/console)
Location: Console
Overview [#overview]
The [Console](https://console.prisma.io/login?utm_source=docs\&utm_medium=content\&utm_content=console) enables you to manage and configure your projects that use Prisma products, and helps you integrate them into your application:
* [Query Insights](/query-insights): Inspect slow queries, connect Prisma calls to SQL, and apply focused fixes.
* [Prisma Postgres](/postgres): A managed PostgreSQL database that is optimized for Prisma ORM.
* [Prisma Compute](/compute): Runs your app next to your Prisma Postgres database, currently in [Public Beta](/console/more/feature-maturity#public-beta). Inspect projects, branches, apps, and deployments in the Console; deploy with the [`@prisma/cli`](/compute/getting-started) beta package.
Getting started [#getting-started]
To start using Prisma products, you'll need to:
1. Create a Console account
2. Set up a workspace for your team
3. Create a project for your application
4. Generate connection strings for your resources
Learn more in the [Getting Started](/console/getting-started) guide.
Core concepts [#core-concepts]
The Console is organized around four main concepts:
* **[User account](/console/concepts#user-account)**: Your personal account to manage workspaces and projects
* **[Workspaces](/console/concepts#workspace)**: Team-level container where billing is managed
* **[Projects](/console/concepts#project)**: Application-level container within a workspace
* **[Resources](/console/concepts#resources)**: Actual services or databases within a project (databases for Prisma Postgres)
Read more about [Console concepts](/console/concepts).
Console CLI [#console-cli]
In addition to the web interface, the Prisma CLI provides another way to interact with your Console account and manage Prisma products. This can be useful for programmatic access, such as integrating into CI workflows.
Learn more about the [Console CLI commands](/cli/console).
## Related pages
- [`Build faster with Prisma + AI`](https://www.prisma.io/docs/ai): Build faster with Prisma and AI coding tools like Cursor, Codex, and ChatGPT
- [`Choose a setup path`](https://www.prisma.io/docs/getting-started): Choose the fastest path to start using Prisma ORM, Prisma Postgres, or Prisma Compute in a new or existing TypeScript project.
- [`CLI Overview`](https://www.prisma.io/docs/cli): The Prisma CLI is the command-line interface for Prisma ORM. Use it to initialize projects, generate Prisma Client, manage databases, run migrations, and more
- [`Guides`](https://www.prisma.io/docs/guides): A collection of guides for various tasks and workflows
- [`Introduction to Prisma Next`](https://www.prisma.io/docs/next): Prisma Next is the next major version of Prisma ORM, available in Early Access.
# Using API Clients (/docs/management-api/api-clients)
Location: Management API > Using API Clients
This guide shows you how to configure popular API clients to work with the Management API using OAuth 2.0 authentication.
Download the Postman collection to import all endpoints with OAuth2 auth pre-configured. Compatible with Postman, Yaak, Insomnia, and other clients that support the Postman Collection v2.1 format.
Postman [#postman]
Postman is a popular API client with testing, collaboration, and automation features for working with REST APIs.
Prerequisites [#prerequisites]
Before you begin, make sure you have:
* A [Prisma Console account](https://console.prisma.io/?utm_source=docs\&utm_medium=content\&utm_content=management-api)
* [Postman installed](https://www.postman.com/downloads/)
1. Create an OAuth2 Application [#1-create-an-oauth2-application]
First, you'll need to register an OAuth2 application in Prisma Console:
1. Navigate to [Prisma Console](https://console.prisma.io/?utm_source=docs\&utm_medium=content\&utm_content=management-api) and log in
2. Click the **🧩 Integrations** tab in the left sidebar
3. Under the "Published Applications" section, click **New Application**
4. Fill in your application details:
* **Name**: Postman API Client
* **Description**: Brief description of your application *(Optional)*
* **Redirect URI**: `https://oauth.pstmn.io/v1/callback`
5. Click **Continue**
6. **Important**: Copy your Client ID and Client Secret immediately and store them securely
> [!NOTE]
> The redirect URI `https://oauth.pstmn.io/v1/callback` is Postman's default callback URL when using the "Authorize using browser" option.
2. Configure OAuth 2.0 in Postman [#2-configure-oauth-20-in-postman]
Now you'll set up authentication in Postman:
1. Open Postman and create a new HTTP request
2. Set the request method to **POST**
3. Set the URL to `https://api.prisma.io/v1/projects`
4. Navigate to the **Authorization** tab
5. Set **Auth Type** to **OAuth 2.0**
6. Under **Configure New Token**, enter the following values:
| Parameter | Value |
| -------------------- | ------------------------------------ |
| Token Name | Management API Token |
| Grant Type | Authorization Code |
| Callback URL | `https://oauth.pstmn.io/v1/callback` |
| Authorize in Browser | `true` *(checked)* |
| Auth URL | `https://auth.prisma.io/authorize` |
| Access Token URL | `https://auth.prisma.io/token` |
| Client ID | `your-client-id` |
| Client Secret | `your-client-secret` |
| Scope | `workspace:admin` |
7. Click **Get New Access Token**
8. A browser window will open and have you complete the authorization flow
9. Return to Postman and click **Use Token** to attach it to your request
10. Verify that your new token appears under **Current Token** at the top of the Authorization tab
3. Make your first request [#3-make-your-first-request]
With authentication configured, you can now create a project:
1. In the request body, select **raw** and **JSON** format
2. Add the following JSON payload:
```json
{
"name": "My Postman Database",
"region": "us-east-1"
}
```
3. Click **Send**
You should receive a successful response confirming your project creation.
Insomnia [#insomnia]
Insomnia is an open-source API client with a clean interface for testing and debugging HTTP requests.
Prerequisites [#prerequisites-1]
Before you begin, make sure you have:
* A [Prisma Console account](https://console.prisma.io/?utm_source=docs\&utm_medium=content\&utm_content=management-api)
* [Insomnia installed](https://insomnia.rest/download/)
1. Create an OAuth2 Application [#1-create-an-oauth2-application-1]
First, you'll need to register an OAuth2 application in Prisma Console:
1. Navigate to [Prisma Console](https://console.prisma.io/?utm_source=docs\&utm_medium=content\&utm_content=management-api) and log in
2. Click the **🧩 Integrations** tab in the left sidebar
3. Under the "Published Applications" section, click **New Application**
4. Fill in your application details:
* **Name**: Insomnia API Client
* **Description**: Brief description of your application *(Optional)*
* **Redirect URI**: `https://app.insomnia.rest/oauth/redirect`
5. Click **Continue**
6. **Important**: Copy your Client ID and Client Secret immediately and store them securely
> [!NOTE]
> Insomnia uses `https://app.insomnia.rest/oauth/redirect` as the default OAuth callback URL for local authentication flows.
2. Configure OAuth 2.0 in Insomnia [#2-configure-oauth-20-in-insomnia]
Now you'll set up authentication in Insomnia:
1. Open Insomnia and create a new HTTP request
2. Set the request method to **POST**
3. Set the URL to `https://api.prisma.io/v1/projects`
4. Navigate to the **Auth** tab
5. Set the authentication type to **OAuth 2.0**
6. Under **Configuration**, enter the following values:
| Parameter | Value |
| -------------------------------- | ------------------------------------------ |
| Grant Type | Authorization Code |
| Authorization URL | `https://auth.prisma.io/authorize` |
| Access Token URL | `https://auth.prisma.io/token` |
| Client ID | `your-client-id` |
| Client Secret | `your-client-secret` |
| Redirect URL | `https://app.insomnia.rest/oauth/redirect` |
| Scope *(Under Advanced Options)* | `workspace:admin` |
7. Click **Fetch Tokens**
8. A browser window will open and have you complete the authorization flow
9. Return to Insomnia and verify that the access token has been retrieved
10. The token will be automatically attached to your requests
3. Make your first request [#3-make-your-first-request-1]
With authentication configured, you can now create a project:
1. Navigate to the **Body** tab and select **JSON** format
2. Add the following JSON payload:
```json
{
"name": "My Insomnia Database",
"region": "us-east-1"
}
```
3. Click **Send**
You should receive a successful response confirming your project creation.
Yaak [#yaak]
Yaak is a lightweight, open-source, and offline API client that works with Git.
Prerequisites [#prerequisites-2]
Before you begin, make sure you have:
* A [Prisma Console account](https://console.prisma.io/?utm_source=docs\&utm_medium=content\&utm_content=management-api)
* [Yaak installed](https://yaak.app)
1. Create an OAuth2 Application [#1-create-an-oauth2-application-2]
First, you'll need to register an OAuth2 application in Prisma Console:
1. Navigate to [Prisma Console](https://console.prisma.io/?utm_source=docs\&utm_medium=content\&utm_content=management-api) and log in
2. Click the **🧩 Integrations** tab in the left sidebar
3. Under the "Published Applications" section, click **New Application**
4. Fill in your application details:
* **Name**: Yaak API Client
* **Description**: Brief description of your application *(Optional)*
* **Redirect URI**: `https://devnull.yaak.app/callback`
5. Click **Continue**
6. **Important**: Copy your Client ID and Client Secret immediately and store them securely
> [!NOTE]
> The redirect URI can be any valid URL. Yaak intercepts the OAuth callback regardless of the redirect URI, as long as it matches what's registered with the provider.
2. Configure OAuth 2.0 in Yaak [#2-configure-oauth-20-in-yaak]
Now you'll set up authentication in Yaak:
1. Open Yaak and create a new HTTP request
2. Set the request method to **POST**
3. Set the URL to `https://api.prisma.io/v1/projects`
4. Navigate to the **Auth** tab
5. Set the authentication type to **OAuth 2.0**
6. Enter the following values:
| Parameter | Value |
| ----------------- | ----------------------------------- |
| Grant Type | Authorization Code |
| Authorization URL | `https://auth.prisma.io/authorize` |
| Token URL | `https://auth.prisma.io/token` |
| Client ID | `your-client-id` |
| Client Secret | `your-client-secret` |
| Redirect URL | `https://devnull.yaak.app/callback` |
| Scope | `workspace:admin` |
7. Click **Get Token**
8. A browser window will open and have you complete the authorization flow
9. Return to Yaak and verify that the access token has been retrieved
10. The token will be automatically attached to your requests
3. Make your first request [#3-make-your-first-request-2]
With authentication configured, you can now create a project:
1. Navigate to the **Body** tab and select **JSON** format
2. Add the following JSON payload:
```json
{
"name": "My Yaak Database",
"region": "us-east-1"
}
```
3. Click **Send**
You should receive a successful response confirming your project creation.
## Related pages
- [`Authentication`](https://www.prisma.io/docs/management-api/authentication): Learn how to authenticate with the Prisma Management API using service tokens or OAuth 2.0
- [`Getting Started`](https://www.prisma.io/docs/management-api/getting-started): Get started with the Prisma Management API by creating your first project and database
- [`Partner Integration`](https://www.prisma.io/docs/management-api/partner-integration): Build partner integrations that provision and transfer Prisma Postgres databases to users
- [`SDK`](https://www.prisma.io/docs/management-api/sdk): A TypeScript SDK for the Prisma Data Platform Management API. Use the simple client for direct API access, or the full SDK with built-in OAuth authentication and automatic token refresh
# Authentication (/docs/management-api/authentication)
Location: Management API > Authentication
The Management API supports two authentication methods:
* **Service Tokens** - Simple bearer tokens for server-to-server integrations
* **OAuth 2.0** - For user-facing applications requiring user consent
Service tokens [#service-tokens]
Service tokens are the simplest way to authenticate. They're ideal for scripts, CI/CD pipelines, and backend services.
Creating a Service token [#creating-a-service-token]
1. Navigate to [Prisma Console](https://console.prisma.io/?utm_source=docs\&utm_medium=content\&utm_content=management-api) and log in
2. Select your workspace
3. Go to **Settings → Service Tokens**
4. Click **New Service Token**
5. Copy the generated token immediately and store it securely
Using a Service token [#using-a-service-token]
Include the token in the `Authorization` header:
```bash
curl -X GET "https://api.prisma.io/v1/workspaces" \
-H "Authorization: Bearer your-service-token"
```
Or with the SDK:
```typescript
import { createManagementApiClient } from "@prisma/management-api-sdk";
const client = createManagementApiClient({
token: "your-service-token",
});
```
> [!WARNING]
> Service tokens never expire
>
> Service tokens do not have an expiration date. While this provides convenience for long-running integrations, it also means these tokens require careful security management.
OAuth 2.0 [#oauth-20]
OAuth 2.0 is required for applications that act on behalf of users. The API uses OAuth 2.0 with PKCE for secure authentication.
PKCE Support [#pkce-support]
The OAuth implementation supports Proof Key for Code Exchange (PKCE) using the S256 code challenge method:
* **Public clients** (no client secret): PKCE is **mandatory**
* **Confidential clients** (with client secret): PKCE is **optional**, but if you start the flow with PKCE, it must be completed with PKCE
This provides enhanced security, especially for mobile and single-page applications that cannot securely store client secrets.
Creating an OAuth Application [#creating-an-oauth-application]
1. Navigate to [Prisma Console](https://console.prisma.io/?utm_source=docs\&utm_medium=content\&utm_content=management-api) and log in
2. Click the **Integrations** tab in the left sidebar
3. Under "Published Applications", click **New Application**
4. Fill in your application details:
* **Name**: Your application name
* **Description**: Brief description *(optional)*
* **Redirect URI**: Your callback URL (e.g., `https://your-app.com/auth/callback`)
5. Click **Continue**
6. Copy your **Client ID** and **Client Secret** immediately
> [!NOTE]
> Development redirect URIs
>
> For local development, the following redirect URIs are accepted with any port via wildcard matching:
>
> * `localhost` (e.g., `http://localhost:3000/callback`)
> * `127.0.0.1` (e.g., `http://127.0.0.1:3000/callback`)
> * `[::1]` - IPv6 loopback (e.g., `http://[::1]:3000/callback`)
OAuth Endpoints [#oauth-endpoints]
| Endpoint | URL |
| ------------- | --------------------------------------------------------------- |
| Authorization | `https://auth.prisma.io/authorize` |
| Token | `https://auth.prisma.io/token` |
| Discovery | `https://auth.prisma.io/.well-known/oauth-authorization-server` |
> [!NOTE]
> The discovery endpoint provides OAuth server metadata that can be used for automatic client configuration. Many OAuth libraries support automatic discovery using this endpoint.
Available Scopes [#available-scopes]
| Scope | Description |
| ----------------- | ---------------------------------------------- |
| `workspace:admin` | Full access to workspace resources |
| `offline_access` | Enables refresh tokens for long-lived sessions |
Token Lifetimes [#token-lifetimes]
| Token Type | Expiration |
| -------------- | ---------- |
| Access tokens | 1 hour |
| Refresh tokens | 90 days |
OAuth Authorization Flow [#oauth-authorization-flow]
1. Redirect users to authorize [#1-redirect-users-to-authorize]
Redirect users to the authorization endpoint with the following query parameters:
| Parameter | Description |
| --------------- | ------------------------------------------------------------------- |
| `client_id` | Your OAuth application's Client ID |
| `redirect_uri` | The callback URL where users will be redirected after authorization |
| `response_type` | Must be `code` for the authorization code flow |
| `scope` | Permissions to request (e.g., `workspace:admin`) |
```
https://auth.prisma.io/authorize?client_id=$CLIENT_ID&redirect_uri=$REDIRECT_URI&response_type=code&scope=workspace:admin
```
This will redirect the user to the Prisma authorization page where they can grant your application access to their workspace.
2. Receive the authorization code [#2-receive-the-authorization-code]
After authorization, users are redirected to your callback URL with a `code` parameter:
```
https://your-app.com/callback?code=abc123...
```
3. Exchange the code for an access token [#3-exchange-the-code-for-an-access-token]
```bash
curl -X POST https://auth.prisma.io/token \
-H "Content-Type: application/x-www-form-urlencoded" \
-d "client_id=$CLIENT_ID" \
-d "client_secret=$CLIENT_SECRET" \
-d "code=$CODE" \
-d "grant_type=authorization_code" \
-d "redirect_uri=$REDIRECT_URI"
```
The response will include an access token that can be used to make authenticated requests to the Management API:
```json
{
"access_token": "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...",
"token_type": "Bearer",
"expires_in": 3600
}
```
4. Use the access token [#4-use-the-access-token]
```bash
curl -X GET "https://api.prisma.io/v1/workspaces" \
-H "Authorization: Bearer $ACCESS_TOKEN"
```
Token Refresh [#token-refresh]
If you requested the `offline_access` scope, you'll receive a refresh token. Use it to obtain new access tokens:
```bash
curl -X POST https://auth.prisma.io/token \
-H "Content-Type: application/x-www-form-urlencoded" \
-d "client_id=$CLIENT_ID" \
-d "client_secret=$CLIENT_SECRET" \
-d "refresh_token=$REFRESH_TOKEN" \
-d "grant_type=refresh_token"
```
> [!NOTE]
> Refresh token rotation
>
> Refresh tokens use single-use rotation with replay attack detection. When you exchange a refresh token for a new access token, you'll receive a new refresh token in the response. The old refresh token is immediately invalidated. If an invalidated refresh token is used again, it indicates a potential security breach, and the system will revoke all tokens associated with that authorization.
Using OAuth with the SDK [#using-oauth-with-the-sdk]
The SDK handles the OAuth flow automatically. See the [SDK documentation](/management-api/sdk#oauth-authentication-flow) for implementation details.
Using API Clients [#using-api-clients]
You can also authenticate using popular API clients like Postman, Insomnia, or Yaak. See the [Using API Clients](/management-api/api-clients) guide for step-by-step instructions.
## Related pages
- [`Getting Started`](https://www.prisma.io/docs/management-api/getting-started): Get started with the Prisma Management API by creating your first project and database
- [`Partner Integration`](https://www.prisma.io/docs/management-api/partner-integration): Build partner integrations that provision and transfer Prisma Postgres databases to users
- [`SDK`](https://www.prisma.io/docs/management-api/sdk): A TypeScript SDK for the Prisma Data Platform Management API. Use the simple client for direct API access, or the full SDK with built-in OAuth authentication and automatic token refresh
- [`Using API Clients`](https://www.prisma.io/docs/management-api/api-clients): Use the Management API with popular API clients like Postman, Insomnia, and Yaak
# Getting Started (/docs/management-api/getting-started)
Location: Management API > Getting Started
This guide walks you through setting up a basic TypeScript project that uses the Management API to create a new Prisma Console project with a Prisma Postgres database, and print out all connection details.
You'll authenticate via a service token, set up your environment, and run a script to interact with the API.
Prerequisites [#prerequisites]
* Node.js and `npm` installed
* A [Prisma Data Platform](https://console.prisma.io/?utm_source=docs\&utm_medium=content\&utm_content=management-api) account
1. Create a service token in Prisma Console [#1-create-a-service-token-in-prisma-console]
First, you need to create a service token to be able to access the Management API:
1. Open the [Prisma Console](https://console.prisma.io/?utm_source=docs\&utm_medium=content\&utm_content=management-api)
2. Navigate to the **Settings** page of your workspace and select **Service Tokens**
3. Click **New Service Token**
4. Copy and save the generated service token securely, you'll use it in step 2.2.
2. Set up your project directory [#2-set-up-your-project-directory]
2.1. Create a basic TypeScript project [#21-create-a-basic-typescript-project]
Open your terminal and run the following commands:
```bash
mkdir management-api-demo
cd management-api-demo
```
Next, initialize npm and install dependencies required for using TypeScript:
#### bun
```bash
bun init
bun add tsx typescript @types/node --dev
touch index.ts
```
#### pnpm
```bash
pnpm init
pnpm add tsx typescript @types/node --save-dev
touch index.ts
```
#### yarn
```bash
yarn init
yarn add tsx typescript @types/node --dev
touch index.ts
```
#### npm
```bash
npm init
npm install tsx typescript @types/node --save-dev
touch index.ts
```
You now have an `index.ts` file that you can execute with `npx tsx index.ts`. It's still empty, you'll start writing code in step 3.
2.2. Configure service token environment variable [#22-configure-service-token-environment-variable]
Create your `.env` file:
```bash
touch .env
```
Next, install the [`dotenv`](https://github.com/motdotla/dotenv) library for loading environment variables from the `.env` file:
#### bun
```bash
bun add dotenv
```
#### pnpm
```bash
pnpm add dotenv
```
#### yarn
```bash
yarn add dotenv
```
#### npm
```bash
npm install dotenv
```
Finally, add your service token (from step 1.) to `.env`:
```bash
PRISMA_SERVICE_TOKEN="ey..."
```
2.3. Install the axios library for HTTP request [#23-install-the-axios-library-for-http-request]
You're going to use [`axios`](https://github.com/axios/axios/tree/main) as your HTTP client to interact with the Management API. Install it as follows:
#### bun
```bash
bun add axios
```
#### pnpm
```bash
pnpm add axios
```
#### yarn
```bash
yarn add axios
```
#### npm
```bash
npm install axios
```
You're all set, let's write some code to create a project and provision a Prisma Postgres database!
3. Programmatically create a new project with a database [#3-programmatically-create-a-new-project-with-a-database]
Paste the following code into `index.ts`:
```ts
import axios from "axios";
import dotenv from "dotenv";
// Load environment variables
dotenv.config();
const API_URL = "https://api.prisma.io/v1";
const SERVICE_TOKEN = process.env.PRISMA_SERVICE_TOKEN;
if (!SERVICE_TOKEN) {
throw new Error("PRISMA_SERVICE_TOKEN is not set in the environment");
}
// Set HTTP headers to be used in this script
const headers = {
Authorization: `Bearer ${SERVICE_TOKEN}`,
"Content-Type": "application/json",
};
async function main() {
// Create a new project in your Prisma Console workspace
const projectName = `demo-project-${Date.now()}`;
const region = "us-east-1";
const createProjectRes = await axios.post(
`${API_URL}/projects`,
{ name: projectName, region },
{ headers },
);
const project = createProjectRes.data;
console.log("Created project: \n", project);
// Log the database details
const apiKeys = project.databases[0].apiKeys || [];
for (const key of apiKeys) {
console.log(`\nDatabase details`);
console.log(`- ID: ${key.id}`);
console.log(`- Created at: ${key.createdAt}`);
console.log(`- API key: ${key.apiKey}`);
console.log(`- Prisma Postgres connection string: ${key.connectionString}`);
if (key.ppgDirectConnection) {
console.log(`- Direct TCP connection: ${key.ppgDirectConnection.host}`);
console.log(` - Host: ${key.ppgDirectConnection.host}`);
console.log(` - Username: ${key.ppgDirectConnection.user}`);
console.log(` - Password: ${key.ppgDirectConnection.pass}`);
}
}
}
main().catch((e) => {
console.error(e.response?.data || e);
process.exit(1);
});
```
You can run your script with the following command:
#### bun
```bash
bunx tsx index.ts
```
#### pnpm
```bash
pnpm dlx tsx index.ts
```
#### yarn
```bash
yarn dlx tsx index.ts
```
#### npm
```bash
npx tsx index.ts
```
```text no-copy
Created project:
{
createdAt: '2025-07-09T11:52:15.341Z',
id: 'cmcvwftgs00v5zq0vh3kp7pms',
name: 'demo-project-1752061932800',
databases: [
{
createdAt: '2025-07-09T11:52:15.341Z',
id: 'cmcvwftgs00v1zq0v0qrtrg8t',
name: 'demo-project-1752061932800',
connectionString: 'prisma+postgres://accelerate.prisma-data.net/?api_key=
Technical details [#technical-details]
Prisma Postgres is based on **PostgreSQL v17** and uses a unikernel-based architecture.
Learn more: [Prisma Postgres: Building a modern PostgreSQL service](https://pris.ly/ppg-early-access?utm_source=docs).
> [!NOTE]
> Note
>
> Postgres, PostgreSQL, and the Slonik Logo are trademarks or registered trademarks of the PostgreSQL Community Association of Canada and are used with permission.
## Related pages
- [`Build faster with Prisma + AI`](https://www.prisma.io/docs/ai): Build faster with Prisma and AI coding tools like Cursor, Codex, and ChatGPT
- [`Choose a setup path`](https://www.prisma.io/docs/getting-started): Choose the fastest path to start using Prisma ORM, Prisma Postgres, or Prisma Compute in a new or existing TypeScript project.
- [`CLI Overview`](https://www.prisma.io/docs/cli): The Prisma CLI is the command-line interface for Prisma ORM. Use it to initialize projects, generate Prisma Client, manage databases, run migrations, and more
- [`Console`](https://www.prisma.io/docs/console): Learn how to use the Console to manage and integrate Prisma products into your application.
- [`Guides`](https://www.prisma.io/docs/guides): A collection of guides for various tasks and workflows
# create-db (/docs/postgres/npx-create-db)
Location: Postgres > create-db
[`create-db`](https://create-db.prisma.io/) is an open-source CLI tool that provisions temporary [Prisma Postgres](/postgres) databases with a single command.
* **Fast setup:** No sign-up required to create a temporary production-ready Prisma Postgres database.
* **Lifetime:** Each database is available for *24 hours* by default.
* **Keep for free:** You can *claim* a database (via the URL provided in the CLI output) to make it permanent.
Prerequisites [#prerequisites]
To use `npx create-db`, you need:
* **Node.js** version `16` or higher (we recommend the latest LTS version).
* **npm** (comes with Node.js) to run `npx` commands.
**A Prisma Data Platform account is not required** to create a temporary database. However, if you want to keep a database permanently, you can claim it ([details below](#claiming-your-database)).
Option 1: Using the web interface (recommended) [#option-1-using-the-web-interface-recommended]
The [create-db web application](https://create-db.prisma.io) provides a browser-based interface for creating and managing your databases.
Key features: [#key-features]
* No installation required - works directly in your web browser
* Visual interface for database management
* Easy connection string display and copying
* Built-in schema viewer and editor
* Direct integration with Prisma Studio
* Simple database claiming workflow
Getting started: [#getting-started]
1. Visit [create-db.prisma.io](https://create-db.prisma.io) in your web browser
2. Click "Create with the web interface"
3. Modify your schema and interact with the Studio
4. Copy the provided connection strings for your project
5. Claim your database to make it permanent
Option 2: Using the CLI [#option-2-using-the-cli]
You can create a database using one of the following options:
Option 1: Quick start with default settings [#option-1-quick-start-with-default-settings]
Run the following command in your terminal:
#### bun
```bash
bunx create-db@latest
```
#### pnpm
```bash
pnpm dlx create-db@latest
```
#### yarn
```bash
yarn dlx create-db@latest
```
#### npm
```bash
npx create-db@latest
```
The selected migration is part of the URL, so you can link a teammate straight to it:
```
http://localhost:5555/#view=migrations&migration=3
```
Review schema changes [#review-schema-changes]
Select a migration to see the schema as that migration changed it:
* **NEW** (green): a model the migration added.
* **UPDATED** (amber): a model whose table changed, with `+`, `−`, and `~` glyphs on the affected fields and `before → after` pills for changed types, nullability, or defaults.
* **UNCHANGED** (dimmed): neighboring models drawn for context.
* Enum cards, and [relation](/orm/next/fundamentals/relations-and-joins) edges between visible models.
Amber always means the migration changed that model's table. A model that only gained a back-relation, where the foreign key lives on the other table, stays dimmed, and the new relation edge is emphasized instead.
By default the view shows only the models the migration touched plus their direct neighbors. Toggle **All models** to see the entire schema as it stood at that point in history, including unchanged enums.
Review executed SQL [#review-executed-sql]
Open the **SQL** panel to see the operations exactly as they ran, each labelled `additive` or `destructive`. This is the same SQL the migration runner executed; [How migrations work](/orm/next/migrations/how-migrations-work) explains how those operations are planned and checked.
Compare schema versions [#compare-schema-versions]
Open the **Schema** panel to see a Prisma-schema diff between the migration's before and after state. Long unchanged runs collapse into folds you can click to expand.
The diff is a projection built for stable comparison, not a copy of your source file. It uses a fixed field order and renders some attributes in expanded form, such as `@default(dbgenerated("autoincrement()"))`.
Browse the resulting data [#browse-the-resulting-data]
Your tables are in the same Studio session under **Tables**. Move between what a migration changed and the rows it produced without leaving the app. [Getting Started](/studio/getting-started) covers editing, filtering, and exporting.
How migration history works [#how-migration-history-works]
Prisma Next records every apply in two tables in your database:
* `prisma_contract.ledger`: one row per applied migration, with its name, apply time, executed operations, and the schema versions it moved between.
* `prisma_contract.contract`: each schema version, stored once and keyed by hash.
Studio joins the two to build the timeline and the diffs. Nothing is read from disk and nothing is reconstructed, which is why the history of any database you connect to is complete, including migrations you never ran yourself. These table names are also where to look if you inspect the history over SQL.
The hashes are the same ones that make Prisma Next migrations [a graph rather than a numbered list](/orm/next/migrations/the-migration-graph); the design story is in [Rethinking Database Migrations](https://www.prisma.io/blog/rethinking-database-migrations).
Availability [#availability]
| Surface | Available |
| ---------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------- |
| Local Studio (`npx prisma@dev studio`) | Yes, with `@prisma/studio-core` 0.32.0 or later |
| [Prisma Console](https://console.prisma.io/?utm_source=docs\&utm_medium=content\&utm_content=studio) (embedded Studio) | Yes, for databases with an applied Prisma Next migration history |
| Prisma ORM projects using `prisma migrate` | No |
In Prisma Console, open your database's Studio tab and select **Migrations**. The view is the same as local Studio, the selected migration is part of the Console URL, and no local setup is required.
The stable Prisma CLI (`prisma@latest`) currently bundles an older Studio without the Migrations view. Use `npx prisma@dev studio` until it lands in a stable release.
Limitations [#limitations]
* **Prisma Next on PostgreSQL only.** Prisma ORM projects using `prisma migrate` record history in a different format, and [Studio does not support MongoDB](/studio), where Prisma Next [stores its history differently](/orm/next/migrations/the-migration-graph#database-specific-details).
* **Applied migrations only.** A planned but unapplied migration is not in the database, so it does not appear.
* **An empty history hides the view.** The **Migrations** item appears only after the first applied migration.
* **Older databases lose the diffs.** If the database was migrated by a Prisma Next version that predates schema snapshots, the timeline and SQL panel still work, and the diff canvas asks you to update Prisma Next. Migrations applied after the update render normally.
## Related pages
- [`Getting Started`](https://www.prisma.io/docs/studio/getting-started): Learn how to set up and use Prisma Studio to manage your database
# Choose a setup path (/docs/next/getting-started)
Location: Next > Choose a setup path
Start with a quickstart if you want Prisma Next to create the app. Use the existing-project path if you already have an app and database.
Start a new project [#start-a-new-project]
#### bun
```bash
bunx create-prisma@next
```
#### pnpm
```bash
pnpm dlx create-prisma@next
```
#### yarn
```bash
yarn dlx create-prisma@next
```
#### npm
```bash
npx create-prisma@next
```
- [Quickstart with PostgreSQL](/next/quickstart/postgresql): Create the app, choose PostgreSQL, initialize the database, seed data, and run the first query.
- [Quickstart with MongoDB](/next/quickstart/mongodb): Create the app, choose MongoDB, start or connect to MongoDB, seed data, and run the first query.
Use Prisma Postgres [#use-prisma-postgres]
#### bun
```bash
bunx create-prisma@next
```
#### pnpm
```bash
pnpm dlx create-prisma@next
```
#### yarn
```bash
yarn dlx create-prisma@next
```
#### npm
```bash
npx create-prisma@next
```
- [Quickstart with Prisma Postgres](/prisma-postgres/quickstart/prisma-next): Create a Prisma Next app and let setup provision Prisma Postgres for the first run.
- [From the CLI](/next/prisma-postgres/from-the-cli): Start from the command line when you want the Prisma Postgres path without browsing Console first.
Add to an existing project [#add-to-an-existing-project]
#### bun
```bash
bunx prisma-next init
```
#### pnpm
```bash
pnpm dlx prisma-next init
```
#### yarn
```bash
yarn dlx prisma-next init
```
#### npm
```bash
npx prisma-next init
```
- [Add to PostgreSQL](/next/add-to-existing-project/postgresql): Add Prisma Next to an existing PostgreSQL app and infer a starter contract from the live schema.
- [Add to MongoDB](/next/add-to-existing-project/mongodb): Add Prisma Next to an existing MongoDB app and model the collections you want to query first.
After setup [#after-setup]
* Use the generated app scripts for the first run.
* Open `prisma-next.md` or the installed Prisma Next skills when you want agent-ready guidance inside the project.
* Change the starter contract when you are ready to model your own data.
* Open the [Prisma Next overview](/orm/next) when you want the concepts behind the setup.
# Introduction to Prisma Next (/docs/next)
Location: Introduction to Prisma Next
Prisma Next is a ground-up rebuild of Prisma ORM, covering the runtime, query APIs, migration flow, and project setup.
> [!NOTE]
> Prisma Next is in Early Access
>
> Prisma Next is the next major version of Prisma ORM, available now in Early Access. It’s the cutting-edge version of Prisma ORM and will become the future of Prisma, so we’d love for you to try it, explore what’s new, and [share your feedback in Discord](https://pris.ly/discord).
>
> If you want to stay on the current generally available version of Prisma ORM, you can continue with [Prisma 7](/getting-started).
Use Prisma Next when you want to try the new developer experience before it becomes the default Prisma ORM path.
#### bun
```bash
bunx create-prisma@next
```
#### pnpm
```bash
pnpm dlx create-prisma@next
```
#### yarn
```bash
yarn dlx create-prisma@next
```
#### npm
```bash
npx create-prisma@next
```
Start with the setup page when you want a guided first run.
- [Choose a setup path](/next/getting-started): Pick a new-project quickstart or add Prisma Next to an existing app.
What you can try [#what-you-can-try]
- [Quickstart with PostgreSQL](/next/quickstart/postgresql): Create a Prisma Next app, initialize the database, seed data, and run the first query.
- [Quickstart with MongoDB](/next/quickstart/mongodb): Create a Prisma Next app with a local MongoDB replica set or your own MongoDB deployment.
- [Add to PostgreSQL](/next/add-to-existing-project/postgresql): Add Prisma Next to an existing PostgreSQL app with `prisma-next init`.
- [Add to MongoDB](/next/add-to-existing-project/mongodb): Add Prisma Next to an existing MongoDB app and model the collections you want to query first.
- [Use Prisma Postgres](/prisma-postgres/quickstart/prisma-next): Create a Prisma Next app backed by Prisma Postgres.
Learn the fundamentals [#learn-the-fundamentals]
Once you are connected, the Fundamentals section teaches the everyday query patterns.
- [Reading data](/orm/next/fundamentals/reading-data): Filter with where, project with select, sort, and paginate.
- [Writing data](/orm/next/fundamentals/writing-data): Create, update, delete, upsert, and the bulk write variants.
- [Relations and joins](/orm/next/fundamentals/relations-and-joins): Read related records with include on PostgreSQL and MongoDB.
- [Transactions](/orm/next/fundamentals/transactions): Make several writes succeed or fail together.
- [Advanced queries](/orm/next/fundamentals/advanced-queries): The SQL builder and the MongoDB pipeline builder for shapes the ORM can't express.
Learn the concepts [#learn-the-concepts]
- [Prisma Next overview](/orm/next): Learn the core ideas behind contracts, emitted artifacts, runtime clients, query styles, and migrations.
## Related pages
- [`Build faster with Prisma + AI`](https://www.prisma.io/docs/ai): Build faster with Prisma and AI coding tools like Cursor, Codex, and ChatGPT
- [`Choose a setup path`](https://www.prisma.io/docs/getting-started): Choose the fastest path to start using Prisma ORM, Prisma Postgres, or Prisma Compute in a new or existing TypeScript project.
- [`CLI Overview`](https://www.prisma.io/docs/cli): The Prisma CLI is the command-line interface for Prisma ORM. Use it to initialize projects, generate Prisma Client, manage databases, run migrations, and more
- [`Console`](https://www.prisma.io/docs/console): Learn how to use the Console to manage and integrate Prisma products into your application.
- [`Guides`](https://www.prisma.io/docs/guides): A collection of guides for various tasks and workflows
# Deploy your first app (/docs/prisma-compute/deploy)
Location: Prisma Compute > Deploy your first app
[Prisma Compute](/compute) is serverless hosting for TypeScript apps. It runs your app right next to your Prisma Postgres database, so the trip from app to data stays short.
This is a quickstart: sign in, then deploy. There are two ways in:
* **To start fresh**, scaffold a new app and deploy it in one step with `create-prisma`. Follow [Option A](#option-a-scaffold-a-new-app-with-create-prisma).
* **To deploy an app you already have**, run a deploy from its directory. Follow [Option B](#option-b-deploy-a-project-you-already-have).
To learn more about how Compute works, see the [resource model](/compute#the-model) for a mental model.
Prerequisites [#prerequisites]
Before you start, make sure you have:
* **A JavaScript runtime.** Node.js 22.12 or newer for `npx`/`pnpm dlx`, or Bun for `bunx`.
* **A [Prisma Data Platform account](https://pris.ly/pdp).** Free to create, and it holds your workspace.
* **An app, if you are bringing your own.** Compute deploys **Next.js**, **Nuxt**, **Astro**, **Hono**, **NestJS**, **TanStack Start**, and plain **Bun** servers today, including **Elysia** (which runs on Bun). Skip this if you are scaffolding a new app below.
> [!NOTE]
> Next.js apps should set `output: "standalone"` in their Next.js config. The `create-prisma` template already sets this for you.
>
> ```ts title="next.config.ts"
> export default { output: "standalone" };
> ```
1. Sign in [#1-sign-in]
Sign in once. This is the only step that needs a human, because it opens your browser:
#### bun
```bash
bunx @prisma/cli@latest auth login
```
#### pnpm
```bash
pnpm dlx @prisma/cli@latest auth login
```
#### yarn
```bash
yarn dlx @prisma/cli@latest auth login
```
#### npm
```bash
npx @prisma/cli@latest auth login
```
It stores a session on your machine that every later command reads automatically, including a coding agent working in your directory. Confirm it any time with `auth whoami`.
Two shortcuts from here:
* In CI or a headless environment where no browser can open, use a [service token](/compute/getting-started#automation-and-ci) instead.
* To let an agent do the deploying for you, jump to [Hand it to your agent](#hand-it-to-your-agent).
2. Deploy your app [#2-deploy-your-app]
Both options finish in the same place: a live URL and a project you can deploy to again.
Option A: Scaffold a new app with create-prisma [#option-a-scaffold-a-new-app-with-create-prisma]
`create-prisma` builds a TypeScript app from a template, wires up Prisma, and can deploy it to Compute in the same run. Run it and answer the prompts:
#### bun
```bash
bunx create-prisma@latest
```
#### pnpm
```bash
pnpm dlx create-prisma@latest
```
#### yarn
```bash
yarn dlx create-prisma@latest
```
#### npm
```bash
npx create-prisma@latest
```
It asks for a template, a database provider, and a few options, then asks **"Deploy to Prisma Compute now?"**. Say yes, and the deploy step:
* signs you in, if you have not already
* creates a Prisma project for the app
* builds and deploys it, then prints the live URL
* provisions a Prisma Postgres database and wires it in, when you pick PostgreSQL and don't bring your own connection string
So your deployed app has a database from its first request.
To skip the prompts, pass your choices as flags. Compute deploys are available for the `hono`, `elysia`, `next`, and `tanstack-start` templates:
#### bun
```bash
bunx create-prisma@latest --name my-api --template hono --provider postgresql --deploy
```
#### pnpm
```bash
pnpm dlx create-prisma@latest --name my-api --template hono --provider postgresql --deploy
```
#### yarn
```bash
yarn dlx create-prisma@latest --name my-api --template hono --provider postgresql --deploy
```
#### npm
```bash
npx create-prisma@latest --name my-api --template hono --provider postgresql --deploy
```
When it finishes, it prints your live URL and adds a `compute:deploy` script so you can redeploy later. Then [verify the deployment](#3-verify-the-deployment).
Option B: Deploy a project you already have [#option-b-deploy-a-project-you-already-have]
From your app's directory, run:
#### bun
```bash
bunx @prisma/cli@latest app deploy
```
#### pnpm
```bash
pnpm dlx @prisma/cli@latest app deploy
```
#### yarn
```bash
yarn dlx @prisma/cli@latest app deploy
```
#### npm
```bash
npx @prisma/cli@latest app deploy
```
In one pass, the CLI:
1. **Detects your framework** from your project files, whether that is Next.js, Nuxt, Astro, Hono, NestJS, TanStack Start, or a plain Bun server. To choose it yourself, pass `--framework` (use `--framework bun` for a Bun or Elysia server).
2. **Sets up a project** the first time you deploy from this directory, then writes [`.prisma/local.json`](/compute/getting-started#link-an-existing-project) to pin the directory to that project. That file is a gitignored local cache, not committed config. If your team already has a project, [link it first](/compute/getting-started#link-an-existing-project).
3. **Resolves the target branch.** Inside a Git repository, the CLI uses your current Git branch name; otherwise it falls back to `main`. Pass `--branch {error}
) : users.length === 0 ? (No users yet. Create one using the API at /api/users
) : ({user.name || "No name"}
{user.email}
No users yet.
Features of the Prisma MCP server [#features-of-the-prisma-mcp-server]
By connecting the Prisma MCP server to ChatGPT, you can perform a variety of database management tasks directly from the chat interface. Here are some of the key features available:
* **Database management**: Create, list, and delete your Prisma Postgres databases.
* **Connection strings**: Generate, list, and revoke database connection strings.
* **Backup and recovery**: Create and list database backups, and restore a database from a backup.
* **Schema and Data interaction**: Execute SQL queries and introspect your database schema to understand its structure.
* **Workspace information**: Fetch details about your Prisma workspace.
Prerequisites [#prerequisites]
To use the Prisma MCP server with ChatGPT, you need access to ChatGPT's Developer Mode. This feature is available on specific ChatGPT plans. For the most up-to-date information on supported plans, please refer to the [official OpenAI documentation](https://platform.openai.com/docs/guides/developer-mode).
Enable Developer mode in ChatGPT [#enable-developer-mode-in-chatgpt]
1. Go to **Settings** in your ChatGPT account.
2. Click **Apps & Connectors**.
3. Scroll down and locate **Advanced settings**, then click it.
4. Toggle the **Developer mode** button on.
5. Click **Back**.
Add the Prisma MCP server [#add-the-prisma-mcp-server]
1. Make sure "Developer mode" is enabled.
2. Go to the **Apps & Connectors** section of your **Settings**.
3. On the top right, locate and click **Create**.
4. A "New Connector" popup will open. Fill in the text fields as follows:
* **Icon**: You can download and use the [Prisma favicon](https://www.prisma.io/favicon.ico).
* **Name**: `Prisma MCP server`
* **Description**: `Manage Prisma Postgres databases`
* **MCP Server URL**: `https://mcp.prisma.io/mcp`
* **Authentication**: `OAuth`
5. Check the "I trust this application" box and click **Create**.
You will be redirected to authenticate with your Prisma Data Platform account and choose your desired workspace. After successful authentication, you will be redirected back to ChatGPT.
Using the Prisma MCP server [#using-the-prisma-mcp-server]
Once Developer Mode is enabled and the Prisma MCP server is added, you can use it in your chats.
1. In ChatGPT, click the **+** icon to the left of the chat input box.
2. Click **More**.
3. Select the **Prisma MCP server** to add it to your chat as a connector.
Now you can use natural language prompts to manage your database. For example:
```
Create a DB called pet-app for me near Paris
```
## Related pages
- [`Agent Skills`](https://www.prisma.io/docs/ai/tools/skills): Give your AI coding agent up-to-date Prisma knowledge with installable skills
- [`Codex`](https://www.prisma.io/docs/ai/tools/codex): Learn how to install the Prisma Codex plugin and use Prisma MCP from Codex
- [`Cursor`](https://www.prisma.io/docs/ai/tools/cursor): Learn tips and best practices for using Prisma ORM with the Cursor AI code editor
- [`GitHub Copilot`](https://www.prisma.io/docs/ai/tools/github-copilot): Learn about the features available with GitHub Copilot and Prisma ORM, plus best practices and tips
- [`MCP server`](https://www.prisma.io/docs/ai/tools/mcp-server): Manage Prisma Postgres databases using LLMs with the Prisma Model-Context-Protocol (MCP) Server
# Codex (/docs/ai/tools/codex)
Location: AI > AI Tools > Codex
[Codex](https://developers.openai.com/codex/) is an AI coding agent from OpenAI. You can use the Prisma Codex plugin to give Codex Prisma-specific guidance and connect it to the Prisma MCP server for Prisma Postgres workflows.
The Prisma Codex plugin includes:
* Prisma CLI guidance
* Prisma Client API guidance
* Database setup guidance
* Prisma Postgres guidance
* Prisma ORM upgrade guidance
* The remote Prisma MCP server configuration
Install the Prisma Codex plugin [#install-the-prisma-codex-plugin]
Add the Prisma plugin marketplace to Codex:
```bash title="Terminal"
codex plugin marketplace add prisma/codex-plugin
```
Then restart Codex and install the plugin:
1. Open the Codex plugin directory.
2. Select the `Prisma` marketplace.
3. Install the `Prisma` plugin.
If your Codex CLI does not recognize the `plugin marketplace add` command, update Codex and try again.
Prisma MCP server [#prisma-mcp-server]
The plugin configures the official remote Prisma MCP server:
```json title="Prisma MCP server"
{
"mcpServers": {
"prisma": {
"type": "http",
"url": "https://mcp.prisma.io/mcp"
}
}
}
```
When Codex first uses the Prisma MCP server, it authenticates with Prisma Console and asks you to choose the workspace Codex can access.
With the Prisma MCP server, Codex can help you:
* List Prisma Postgres databases in your workspace.
* Create Prisma Postgres databases.
* Create backups and recovery databases.
* Create and manage connection strings.
* Execute SQL queries.
* Introspect database schemas.
Example prompts [#example-prompts]
After installing the plugin, try prompts like:
```text
Set up Prisma ORM in this project with the right database adapter.
```
```text
Use Prisma MCP to list my Prisma Postgres databases.
```
```text
Inspect this project and upgrade it to Prisma ORM 7.
```
```text
Use Prisma MCP to inspect my database schema and plan a migration.
```
Safety [#safety]
Prisma ORM includes safety checks for destructive commands run through AI coding agents. For example, Prisma blocks destructive commands such as `prisma migrate reset --force` unless the AI agent asks for explicit user consent and passes that consent back to Prisma.
This helps prevent accidental data loss when using Codex or another AI agent with Prisma projects.
## Related pages
- [`Agent Skills`](https://www.prisma.io/docs/ai/tools/skills): Give your AI coding agent up-to-date Prisma knowledge with installable skills
- [`ChatGPT`](https://www.prisma.io/docs/ai/tools/chatgpt): Learn how to add the Prisma MCP server to ChatGPT to manage your Prisma Postgres databases
- [`Cursor`](https://www.prisma.io/docs/ai/tools/cursor): Learn tips and best practices for using Prisma ORM with the Cursor AI code editor
- [`GitHub Copilot`](https://www.prisma.io/docs/ai/tools/github-copilot): Learn about the features available with GitHub Copilot and Prisma ORM, plus best practices and tips
- [`MCP server`](https://www.prisma.io/docs/ai/tools/mcp-server): Manage Prisma Postgres databases using LLMs with the Prisma Model-Context-Protocol (MCP) Server
# Cursor (/docs/ai/tools/cursor)
Location: AI > AI Tools > Cursor
[Cursor](https://www.cursor.com/) is an AI-powered code editor designed to boost productivity by automating repetitive coding tasks. When paired with Prisma, a robust and type-safe toolkit for database workflows, it becomes a powerful solution for managing and optimizing database schemas, queries, and data seeding.
This guide provides detailed instructions for effectively using Prisma with Cursor to:
* Configure the Prisma MCP server for database workflows.
* Define project-specific Prisma guidance with Project Rules or `AGENTS.md`.
* Use Cursor's context-aware capabilities.
* Generate schemas, queries, and seed data tailored to your database.
> [!NOTE]
> While this guide is focused on Cursor, these patterns should work with any AI editor. [Let us know on X](https://pris.ly/x?utm_source=docs\&utm_medium=inline_text) if you'd like us to create guides for your preferred tool!
Prisma Plugin [#prisma-plugin]
The [Prisma plugin for Cursor](https://cursor.com/marketplace/prisma) provides integration with the Prisma MCP server, various skills for working with Prisma ORM and Prisma Postgres, and automation for database development.
[Install the Prisma plugin for Cursor](https://cursor.com/marketplace/prisma)
Prisma MCP server [#prisma-mcp-server]
Prisma provides its own [Model Context Protocol](https://modelcontextprotocol.io/introduction) (MCP) server that lets you manage Prisma Postgres databases, inspect schemas, and execute SQL queries. Learn more about how you can add it to Cursor [here](/ai/tools/mcp-server#cursor). You can also add the Prisma MCP server to Cursor using the [one-click installation](https://docs.cursor.com/context/model-context-protocol#one-click-installation) by clicking on the following link:
[Install MCP Server](https://pris.ly/cursor-prisma-mcp-web)
This will prompt you to open the Cursor app in your browser. Once opened, you'll be guided to install the Prisma MCP server directly into your Cursor configuration.
Define project-specific rules [#define-project-specific-rules]
[Cursor Rules](https://docs.cursor.com/context/rules) provide persistent instructions to Cursor's Agent and Inline Edit. For Prisma projects, prefer one of these current options:
* **Project Rules**: Create a version-controlled `.cursor/rules/prisma.mdc` file for structured rules.
* **`AGENTS.md`**: Create an `AGENTS.md` file in the project root for simple, readable agent instructions.
The legacy `.cursorrules` file is still supported by Cursor, but Cursor recommends Project Rules for new projects.
Below is a concise Project Rule you can add to `.cursor/rules/prisma.mdc`:
```markdown title=".cursor/rules/prisma.mdc"
---
description: Prisma ORM and Prisma Postgres guidance
globs: **/*.{ts,tsx,js,jsx,prisma,json}
alwaysApply: false
---
- Prefer current Prisma documentation from https://www.prisma.io/docs and the Prisma LLM feed at https://pris.ly/llms.txt.
- For Prisma ORM v7 projects, use the `prisma-client` generator with an explicit `output`.
- Keep database connection URLs in `prisma.config.ts`; do not add `url = env("DATABASE_URL")` to the Prisma schema unless the project is intentionally using older Prisma ORM conventions.
- Use `prisma.config.ts` with `datasource.url = env("DATABASE_URL")` for Prisma CLI commands.
- Instantiate Prisma Client with the correct driver adapter for the database, for example `@prisma/adapter-pg` for PostgreSQL.
- When creating or managing Prisma Postgres databases, prefer the Prisma MCP server tools instead of guessing CLI/API steps.
- Before changing Prisma setup, inspect `package.json`, `prisma.config.*`, `schema.prisma`, existing generated client imports, and the installed Prisma version.
- Preserve existing Prisma Accelerate usage unless explicitly asked to migrate it.
## Prisma application best practices
- Validate inputs at API boundaries before calling Prisma Client.
- Use `select` or scoped `include` to avoid over-fetching data.
- Use transactions for multi-step writes that must succeed or fail together.
- Handle known Prisma errors intentionally, especially constraint and validation errors.
- Prefer integration tests against the same database provider used in production when testing Prisma behavior.
- Mock Prisma Client only for isolated unit tests where database behavior is not under test.
- Review generated migrations before applying them to shared or production environments.
- Avoid exposing database-specific errors directly to end users.
- Keep Prisma-related database access separate from unrelated business logic when it improves maintainability.
```
For a simpler repo-wide setup, you can paste the same guidance into `AGENTS.md`.
Using Cursor's context-aware capabilities [#using-cursors-context-aware-capabilities]
Cursor's [context-aware](https://docs.cursor.com/context/) capabilities let you add specific websites, files, folders or documentation to enhance its understanding of your project. By adding your `schema.prisma` file as context, you enable Cursor to generate more accurate queries, tests, and seed data based on your database schema.
Add Prisma docs llm.txt file as @Docs context [#add-prisma-docs-llmtxt-file-as-docs-context]
To improve Cursor's understanding of Prisma-related suggestions in your project, include the [`/llms.txt`](https://llmstxt.org/) markdown file as context. This file offers a concise overview, useful guidance, and links to detailed Prisma documentation—all optimized for LLM processing. Simply navigate to the [url](https://pris.ly/llms.txt) and add it as a `@Docs` resource in your Cursor configuration.
Adding additional Prisma documentation [#adding-additional-prisma-documentation]
Cursor may already have Prisma documentation available in its built-in docs context, but external documentation indexes can lag behind the latest Prisma release. Add the Prisma LLM feed explicitly when you need Cursor to follow the current recommended setup.
To stay updated with the latest changes or incorporate additional context, add these resources as `@Docs` context:
* [Prisma Changelog](https://www.prisma.io/changelog) for updates and new features.
* [Prisma Blog](https://www.prisma.io/blog) for practical guides and best practices.
To learn how to add and manage documentation context, visit the [Cursor documentation](https://docs.cursor.com/context/@-symbols/@-docs#docs).
Using schema as context [#using-schema-as-context]
Add your `schema.prisma` file (or the entire codebase) as context using the [`@Files`](https://docs.cursor.com/context/@-symbols/@-files) syntax before requesting queries, tests, or seed scripts. This allows Cursor to generate precise, schema-driven outputs such as queries, tests, and seed data. For example, in [Cursor Chat](https://docs.cursor.com/chat/overview), you can include your schema by typing `@Files` followed by adding your `schema.prisma` file.
Generating Prisma Schema [#generating-prisma-schema]
Cursor can generate Prisma schemas from high-level descriptions, enabling you to quickly establish a solid foundation for your database schema. By providing a clear and detailed prompt, Cursor creates Prisma schemas tailored to your requirements. Whether you need a general foundational schema or a highly specific one for detailed use cases, Cursor can deliver with precision. Here's an example prompt and its corresponding result:
> [!NOTE]
> If you run the prompts below, you may receive a different outputs because LLMs produce non-deterministic responses.
#### Prompt to generate Prisma schema
```text
"Create a Prisma schema for a SaaS app using PostgreSQL as a provider with `User`, `Organization`, and `Subscription` models, ensuring all models include `createdAt` and `updatedAt` DateTime fields with defaults, a soft-delete `deletedAt` field, and proper relationships between entities."
```
#### Result
```prisma title="schema.prisma"
generator client {
provider = "prisma-client"
output = "./generated"
}
datasource db {
provider = "postgresql"
}
model User {
id Int @id @default(autoincrement())
email String @unique
name String
password String
createdAt DateTime @default(now())
updatedAt DateTime @updatedAt
deletedAt DateTime?
organization Organization @relation(fields: [organizationId], references: [id])
organizationId Int
role UserRole @default(MEMBER)
}
model Organization {
id Int @id @default(autoincrement())
name String
slug String @unique
subscription Subscription?
users User[]
createdAt DateTime @default(now())
updatedAt DateTime @updatedAt
deletedAt DateTime?
}
model Subscription {
id Int @id @default(autoincrement())
organization Organization @relation(fields: [organizationId], references: [id])
organizationId Int @unique
plan SubscriptionPlan
status SubscriptionStatus @default(ACTIVE)
startDate DateTime
endDate DateTime?
createdAt DateTime @default(now())
updatedAt DateTime @updatedAt
deletedAt DateTime?
}
enum UserRole {
ADMIN
MEMBER
}
enum SubscriptionPlan {
FREE
BASIC
PREMIUM
ENTERPRISE
}
enum SubscriptionStatus {
ACTIVE
CANCELED
EXPIRED
PAST_DUE
}
```
Generating Prisma queries [#generating-prisma-queries]
Cursor can help you create queries tailored to your Prisma schema, whether for basic data retrieval or complex, optimized operations. To get the best results, focus on writing clear, specific prompts that define your requirements, such as the fields to include, conditions to apply, and relationships to traverse. This ensures Cursor generates accurate, performant, and type-safe queries. Here's an example prompt and its resulting query:
#### Prompt to generate a database query
```text
"Generate a query to retrieve all User records associated with an Organization that has an `active` Subscription, while excluding any records where the deletedAt field is set."
```
#### Result
```typescript
const activeUsers = await prisma.user.findMany({
where: {
deletedAt: null,
organization: {
deletedAt: null,
subscription: {
deletedAt: null,
status: "ACTIVE",
},
},
},
include: {
organization: {
include: {
subscription: true,
},
},
},
orderBy: {
createdAt: "desc",
},
skip: 0,
take: 10,
});
```
Creating seed files with Cursor [#creating-seed-files-with-cursor]
Writing seed scripts can be a tedious process, but Cursor simplifies it by quickly generating structured and organized seed code. By providing clear instructions, you can guide Cursor to create scripts that populate your database with realistic data, including handling relationships and complex structures defined in your schema. Here's an example prompt and its resulting seed script:
#### Prompt to seed the database
```text
"Generate code to populate the Prisma schema with realistic data for the User, Organization, and Subscription models, ensuring all necessary fields are included."
```
#### Result
```ts title="seed.ts"
import {
PrismaClient,
UserRole,
SubscriptionPlan,
SubscriptionStatus,
} from "../prisma/generated/client";
const prisma = new PrismaClient();
async function main() {
// Clear existing data
await prisma.user.deleteMany();
await prisma.subscription.deleteMany();
await prisma.organization.deleteMany();
const organizations = [
{
name: "Tech Innovators",
slug: "tech-innovators",
subscription: {
plan: SubscriptionPlan.ENTERPRISE,
status: SubscriptionStatus.ACTIVE,
startDate: new Date("2024-01-01"),
},
users: [
{
name: "Emma Thompson",
email: "emma@techinnovators.com",
role: UserRole.ADMIN,
password: "password123",
},
{
name: "Michael Chen",
email: "michael@techinnovators.com",
role: UserRole.MEMBER,
password: "password123",
},
],
},
{
name: "Digital Solutions",
slug: "digital-solutions",
subscription: {
plan: SubscriptionPlan.PREMIUM,
status: SubscriptionStatus.ACTIVE,
startDate: new Date("2024-01-15"),
},
users: [
{
name: "Sarah Wilson",
email: "sarah@digitalsolutions.com",
role: UserRole.ADMIN,
password: "password123",
},
{
name: "James Miller",
email: "james@digitalsolutions.com",
role: UserRole.MEMBER,
password: "password123",
},
],
},
{
name: "Cloud Systems",
slug: "cloud-systems",
subscription: {
plan: SubscriptionPlan.BASIC,
status: SubscriptionStatus.ACTIVE,
startDate: new Date("2024-02-01"),
},
users: [
{
name: "David Garcia",
email: "david@cloudsystems.com",
role: UserRole.ADMIN,
password: "password123",
},
{
name: "Lisa Wang",
email: "lisa@cloudsystems.com",
role: UserRole.MEMBER,
password: "password123",
},
],
},
{
name: "Data Analytics Co",
slug: "data-analytics",
subscription: {
plan: SubscriptionPlan.PREMIUM,
status: SubscriptionStatus.ACTIVE,
startDate: new Date("2024-01-10"),
},
users: [
{
name: "Alex Johnson",
email: "alex@dataanalytics.com",
role: UserRole.ADMIN,
password: "password123",
},
{
name: "Rachel Kim",
email: "rachel@dataanalytics.com",
role: UserRole.MEMBER,
password: "password123",
},
],
},
{
name: "Smart Solutions",
slug: "smart-solutions",
subscription: {
plan: SubscriptionPlan.FREE,
status: SubscriptionStatus.ACTIVE,
startDate: new Date("2024-02-15"),
},
users: [
{
name: "Daniel Brown",
email: "daniel@smartsolutions.com",
role: UserRole.ADMIN,
password: "password123",
},
{
name: "Maria Rodriguez",
email: "maria@smartsolutions.com",
role: UserRole.MEMBER,
password: "password123",
},
],
},
];
for (const org of organizations) {
const createdOrg = await prisma.organization.create({
data: {
name: org.name,
slug: org.slug,
subscription: {
create: {
plan: org.subscription.plan,
status: org.subscription.status,
startDate: org.subscription.startDate,
},
},
},
});
for (const user of org.users) {
await prisma.user.create({
data: {
name: user.name,
email: user.email,
password: user.password,
role: user.role,
organizationId: createdOrg.id,
},
});
}
}
console.log("Seed data created successfully");
}
main()
.catch((e) => {
console.error(e);
process.exit(1);
})
.finally(async () => {
await prisma.$disconnect();
});
```
Using the Prisma VS Code extension to manage your database [#using-the-prisma-vs-code-extension-to-manage-your-database]
The [Prisma VS Code extension](https://marketplace.visualstudio.com/items?itemName=Prisma.prisma) is a powerful tool for building applications with [Prisma Postgres](/postgres). You can also use it in Cursor by installing the extension. It provides a dedicated UI for managing Prisma Postgres instances, both local and remote, making it easy to view, create, and delete instances, push local databases to the cloud, and visualize your schema.
Database management UI [#database-management-ui]
With its built-in database management interface, the [Prisma VS Code extension](/guides/postgres/vscode) lets you easily work with local and remote Prisma Postgres instances from inside your editor.
Workflows [#workflows]
The UI enables the following workflows:
* Authenticate with the [Prisma Console](https://console.prisma.io/?utm_source=docs\&utm_medium=content\&utm_content=ai)
* View, create and delete Prisma Postgres instances (local & remote)
* "Push to cloud": Easily deploy a local Prisma Postgres instance
* View and edit data via an embedded Prisma Studio
* Visualize your database schema
Usage [#usage]
To manage Prisma Postgres instances via the UI in the Prisma VS Code extension:
1. Ensure you have the latest version of the [Prisma VS Code extension](https://marketplace.visualstudio.com/items?itemName=Prisma.prisma) installed
2. Find the Prisma logo in the **Activity Bar**
3. Click the **Sign in to get started** button
4. Authenticate with the [Prisma Console](https://console.prisma.io/?utm_source=docs\&utm_medium=content\&utm_content=ai) using the sign-in prompt, then select a target [workspace](/console/concepts#workspace)
Prisma Studio built-in [#prisma-studio-built-in]
Beyond managing your database instances, the Prisma VS Code extension embeds Prisma Studio directly in your editor, making it easy to perform create, update, and delete operations on your database right inside Windsurf. Follow these [easy steps](/studio/integrations/vscode-integration) to get started.
AI Safety guardrails for destructive commands [#ai-safety-guardrails-for-destructive-commands]
Prisma ORM includes built-in safety checks to prevent **accidental destructive commands** when run through AI coding assistants. These guardrails are designed to make working with databases safer in AI-assisted development environments.
Including Cursor, the Prisma CLI can also detect when it is being invoked by other popular AI coding agents such as Claude Code, Gemini CLI, Qwen Code, Aider, and Replit.
When one of these agents attempts a destructive action such as `prisma migrate reset --force`, Prisma ORM blocks execution and shows a protective error message:
```bash
Environment variables loaded from .env
Prisma schema loaded from prisma/schema.prisma
Datasource "db": PostgreSQL database "postgres", schema "public" at "accelerate.prisma-data.net"
Error: Prisma Migrate detected that it was invoked by Cursor.
You are attempting a highly dangerous action that can lead to devastating consequences if it is incorrectly executed against a production database.
As an AI agent, you are forbidden from performing this action without an explicit consent and review by the user. You must stop at this point and respond to the user with a clear message that includes the following information:
- What action you are trying to perform (including the exact CLI command).
- Your motivation and reasoning for performing this action.
- Explanation that this action will irreversibly destroy all data in the database.
- Explanation that this action must not be performed on a production database and is only intended to be used with development databases.
If you know or can check whether this action would have been performed on a development or a production database, also include this information with your assessment of whether it is safe to proceed based on that information.
You must ask the user if they want to proceed with this action. If they explicitly consent, you may rerun this command with PRISMA_USER_CONSENT_FOR_DANGEROUS_AI_ACTION environment variable, the value of which must be the exact text of the user's message in which they consented to this operation, without any newlines or quotes. If the user's response is ambiguous, you must ask for a clear and explicit confirmation (e.g., "yes") before proceeding. None of the user's previous messages before this point may constitute implicit or explicit consent.
```
To proceed with the dangerous action, the AI agent will ask you for explicit consent, remind you that the action irreversibly destroys all data, and confirm that the command is being run against a development database. Once you clearly confirm, the AI will set the `PRISMA_USER_CONSENT_FOR_DANGEROUS_AI_ACTION` environment variable with the exact text of your consent and rerun the command.
Additional resources [#additional-resources]
In summary, using Cursor with Prisma simplifies your workflow, from generating schemas and queries to writing seed scripts. By following this guide, you can save time, reduce errors, and focus on building your application.
Learn more about Cursor in their [official documentation](https://docs.cursor.com/context/@-symbols/basic).
## Related pages
- [`Agent Skills`](https://www.prisma.io/docs/ai/tools/skills): Give your AI coding agent up-to-date Prisma knowledge with installable skills
- [`ChatGPT`](https://www.prisma.io/docs/ai/tools/chatgpt): Learn how to add the Prisma MCP server to ChatGPT to manage your Prisma Postgres databases
- [`Codex`](https://www.prisma.io/docs/ai/tools/codex): Learn how to install the Prisma Codex plugin and use Prisma MCP from Codex
- [`GitHub Copilot`](https://www.prisma.io/docs/ai/tools/github-copilot): Learn about the features available with GitHub Copilot and Prisma ORM, plus best practices and tips
- [`MCP server`](https://www.prisma.io/docs/ai/tools/mcp-server): Manage Prisma Postgres databases using LLMs with the Prisma Model-Context-Protocol (MCP) Server
# GitHub Copilot (/docs/ai/tools/github-copilot)
Location: AI > AI Tools > GitHub Copilot
GitHub Copilot is an AI coding assistant that speeds up your Prisma ORM workflows, so you spend less time on boilerplate and more on data modeling, querying, and collaboration. With the GitHub Copilot extension in your editor, you can:
* Get Prisma-aware code suggestions as you edit your schema or invoke the client.
* Chat with Copilot about modeling patterns, troubleshoot queries, or explore migration strategies.
* Run common Prisma CLI commands (e.g. `prisma migrate dev`, `prisma db push`) via Copilot's command-palette interface.
* Scaffold Prisma schema models and generate Prisma Client code and run migrations directly from the Copilot chat interface.
GitHub Copilot allows you to query the official docs via the [**Prisma for GitHub Copilot** extension](https://github.com/apps/prisma-for-github-copilot) and also perform automated [actions in VS Code agent mode](/guides/postgres/vscode#agent-mode), such as scaffolding a Prisma schema, running seed scripts, and creating a production-ready Prisma Postgres database.
Query Prisma docs with the Prisma for GitHub Copilot extension [#query-prisma-docs-with-the-prisma-for-github-copilot-extension]
The [Prisma for GitHub Copilot extension](https://github.com/apps/prisma-for-github-copilot) lets you fetch Prisma documentation directly in GitHub Copilot Chat. You can look up schema syntax, client methods, migration commands, and more from your editor.
How to enable the extension [#how-to-enable-the-extension]
1. Install the **Prisma for Copilot** from the GitHub Marketplace.
2. Ensure [GitHub Copilot Chat is installed](https://docs.github.com/en/copilot/using-github-copilot/copilot-chat/asking-github-copilot-questions-in-your-ide) and active in your code editor.
3. Open a file in your workspace and launch Copilot Chat.
4. In chat, prefix your question with the `@prisma-for-copilot` keyword:
```
@prisma-for-copilot How do I define a one-to-many relation?
```
1. Install the [Prisma for GitHub Copilot](https://github.com/apps/prisma-for-github-copilot) extension.
2. Open your IDE.
3. Install the [GitHub Copilot Chat extension](https://docs.github.com/en/copilot/managing-copilot/configure-personal-settings/installing-the-github-copilot-extension-in-your-environment).
4. Open Copilot Chat and switch to [**Ask** mode](https://code.visualstudio.com/docs/copilot/chat/chat-ask-mode).
5. Ask: "`@prisma-for-github-copilot` How do I define a one-to-many relation?" (If the `@prisma-for-github-copilot` namespace doesn't show up after a few seconds, reload the chat.)
6. When prompted, authorize the Prisma app in your browser, then return to the chat.
7. After returning to the chat, resend the question.
8. Copilot returns the answer pulled straight from the Prisma docs.
Use GitHub Copilot's agent features [#use-github-copilots-agent-features]
GitHub Copilot Chat offers an **Agent** mode in VS Code that can run Prisma commands. You can use the agent chat to:
* Run and inspect migrations.
* Generate Prisma Client code.
* Create a new Prisma Postgres database and update your `.env` file.
You can type `Create a database named test-db and add its connection string to the .env file.` in the Copilot chat, and it will automatically create a new database named `test-db` and add the connection string to your `.env` file. To learn more about this, visit our [VS Code agent mode documentation](/guides/postgres/vscode#agent-mode).
Customize GitHub Copilot with copilot-instructions.md [#customize-github-copilot-with-copilot-instructionsmd]
You can tailor Copilot Chat's behavior in your repository by [adding a `.github/copilot-instructions.md` file](https://docs.github.com/en/copilot/customizing-copilot/adding-repository-custom-instructions-for-github-copilot). This file injects your guidelines into every Copilot Chat session.
This will prompt you to open the Cursor app in your browser. Once opened, you'll be guided to install the Prisma MCP server directly into your Cursor configuration.
Add via Cursor Settings UI [#add-via-cursor-settings-ui]
When opening the **Cursor Settings**, you can add the Prisma MCP Server as follows:
1. Select **MCP** in the settings sidenav
2. Click **+ Add new global MCP server**
3. Add the `Prisma` snippet to the `mcpServers` JSON object:
```json title="Cursor MCP configuration"
{
"mcpServers": {
"Prisma": {
"url": "https://mcp.prisma.io/mcp"
}
}
}
```
Global configuration [#global-configuration]
Adding it via the **Cursor Settings** settings will modify the global `~/.cursor/mcp.json` config file. In this case, the Prisma MCP server will be available in *all* your Cursor projects:
```json title="~/.cursor/mcp.json"
{
"mcpServers": {
"Prisma": {
"url": "https://mcp.prisma.io/mcp"
}
// other MCP servers
}
}
```
Project configuration [#project-configuration]
If you want the Prisma MCP server to be available only in specific Cursor projects, add it to the Cursor config of the respective project inside the `.cursor` directory in the project's root:
```json title=".cursor/mcp.json"
{
"mcpServers": {
"Prisma": {
"url": "https://mcp.prisma.io/mcp"
}
// other MCP servers
}
}
```
Windsurf [#windsurf]
To learn more about Windsurf's MCP integration, check out the [Windsurf MCP docs](https://docs.windsurf.com/windsurf/cascade/mcp).
Add via Windsurf MCP Plugin Store (Recommended) [#add-via-windsurf-mcp-plugin-store-recommended]
Use the Prisma MCP plugin from the [Windsurf MCP Plugin Store](https://docs.windsurf.com/windsurf/cascade/mcp#adding-a-new-mcp-plugin). Follow [the steps here](/ai/tools/windsurf#add-prisma-mcp-server-via-windsurf-plugins) to add the Prisma MCP plugin in Windsurf. This is the simplest and recommended way to add the Prisma MCP server to Windsurf.
Add via Windsurf Settings UI [#add-via-windsurf-settings-ui]
When opening the **Windsurf Settings** (via **Windsurf - Settings** > **Advanced Settings or Command Palette** > **Open Windsurf Settings Page**), you can add the Prisma MCP Server as follows:
1. Select **Cascade** in the settings sidenav
2. Click **Add Server**
3. Add the `Prisma` snippet to the `mcpServers` JSON object:
```json title="Windsurf MCP configuration"
{
"mcpServers": {
"Prisma": {
"url": "https://mcp.prisma.io/mcp"
}
}
}
```
Global configuration [#global-configuration-1]
Adding it via the **Windsurf Settings** will modify the global `~/.codeium/windsurf/mcp_config.json` config file. Alternatively, you can also manually add it to that file:
```json title="~/.codeium/windsurf/mcp_config.json"
{
"mcpServers": {
"Prisma": {
"url": "https://mcp.prisma.io/mcp"
}
// other MCP servers
}
}
```
Warp [#warp]
You can add the Prisma MCP to Warp as a globally available tool. First, [visit your MCP settings](https://docs.warp.dev/knowledge-and-collaboration/mcp#how-to-access-mcp-server-settings) and click **+ Add**. From here, you can configure the Prisma MCP server as JSON:
```json title="Warp MCP configuration"
{
"Prisma": {
"url": "https://mcp.prisma.io/mcp"
}
}
```
Hit **Save** and ensure the MCP server is running from your MCP settings panel. Then, open a new terminal window and ask Warp to manage your Prisma database. It should reach for the Prisma MCP server automatically.
To learn more about Warp's MCP integration, visit the [Warp MCP docs](https://docs.warp.dev/knowledge-and-collaboration/mcp).
Claude Code [#claude-code]
Claude Code is a terminal-based AI tool where you can add MCP servers using the `claude mcp add` command:
```bash title="Claude Code"
claude mcp add --transport http prisma https://mcp.prisma.io/mcp
```
Learn more in the [Claude Code MCP docs](https://docs.anthropic.com/en/docs/agents-and-tools/claude-code/tutorials#configure-mcp-servers).
Claude Desktop only [#claude-desktop-only]
Follow the instructions in the [Claude Desktop MCP docs](https://modelcontextprotocol.io/quickstart/user#2-add-the-filesystem-mcp-server) to create the required configuration file:
* macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
* Windows: `%APPDATA%\Claude\claude_desktop_config.json`
Then add the JSON snippet to that configuration file:
```json title="Claude Desktop configuration"
{
"mcpServers": {
"Prisma": {
"url": "https://mcp.prisma.io/mcp"
}
// other MCP servers
}
}
```
Claude Desktop & Web [#claude-desktop--web]
Alternatively, you can add the Prisma MCP server as an [integration](https://www.anthropic.com/news/integrations):
1. In a new chat, find the **Connect apps** field in the main Claude UI below the input prompt field
2. Click **+ Add integration**
3. Enter the following:
* **Integration name**: `Prisma Postgres`
* **Integration URL**: `https://mcp.prisma.io/mcp`
1. Click **Add**
ChatGPT [#chatgpt]
You can add the Prisma MCP server to ChatGPT to manage your Prisma Postgres databases using natural language. Learn more about setting it up in our [ChatGPT integration guide](/ai/tools/chatgpt).
Gemini CLI [#gemini-cli]
Gemini CLI can add the Prisma MCP server using HTTP transport:
```bash title="Gemini CLI"
gemini mcp add --transport http Prisma https://mcp.prisma.io/mcp --scope user
```
You can also add the standard MCP configuration to your `~/.gemini/settings.json` file:
```json title="~/.gemini/settings.json"
{
"mcpServers": {
"Prisma": {
"url": "https://mcp.prisma.io/mcp"
}
}
}
```
AI Safety guardrails for destructive commands [#ai-safety-guardrails-for-destructive-commands]
Prisma ORM includes built-in safety checks to prevent **accidental destructive commands** when run through AI coding assistants. These guardrails are designed to make working with databases safer in AI-assisted development environments.
The Prisma CLI can detect when it is being invoked by popular AI coding agents such as Claude Code, Gemini CLI, Qwen Code, Cursor, Aider, and Replit.
When one of these agents attempts a destructive action such as `prisma migrate reset --force`, Prisma ORM blocks execution and shows a protective error message:
```bash title="Destructive command guardrail"
Environment variables loaded from .env
Prisma schema loaded from prisma/schema.prisma
Datasource "db": PostgreSQL database "postgres", schema "public" at "accelerate.prisma-data.net"
Error: Prisma Migrate detected that it was invoked by Cursor.
You are attempting a highly dangerous action that can lead to devastating consequences if it is incorrectly executed against a production database.
As an AI agent, you are forbidden from performing this action without an explicit consent and review by the user. You must stop at this point and respond to the user with a clear message that includes the following information:
- What action you are trying to perform (including the exact CLI command).
- Your motivation and reasoning for performing this action.
- Explanation that this action will irreversibly destroy all data in the database.
- Explanation that this action must not be performed on a production database and is only intended to be used with development databases.
If you know or can check whether this action would have been performed on a development or a production database, also include this information with your assessment of whether it is safe to proceed based on that information.
You must ask the user if they want to proceed with this action. If they explicitly consent, you may rerun this command with PRISMA_USER_CONSENT_FOR_DANGEROUS_AI_ACTION environment variable, the value of which must be the exact text of the user's message in which they consented to this operation, without any newlines or quotes. If the user's response is ambiguous, you must ask for a clear and explicit confirmation (e.g., "yes") before proceeding. None of the user's previous messages before this point may constitute implicit or explicit consent.
```
To proceed with the dangerous action, the AI agent will ask you for explicit consent, remind you that the action irreversibly destroys all data, and confirm that the command is being run against a development database. Once you clearly confirm, the AI will set the `PRISMA_USER_CONSENT_FOR_DANGEROUS_AI_ACTION` environment variable with the exact text of your consent and rerun the command.
## Related pages
- [`Agent Skills`](https://www.prisma.io/docs/ai/tools/skills): Give your AI coding agent up-to-date Prisma knowledge with installable skills
- [`ChatGPT`](https://www.prisma.io/docs/ai/tools/chatgpt): Learn how to add the Prisma MCP server to ChatGPT to manage your Prisma Postgres databases
- [`Codex`](https://www.prisma.io/docs/ai/tools/codex): Learn how to install the Prisma Codex plugin and use Prisma MCP from Codex
- [`Cursor`](https://www.prisma.io/docs/ai/tools/cursor): Learn tips and best practices for using Prisma ORM with the Cursor AI code editor
- [`GitHub Copilot`](https://www.prisma.io/docs/ai/tools/github-copilot): Learn about the features available with GitHub Copilot and Prisma ORM, plus best practices and tips
# Agent Skills (/docs/ai/tools/skills)
Location: AI > AI Tools > Agent Skills
AI coding agents often struggle with Prisma 7 -they generate outdated v6 patterns, hallucinate APIs, and miss breaking changes like ESM-only support and required driver adapters. **Prisma Skills** fix this by giving your agent accurate, version-specific knowledge it can reference automatically.
Skills are packaged instructions that follow the open [Agent Skills](https://agentskills.io/) format. Once installed, your agent uses them whenever it detects a relevant task -no prompting required.
Install [#install]
Add all Prisma skills to your project:
#### bun
```bash
bunx skills add prisma/skills
```
#### pnpm
```bash
pnpm dlx skills add prisma/skills
```
#### yarn
```bash
yarn dlx skills add prisma/skills
```
#### npm
```bash
npx skills add prisma/skills
```
Or install only the ones you need:
#### bun
```bash
bunx skills add prisma/skills --skill prisma-client-api
```
#### pnpm
```bash
pnpm dlx skills add prisma/skills --skill prisma-client-api
```
#### yarn
```bash
yarn dlx skills add prisma/skills --skill prisma-client-api
```
#### npm
```bash
npx skills add prisma/skills --skill prisma-client-api
```
> [!NOTE]
> Skills are compatible with any agent that supports the [Agent Skills](https://agentskills.io/) format, including Claude Code, Cursor, and others.
Available skills [#available-skills]
prisma-cli [#prisma-cli]
Complete reference for all Prisma CLI commands in v7.
Covers `init`, `generate`, `dev`, `migrate dev`, `migrate deploy`, `db push`, `db pull`, `db seed`, `studio`, and more. Use this when your agent needs to run Prisma commands, set up projects, or manage migrations.
prisma-client-api [#prisma-client-api]
Comprehensive Prisma Client API reference for v7.
Covers CRUD operations (`findMany`, `create`, `update`, `delete`), query options (`select`, `include`, `omit`, `orderBy`), filter operators, transactions (`$transaction`), raw queries (`$queryRaw`, `$executeRaw`), and client methods (`$connect`, `$disconnect`, `$extends`).
prisma-upgrade-v7 [#prisma-upgrade-v7]
Step-by-step migration guide from Prisma v6 to v7.
Covers ESM module configuration, required driver adapters, the new `prisma.config.ts` file, manual environment variable loading, and removed features (middleware, metrics, deprecated CLI flags). Essential for upgrading existing projects.
prisma-database-setup [#prisma-database-setup]
Guides for configuring Prisma with different database providers.
Covers PostgreSQL, Prisma Postgres, MySQL/MariaDB, SQLite, MongoDB, SQL Server, and CockroachDB. Use this when setting up a new project or switching databases.
prisma-postgres [#prisma-postgres]
Prisma Postgres workflows across Console, CLI, Management API, and SDK.
Covers `npx create-db`, Console operations, programmatic provisioning via the Management API, and the `@prisma/management-api-sdk`. Use this when creating or managing Prisma Postgres databases.
Available skills for Prisma Next [#available-skills-for-prisma-next]
[Prisma Next](/orm/next) ships its own skill set, versioned with the product. Projects scaffolded with `create-prisma` install them automatically; add them to an existing project with:
#### bun
```bash
bunx skills add prisma/prisma-next/skills
```
#### pnpm
```bash
pnpm dlx skills add prisma/prisma-next/skills
```
#### yarn
```bash
yarn dlx skills add prisma/prisma-next/skills
```
#### npm
```bash
npx skills add prisma/prisma-next/skills
```
| Skill | What your agent uses it for |
| ------------------------------- | ---------------------------------------------------------------------------------------------------- |
| `prisma-next` | Route a general Prisma Next question to the right skill below |
| `prisma-next-quickstart` | First-touch setup and orientation after scaffolding |
| `prisma-next-contract` | Edit the schema: models, relations, enums, namespaces, extensions, then emit the contract |
| `prisma-next-queries` | Write queries in the right lane: the ORM API, the SQL query builder, or the MongoDB pipeline builder |
| `prisma-next-runtime` | Wire `db.ts`, middleware, and environment configuration |
| `prisma-next-migrations` | Author migrations: `db update` vs `migration plan`, and filling in data transforms |
| `prisma-next-migration-review` | Review migrations on deploy and reconcile concurrent migration work |
| `prisma-next-build` | Integrate with the build tool (the Vite contract-emit plugin today) |
| `prisma-next-debug` | Read structured error envelopes (`PN-*` codes) and route to the fix |
| `prisma-next-upgrade` | Move a project between Prisma Next releases |
| `prisma-next-extension-upgrade` | Upgrade extension packs alongside the core |
| `prisma-next-feedback` | File a bug or feature request, or route a question to the Prisma Discord |
The Prisma Next docs reference these in each page's "Prompt your coding agent" section, with prompts that map to the page you are reading.
Useful commands [#useful-commands]
List available skills before installing:
#### bun
```bash
bunx skills add prisma/skills --list
```
#### pnpm
```bash
pnpm dlx skills add prisma/skills --list
```
#### yarn
```bash
yarn dlx skills add prisma/skills --list
```
#### npm
```bash
npx skills add prisma/skills --list
```
List skills currently installed in your project:
#### bun
```bash
bunx skills list
```
#### pnpm
```bash
pnpm dlx skills list
```
#### yarn
```bash
yarn dlx skills list
```
#### npm
```bash
npx skills list
```
Example prompts [#example-prompts]
Once skills are installed, your agent will use them automatically. Try prompts like:
* *"Set up Prisma with PostgreSQL in this project"*
* *"Upgrade this project from Prisma 6 to 7"*
* *"Write a query to find all users with their posts"*
* *"Run migrations for production"*
* *"Create a new Prisma Postgres database"*
Learn more [#learn-more]
* [Prisma Skills on skills.sh](https://skills.sh/prisma/skills) - browse available skills and install instructions
* [GitHub repository](https://github.com/prisma/skills) - source code, contribution guidelines, and skill structure
* [Agent Skills format](https://agentskills.io/) - the open standard behind skills
## Related pages
- [`ChatGPT`](https://www.prisma.io/docs/ai/tools/chatgpt): Learn how to add the Prisma MCP server to ChatGPT to manage your Prisma Postgres databases
- [`Codex`](https://www.prisma.io/docs/ai/tools/codex): Learn how to install the Prisma Codex plugin and use Prisma MCP from Codex
- [`Cursor`](https://www.prisma.io/docs/ai/tools/cursor): Learn tips and best practices for using Prisma ORM with the Cursor AI code editor
- [`GitHub Copilot`](https://www.prisma.io/docs/ai/tools/github-copilot): Learn about the features available with GitHub Copilot and Prisma ORM, plus best practices and tips
- [`MCP server`](https://www.prisma.io/docs/ai/tools/mcp-server): Manage Prisma Postgres databases using LLMs with the Prisma Model-Context-Protocol (MCP) Server
# Tabnine (/docs/ai/tools/tabnine)
Location: AI > AI Tools > Tabnine
[Tabnine](https://www.tabnine.com/) is a an AI software development platform that comes as an [extension](https://www.tabnine.com/install/) for your IDE (e.g. VS Code, WebStorm, IntelliJ, ...).
Overview [#overview]
It helps developers write code faster by:
* Providing context-aware [code completion](https://docs.tabnine.com/main/getting-started/getting-the-most-from-tabnines-code-completion) suggestions in the editor for small, repetitive coding tasks
* Offering an integrated [chat](https://docs.tabnine.com/main/getting-started/getting-the-most-from-tabnine-chat) for higher-level tasks and detailed instructions
Why use Prisma ORM with Tabnine? [#why-use-prisma-orm-with-tabnine]
AI editors like Tabnine are powerful tools that can drastically improve developer productivity. It works especially well with the following workflows:
* Data modeling and database schema design
* Constructing and optimizing database queries
* Generating CRUD functionality and other boilerplate code
* Generating plain SQL queries that can be used with [TypedSQL](/orm/prisma-client/using-raw-sql/typedsql)
* Generating code for unit and integrations tests
* Guiding through major refactorings
* Generating seeding scripts
Leveraging the Prisma schema [#leveraging-the-prisma-schema]
Because Prisma has its own [schema](/orm/prisma-schema/overview), Tabnine can understand the basic shape of your data and help you write code for the other parts of your stack.
We therefore recommend that you start out by defining your Prisma schema and then use Tabnine to build the application layer around it (including API calls, DTOs, business logic, 3rd party integrations, ...).
Data modeling and database schema design [#data-modeling-and-database-schema-design]
How Tabnine helps [#how-tabnine-helps]
Designing a database schema from scratch involves a lot of boilerplate and can be time-consuming.
Tabnine can accelerate this process by:
* Generating boilerplate for models, indexes, constraints, and relations.
* Keeping the schema consistent by sticking to naming and other conventions.
* Auto-completing model and field definitions based on common database patterns.
* Suggesting relationships and field types based on naming conventions.
Example: Defining a Prisma schema [#example-defining-a-prisma-schema]
Prompt [#prompt]
*Define a Prisma schema for a SaaS application with User, Organization, and Subscription models. Ensure relationships are properly set up.*
Generated code [#generated-code]
```prisma
generator client {
provider = "prisma-client"
output = "./generated"
}
datasource db {
provider = "postgresql"
}
model User {
id Int @id @default(autoincrement())
createdAt DateTime @default(now())
updatedAt DateTime @updatedAt
email String @unique
name String
organization Organization @relation(fields: [organizationId], references: [id])
organizationId Int
}
model Organization {
id Int @id @default(autoincrement())
name String
slug String @unique
subscription Subscription?
users User[]
}
model Subscription {
id Int @id @default(autoincrement())
organization Organization @relation(fields: [organizationId], references: [id])
organizationId Int @unique
plan String
status Status
}
enum Status {
Active
Paused
Expired
}
```
Constructing and optimizing database queries [#constructing-and-optimizing-database-queries]
How Tabnine helps [#how-tabnine-helps-1]
Prisma ORM provides a convenient high-level API for writing database queries intuitively. However, queries involving filters, pagination and advanced patterns can still become complex to construct.
Tabnine can help by:
* Auto-completing Prisma queries based on the schema.
* Suggesting `where` clauses for filters and `skip` / `take` options for pagination logic.
* Helping with efficiency and performance optimizations.
Example: fetching data with relationships [#example-fetching-data-with-relationships]
Prompt [#prompt-1]
*Generate a Prisma query to fetch all active users from an organization with an active subscription. Include data about the users' organizations in the query result.*
Generated code [#generated-code-1]
```ts
const activeUsers = await prisma.user.findMany({
where: {
organization: {
subscription: {
status: "ACTIVE",
},
},
},
include: {
organization: true,
},
});
```
Generating CRUD functionality and other boilerplate code [#generating-crud-functionality-and-other-boilerplate-code]
How Tabnine helps [#how-tabnine-helps-2]
Most applications require basic CRUD operations or other boilerplate code that's usually derived from the structure of the database schema. For example, an API layer may expose a set of HTTP endpoints that allow to create, read, update or delete records of a certain model. Similarly, a frontend will data fetching and state management logic to interact with these API endpoints and update the UI accordingly.
Instead of writing this code manually, Tabnine can speed up this process by:
* Generating Prisma `create`, `read`, `update`, and `delete` operations for the backend and UI components for the frontend.
* Auto-completing function names and argument types.
* Write boilerplate code while following best practices for using DTOs, error handling, consistent API design, ...
Example: Generating CRUD functionality with Next.js [#example-generating-crud-functionality-with-nextjs]
Prompt [#prompt-2]
*Generate CRUD functionality for a Next.js app based on the User model from the schema above.*
Generated code [#generated-code-2]
API endpoints [#api-endpoints]
```ts filename=app/api/users/routes.ts
import { NextResponse } from "next/server";
import prisma from "../../../lib/prisma";
export async function GET() {
const users = await prisma.user.findMany({
include: { organization: true },
});
return NextResponse.json(users);
}
export async function POST(request: Request) {
const body = await request.json();
const user = await prisma.user.create({
data: {
email: body.email,
name: body.name,
organization: {
connect: { id: body.organizationId },
},
},
include: { organization: true },
});
return NextResponse.json(user);
}
export async function PUT(request: Request) {
const body = await request.json();
const user = await prisma.user.update({
where: { id: body.id },
data: {
email: body.email,
name: body.name,
organizationId: body.organizationId,
},
include: { organization: true },
});
return NextResponse.json(user);
}
export async function DELETE(request: Request) {
const { searchParams } = new URL(request.url);
const id = searchParams.get("id");
const user = await prisma.user.delete({
where: { id: Number(id) },
});
return NextResponse.json(user);
}
```
React components [#react-components]
```ts filename=app/components/User.tsx
import React, { useState, useEffect } from 'react';
interface User {
id: number;
email: string;
name: string;
organizationId: number;
}
const User: React.FC = () => {
const [users, setUsers] = useState.windsurfrules
file
Learn more on [how to enable static IP for Accelerate in the Platform Console](/accelerate/static-ip).
> [!NOTE]
> **What is a static IP?**
>
> A static IP address is an IPv4 or an IPv6 address that is fixed. Unlike dynamic IP addresses, which can change unpredictably, traffic from static IP addresses can be easily identified.
>
> 
> ℹ️ To enable static IP support for Accelerate within your existing or new project environment, your workspace will need to be on our **Pro** or **Business** plans. Take a look at the [pricing page](https://www.prisma.io/pricing#accelerate) for more information.
Why do I sometimes see unexpected cache behavior? [#why-do-i-sometimes-see-unexpected-cache-behavior]
Accelerate's cache performs best when it observes a higher load from a project. Many cache operations, such as committing data to cache and refreshing stale data, happen asynchronously. When benchmarking Accelerate, we recommend doing so with loops or a load testing approach. This will mimic higher load scenarios better and reduce outliers from low frequency operations.
Prisma operations are sent to Accelerate over HTTP. As a result, the first request to Accelerate must establish an HTTP handshake and may have additional latency as a result. We're exploring ways to reduce this initial request latency in the future.
What is the pricing of Accelerate? [#what-is-the-pricing-of-accelerate]
You can find more details on our [Accelerate pricing page](https://www.prisma.io/pricing)
VS Code does not recognize the $extends method [#vs-code-does-not-recognize-the-extends-method]
If you add the Prisma Client extension for Accelerate to an existing project that is currently open in VS Code, the editor might not immediately recognize the `$extends` method.
This might be an issue with the TypeScript server not yet recognizing the regenerated Prisma Client. To resolve this, you need to restart TypeScript.
1. In VS Code, open the Command Palette. You can do so when you press F1 or select **View** > **Command Palette**.
2. Enter `typescript` and select and run the **TypeScript: Restart TS server** command.
VS Code should now recognize the `$extends` method.
What regions are Accelerate's cache nodes available in? [#what-regions-are-accelerates-cache-nodes-available-in]
Accelerate runs on Cloudflare's network and cache hits are served from Cloudflare's 300+ locations. You can find the regions where Accelerate's cache nodes are available here: [https://www.cloudflare.com/network/](https://www.cloudflare.com/network/).
What regions is Accelerate's connection pool available in? [#what-regions-is-accelerates-connection-pool-available-in]
When no cache strategy is specified or in the event of a cache miss, the Prisma Client query is routed through Accelerate's connection pool. Currently, queries can be routed through any chosen region among the 16 available locations.
Currently, the list of available regions are:
* Asia Pacific, Mumbai (`ap-south-1`)
* Asia Pacific, Seoul (`ap-northeast-2`)
* Asia Pacific, Singapore (`ap-southeast-1`)
* Asia Pacific, Sydney (`ap-southeast-2`)
* Asia Pacific, Tokyo (`ap-northeast-1`)
* Canada, Central (`ca-central-1`)
* Europe, Frankfurt (`eu-central-1`)
* Europe, Ireland (`eu-west-1`)
* Europe, London (`eu-west-2`)
* Europe, Paris (`eu-west-3`)
* Europe, Stockholm (`eu-north-1`)
* South America, Sao Paulo (`sa-east-1`)
* US East, N. Virginia (`us-east-1`)
* US East, Ohio (`us-east-2`)
* US West, N. California (`us-west-1`)
* US West, Oregon (`us-west-2`)
You can also view the available regions when you're about to set up Accelerate or by visiting the **Settings** tab for Accelerate under the **Region** section in the Prisma Cloud Platform [dashboard](https://pris.ly/pdp).
How does Accelerate know what region to fetch the cache from? [#how-does-accelerate-know-what-region-to-fetch-the-cache-from]
Under the hood, Accelerate uses Cloudflare, which uses [Anycast](https://www.cloudflare.com/learning/cdn/glossary/anycast-network/) for network addressing and routing. An incoming request will be routed to the nearest data center or "node" in their network that has the capacity to process the request efficiently. To learn more about how this works, we recommend looking into [Anycast](https://www.cloudflare.com/learning/cdn/glossary/anycast-network/).
How can I invalidate a cache on Accelerate? [#how-can-i-invalidate-a-cache-on-accelerate]
You can invalidate the cache on-demand via the [`$accelerate.invalidate` API](/accelerate/reference/api-reference#accelerateinvalidate) if you're on a [paid plan](https://www.prisma.io/pricing#accelerate), or you can invalidate your entire cache, on a project level, a maximum of five times a day. This limit is set based on [your plan](https://www.prisma.io/pricing#accelerate). You can manage this via the Accelerate configuration page.
What is Accelerate's consistency model? [#what-is-accelerates-consistency-model]
Accelerate does not have a consistency model. It is not a distributed system where nodes need to reach a consensus (because data is only stored in the cache node(s) closest to the user). However, the data cached in Accelerate's cache nodes doesn't propagate to other nodes, so Accelerate by design doesn't need a consistency model.
Accelerate implements a [read-through caching strategy](https://www.prisma.io/dataguide/managing-databases/introduction-database-caching#read-through) particularly suitable for read-heavy workloads.
How is Accelerate different from other caching tools, such as Redis? [#how-is-accelerate-different-from-other-caching-tools-such-as-redis]
* Accelerate is a *specialized* cache that allows you to optimize data access in code at the query level with a cache strategy. On the other hand, tools such as Redis and Memcached are *general-purpose* caches designed to be adaptable and flexible.
* Accelerate is a managed service that reduces the time, risk, and engineering effort of building and maintaining a cache service.
* By default, Accelerate is globally distributed, reducing the latency of your queries. Other cache tools would require additional configuration to make them available globally.
When should I not use Accelerate's caching features? [#when-should-i-not-use-accelerates-caching-features]
Accelerate is a global data cache and connection pool that allows you to optimize data access in code at the query level. While caching with Accelerate can greatly boost the performance of your app, it may not always the best choice for your use case.
Accelerate's global cache feature may not be a good fit for your app if:
* Your app is exclusively used within a specific region and both your application server and database are situated in that same region on the same network. For example, database queries will likely be much faster if your application server and database are in the same region and network. However, If your application server is in different regions or networks from your database, Accelerate will speed up your queries because the data will be cached in the closest data center to your application.
* You *only* need a general-purpose cache. Accelerate is a connection pooler and a *specialized cache* that only caches your database query responses in code. A general-purpose cache, such as Redis, would allow you to cache data from multiple sources, such as external APIs, which Accelerate currently doesn't support. If general-purpose caching interests you, please share your feedback with us via our [Discord](https://pris.ly/discord?utm_source=docs\&utm_medium=inline_text).
* Your application data *always* needs to be up-to-date on retrieval, making it difficult to establish a reasonable cache strategy.
Even without using Accelerate's global cache, you can still greatly benefit from Accelerate by using its connection pool, especially in serverless or edge functions, where it is difficult to manage and scale database connections. You can learn more about the serverless challenge [here](/orm/prisma-client/setup-and-configuration/databases-connections#the-serverless-challenge).
Can I use Accelerate with other ORMs/query builders/drivers? [#can-i-use-accelerate-with-other-ormsquery-buildersdrivers]
No. We currently do not have any plans for supporting other ORMs/query builders or drivers. However, if you're interested in support for other libraries, feel free to reach out and let us know in our [Discord](https://pris.ly/discord?utm_source=docs\&utm_medium=inline_text) community in the `#help-and-questions` channel.
What is the maximum allowed value for the ttl parameter when configuring cacheStrategy? [#what-is-the-maximum-allowed-value-for-the-ttl-parameter-when-configuring-cachestrategy]
The [Time-to-live](/accelerate/caching) (`ttl`) parameter can be set for up to a *year*. However, it's important to note that items within the cache may be evicted if they are not frequently accessed.
Based on our experimentation, we’ve seen cache items persist for around 18 hours. While items may remain in the cache for an extended period if they are actively accessed, there is no guarantee.
> **Note**: Even frequently accessed items may occasionally be evicted from the cache. It's unlikely for an item to survive for up to or longer than a month, regardless of its activity level.
Why doesn’t Accelerate fall back to the direct connection string during a service disruption? [#why-doesnt-accelerate-fall-back-to-the-direct-connection-string-during-a-service-disruption]
In the rare event of a service disruption, falling back to a direct connection would bypass the connection pool. This could potentially deplete the database's available connections and cause other issues on the database level.
If there is a service disruption, it's recommended to verify on the [status page](https://pris.ly/data-platform-status). You can reach out to one of Prisma's [support channels](/console/more/support) for assistance.
> **Note:** Additionally, it's worth noting that some edge function runtime environments may not support direct connections with Prisma ORM. For further details, refer to our [Edge functions documentation](/orm/prisma-client/deployment/edge/overview).
Are each of the queries within an interactive transaction counted separately for billing? [#are-each-of-the-queries-within-an-interactive-transaction-counted-separately-for-billing]
Yes, [interactive transactions](/orm/prisma-client/queries/transactions#interactive-transactions) are billed based on the individual operations within the transaction. There is no charge for the start, commit, or rollback of the transaction itself. For example, in the following query, there are two billable queries:
```ts
await prisma.$transaction(async (tx) => {
await tx.user.deleteMany({ where: { name: "John Doe" } });
await tx.user.createMany({ data });
});
```
However, when using the [`$transaction` API for sequential client operations](/orm/prisma-client/queries/transactions#sequential-operations), regardless of the number of queries within the array, it counts as only one billable query. For example:
```ts
await prisma.$transaction([
prisma.user.deleteMany({ where: { name: "John Doe" } }),
prisma.user.createMany({ data }),
]);
```
If you don't need [interactive transactions](/orm/prisma-client/queries/transactions#interactive-transactions), you can save costs and improve performance by using [sequential operations transactions](/orm/prisma-client/queries/transactions#sequential-operations). Sequential operations transactions perform better on Accelerate because they execute in one round-trip to the database, while interactive transactions require separate round-trips for start, commit, and each individual operation on the transaction.
Can I increase my Accelerate query duration and response size limits? [#can-i-increase-my-accelerate-query-duration-and-response-size-limits]
Yes, you can increase your Accelerate limits based on your subscription plan. Here are the configurable limits:
| Limit | Free | Starter | Pro Plan | Business Plan |
| ------------------------------------ | ---------------- | ---------------- | ---------------- | ---------------- |
| **Query timeout** | Up to 10 seconds | Up to 10 seconds | Up to 20 seconds | Up to 60 seconds |
| **Interactive transactions timeout** | Up to 15 seconds | Up to 15 seconds | Up to 30 seconds | Up to 90 seconds |
| **Response size** | Up to 5 MB | Up to 5 MB | Up to 10 MB | Up to 20 MB |
Check the [pricing page](https://www.prisma.io/pricing#accelerate) for more details on the available plans and their corresponding limits.
> [!WARNING]
> While you can increase these limits based on your subscription plan, it's *still* recommended to optimize your database operations. [Learn more in our troubleshooting guide.](/postgres/error-reference)
How long does it take to invalidate a cache query result? [#how-long-does-it-take-to-invalidate-a-cache-query-result]
As the cache needs to be cleared globally, it is difficult to provide a specific time frame. However, the cached data is eventually consistent and typically propagates to all PoPs within a few seconds. In very rare cases, it may take longer.
Here is a [demo app](https://pris.ly/test-cache-invalidation) to test the time it takes to invalidate a cache query result.
What is the difference between Invalidate and Revalidate? [#what-is-the-difference-between-invalidate-and-revalidate]
**Invalidate**: The cache entry is deleted, and new data will be fetched on the next request, causing a cache miss. This removes stale data but may lead to slower responses until the cache is repopulated.
**Revalidate**: The cache entry is updated proactively, ensuring the next request uses fresh data from the cache. This keeps the cache valid and maintains faster response times by avoiding cache misses.
What is on-demand cache invalidation? [#what-is-on-demand-cache-invalidation]
[On-demand cache invalidation](/accelerate/caching) lets applications instantly update specific cached data when it changes, instead of waiting for regular cache refresh cycles. This keeps information accurate and up-to-date for users.
When should I use the cache invalidate API? [#when-should-i-use-the-cache-invalidate-api]
The [cache invalidate API](/accelerate/caching) is essential when data consistency cannot wait for the cache’s standard expiration or revalidation. Key use cases include:
* **Content updates**: When critical changes occur, such as edits to a published article, product updates, or profile modifications, that need to be visible immediately.
* **Inventory management**: In real-time applications, like inventory or booking systems, where stock levels, availability, or reservation statuses must reflect the latest information.
* **High-priority data**: For time-sensitive data, like breaking news or urgent notifications, where it’s essential for users to see the most current information right away.
Using on-demand cache invalidation in these scenarios helps keep only the necessary data refreshed, preserving system performance while ensuring accurate, up-to-date information for users.
How does Accelerate count queries for billing? [#how-does-accelerate-count-queries-for-billing]
Accelerate counts queries at the Prisma Client invocation level. A single Prisma query may translate into multiple SQL statements under the hood, but it will only count as one query for billing purposes. This ensures straightforward, predictable billing that reflects the Prisma Client usage rather than the complexity of the underlying SQL operations.
Queries are counted regardless of whether they are served from the cache or the database. Even if a query is retrieved from the cache, it still counts toward your query limit.
How do I switch from GitHub login to email and password login? [#how-do-i-switch-from-github-login-to-email-and-password-login]
If you previously signed up using GitHub and want to switch to email and password login, follow these steps:
1. Verify Your GitHub Email Address [#1-verify-your-github-email-address]
* Check the primary email address associated with your GitHub account (e.g., from your GitHub profile or notification settings).
2. Create a New Email/Password Account [#2-create-a-new-emailpassword-account]
* Go to the email/password sign-up page.
* Use the **same email address** linked to your GitHub account to create the new account.
* Our system will automatically connect your new email/password account to your existing data.
3. Test Your Login [#3-test-your-login]
* Log out and try logging in with your email and the password you just created.
> **Note**: If you encounter any issues, please contact our support team for help linking your accounts.
## Related pages
- [`Feedback`](https://www.prisma.io/docs/accelerate/more/feedback): Learn where to submit feedback about Accelerate
- [`Known limitations`](https://www.prisma.io/docs/accelerate/more/known-limitations): Learn about limitations of Accelerate
- [`Troubleshooting`](https://www.prisma.io/docs/accelerate/more/troubleshoot): Troubleshoot common Prisma Accelerate errors and connection issues
# Feedback (/docs/accelerate/more/feedback)
Location: Accelerate > More > Feedback
You can submit any feedback about Accelerate in our [Discord server](https://pris.ly/discord?utm_source=docs\&utm_medium=intro_text).
## Related pages
- [`FAQ`](https://www.prisma.io/docs/accelerate/more/faq): Frequently asked questions about Accelerate
- [`Known limitations`](https://www.prisma.io/docs/accelerate/more/known-limitations): Learn about limitations of Accelerate
- [`Troubleshooting`](https://www.prisma.io/docs/accelerate/more/troubleshoot): Troubleshoot common Prisma Accelerate errors and connection issues
# Known limitations (/docs/accelerate/more/known-limitations)
Location: Accelerate > More > Known limitations
Below are descriptions of known limitations when using Accelerate. If you encounter any additional ones, please share them with us via [Discord](https://pris.ly/discord?utm_source=docs\&utm_medium=intro_text).
Cannot cache raw queries [#cannot-cache-raw-queries]
At the moment, it is not possible to cache the responses of [raw queries](/orm/prisma-client/using-raw-sql/raw-queries).
Not compatible with the fluent API [#not-compatible-with-the-fluent-api]
Client Extensions (which are used in Accelerate) currently do not correctly forward the [fluent API](/orm/prisma-client/queries/relation-queries#fluent-api) types. We hope to get a fix into Client Extensions soon.
Not compatible with extremely heavy or long-running queries [#not-compatible-with-extremely-heavy-or-long-running-queries]
Accelerate is designed to work with high-performance, low-latency queries. It is not intended for use with extremely heavy or long-running queries that may cause performance issues or resource contention. While limits are configurable, we recommend optimizing your queries to ensure they fit within the recommended guidelines.
For queries that cannot be optimized or pared down, we recommend one of two solutions:
1. **Use the read replica extension**: The Prisma ORM [read replica extension](https://www.npmjs.com/package/@prisma/extension-read-replicas) allows you to set up two different connections: a `primary` and a `replica`. You can set up your Accelerate connection as the `primary` and then a direct connection as the `replica`. Any queries that are resource-intensive or long-running can then be routed to the `replica`, while the `primary` (your Accelerate connection) will handle normal queries. **Please note** that this solution requires you to both set up a direct connection and requires the full generated Prisma Client (i.e. without `--no-engine`).
2. **Separate analytics queries**: Our preferred solution is to separate your analytics queries into a separate application. This separate application can then use a direct connection so that it can run heavy queries without impacting the performance or cost of your Accelerate-powered application.
If you have a use case that requires running extremely heavy or long-running queries and Prisma Accelerate, please reach out to us.
Not compatible with direct IPv4 addresses in MongoDB connection strings [#not-compatible-with-direct-ipv4-addresses-in-mongodb-connection-strings]
Accelerate does not support direct IPv4 addresses in MongoDB connection strings. When an IPv4 address is provided, Accelerate converts it to an IPv6 format to route through its NAT gateway. This conversion may cause the connection string to be considered invalid due to the formatting of the port value.
**Workaround**: To resolve this issue, create a DNS record that points to your IPv4 address and use that DNS record in your connection string instead of the direct IP.
Example [#example]
* **IPv4 connection string** (not supported): `mongodb://user:password@192.168.1.100:27017/db_name`
* **DNS record connection string** (supported): `mongodb://user:password@my-database.example.com:27017/db_name`
For additional details on Accelerate’s IPv6-first design, refer to our [blog post](https://www.prisma.io/blog/accelerate-ipv6-first).
## Related pages
- [`FAQ`](https://www.prisma.io/docs/accelerate/more/faq): Frequently asked questions about Accelerate
- [`Feedback`](https://www.prisma.io/docs/accelerate/more/feedback): Learn where to submit feedback about Accelerate
- [`Troubleshooting`](https://www.prisma.io/docs/accelerate/more/troubleshoot): Troubleshoot common Prisma Accelerate errors and connection issues
# Troubleshooting (/docs/accelerate/more/troubleshoot)
Location: Accelerate > More > Troubleshooting
When working with Accelerate, you may encounter errors often highlighted by specific error codes during development and operations. It is important to understand the meaning of these errors, why they occur, and how to resolve them in order to ensure the smooth operation of your applications. This guide aims to provide insights and steps to troubleshoot specific error codes encountered with Accelerate.
P6009 (ResponseSizeLimitExceeded) [#p6009-responsesizelimitexceeded]
This error is triggered when the response size from a database query exceeds the configured query response size limit. We've implemented this restriction to safeguard your application performance, as retrieving data over 5MB can significantly slow down your application due to multiple network layers. Typically, transmitting more than 5MB of data is common when conducting ETL (Extract, Transform, Load) operations. However, for other scenarios such as transactional queries, real-time data fetching for user interfaces, bulk data updates, or aggregating large datasets for analytics outside of ETL contexts, it should generally be avoided. These use cases, while essential, can often be optimized to work within the configured query response size limit, ensuring smoother performance and a better user experience.
Possible causes for P6009 [#possible-causes-for-p6009]
Transmitting images/files in response [#transmitting-imagesfiles-in-response]
This error may arise if images or files stored within your table are being fetched, resulting in a large response size. Storing assets directly in the database is generally discouraged because it significantly impacts database performance and scalability. In addition to performance, it makes database backups slow and significantly increases the cost of storing routine backups.
**Suggested solution:** Configure the query response size limit to be larger. If the limit is still exceeded, consider storing the image or file in a BLOB store like [Cloudflare R2](https://developers.cloudflare.com/r2/), [AWS S3](https://aws.amazon.com/pm/serv-s3/), or [Cloudinary](https://cloudinary.com/). These services allow you to store assets optimally and return a URL for access. Instead of storing the asset directly in the database, store the URL, which will substantially reduce the response size.
Over-fetching of data [#over-fetching-of-data]
In certain cases, a large number of records or fields are unintentionally fetched, which results in exceeding the configured query response size limit. This could happen when the [`where`](/orm/reference/prisma-client-reference#where) clause in the query is incorrect or entirely missing.
**Suggested solution:** Configure the query response size limit to be larger. If the limit is still exceeded, double-check that the `where` clause is filtering data as expected. To prevent fetching too many records, consider using [pagination](/orm/prisma-client/queries/pagination). Additionally, use the [`select`](/orm/reference/prisma-client-reference#select) clause to return only the necessary fields, reducing the response size.
Fetching a large volume of data [#fetching-a-large-volume-of-data]
In many data processing workflows, especially those involving ETL (Extract-Transform-Load) processes or scheduled CRON jobs, there's a need to extract large amounts of data from data sources (like databases, APIs, or file systems) for analysis, reporting, or further processing. If you are running an ETL/CRON workload that fetches a huge chunk of data for analytical processing then you might run into this limit.
**Suggested solution:** Configure the query response size limit to be larger. If the limit is exceeded, consider splitting your query into batches. This approach ensures that each batch fetches only a portion of the data, preventing you from exceeding the size limit for a single operation.
P6004 (QueryTimeout) [#p6004-querytimeout]
This error occurs when a database query fails to return a response within the configured query timeout limit. The query timeout limit includes the duration of waiting for a connection from the pool, network latency to the database, and the execution time of the query itself. We enforce this limit to prevent unintentional long-running queries that can overload system resources.
> The time for Accelerate's cross-region networking is excluded from the configured query timeout limit.
Possible causes for P6004 [#possible-causes-for-p6004]
This error could be caused by numerous reasons. Some of the prominent ones are:
High traffic and insufficient connections [#high-traffic-and-insufficient-connections]
If the application is receiving very high traffic and there are not a sufficient number of connections available to the database, then the queries would need to wait for a connection to become available. This situation can lead to queries waiting longer than the configured query timeout limit for a connection, ultimately triggering a timeout error if they do not get serviced within this duration.
**Suggested solution**: Review and possibly increase the `connection_limit` specified in the connection string parameter when setting up Accelerate in a platform environment. This limit should align with your database's maximum number of connections.
By default, the connection limit is set to 10 unless a different `connection_limit` is specified in your database connection string.
Long-running queries [#long-running-queries]
Queries may be slow to respond, hitting the configured query timeout limit even when connections are available. This could happen if a very large amount of data is being fetched in a single query or if appropriate indexes are missing from the table.
**Suggested solution**: Configure the query timeout limit to be larger. If the limit is exceeded, identify the slow-running queries and fetch only the necessary data. Use the `select` clause to retrieve specific fields and avoid fetching unnecessary data. Additionally, consider adding appropriate indexes to improve query efficiency. You might also isolate long-running queries into separate environments to prevent them from affecting transactional queries.
Database resource contention [#database-resource-contention]
A common yet challenging issue is when other services operating on the same database perform heavy analytics or data processing tasks, significantly consuming database resources. These operations can monopolize database connections and processing power, leading to a scenario where even simple queries cannot be executed in a timely manner. This "busy" or "noisy" database environment can cause queries that are typically fast to run slowly or even timeout, particularly during periods of high activity from other services.
Users often rely on CPU and memory usage metrics to gauge database load, which can be misleading. While these are important indicators, they might not fully represent the database's operational state. Direct metrics like the number of reads, writes, and wait times offer a clearer view of the database's performance and should be monitored closely. A noticeable degradation in these metrics, especially in the absence of changes to the queries or data model, suggests that external pressures are affecting database performance.
**Suggested solution**: If normally quick queries are intermittently slow or timing out without any modifications to them, it's probable that competing queries are exerting pressure on the same database tables. To diagnose this, adopt monitoring tools or leverage your database's inherent capabilities to observe reads, writes, and wait times. Such monitoring will unveil activity patterns or spikes that align with the observed performance dips.
Moreover, it's crucial to periodically scrutinize and refine essential queries and verify that tables are properly indexed. This proactive approach minimizes the vulnerability of these queries to slowdowns caused by competing workloads.
Considerations for P6009 and P6004 errors [#considerations-for-p6009-and-p6004-errors]
For runtimes that support Prisma ORM natively, you could consider creating two `PrismaClient` Instances. One with the Accelerate connection string (prefixed with `prisma://`) and the other one with the direct database connection string (prefixed with `postgres://`, `mysql://` etc). The main idea behind this approach is to bypass Accelerate for certain specific queries.
However, please note that the available connections would be split between both of your `PrismaClient` Instances. It's crucial to understand the implications of managing multiple instances, particularly in regards to direct database connections. Utilizing a `PrismaClient` instance with a direct database connection string means that this connection will interact directly with your database.
This approach requires careful consideration because the direct connections and those managed by Accelerate share the same underlying database connection pool. This can lead to competition for resources, potentially affecting the performance and availability of your database services.
Additionally, direct connections could have a significant impact on your database's performance and availability. Operations that consume a considerable amount of resources could potentially degrade the service for other users or processes that rely on the same database.
If your application's runtime environment supports Prisma ORM natively and you're considering this strategy to circumvent P6009 and P6004 errors, you might create two `PrismaClient` instances:
1. An instance using the Accelerate connection string (prefixed with `prisma://`) for general operations.
2. Another instance with the direct database connection string (e.g., prefixed with `postgres://`, `mysql://`, etc.) for specific operations anticipated to exceed the configured query timeout limit or to result in responses larger than the configured query response size limit.
```ts
export const prisma = new PrismaClient({
datasourceUrl: process.env.DIRECT_DB_CONNECTION,
});
export const prismaAccelerate = new PrismaClient({
datasourceUrl: process.env.ACCELERATE_CONNECTION,
}).$extends(withAccelerate());
```
This setup allows you to strategically direct certain operations through the direct connection, mitigating the risk of encountering the aforementioned errors. However, this decision should be made with a comprehensive understanding of the potential consequences and an assessment of whether your database infrastructure can support this additional load without compromising overall performance and availability.
> Also see [**why doesn’t Accelerate fall back to the direct connection string during a service disruption?**](/accelerate/more/faq#why-doesnt-accelerate-fall-back-to-the-direct-connection-string-during-a-service-disruption)
P6008 (ConnectionError|EngineStartError) [#p6008-connectionerrorenginestarterror]
This error indicates that Prisma Accelerate cannot establish a connection to your database, potentially due to several reasons.
Possible causes for P6008 [#possible-causes-for-p6008]
Database Not Publicly accessible [#database-not-publicly-accessible]
If your database is within a VPC or access is limited to specific IP addresses, you might encounter this error if static IP is not enabled for Accelerate or if the static IPs are not permitted in your database firewall.
**Suggested solution:** [Enable static IP for Accelerate](/accelerate/static-ip) and configure your database firewall to allow access from the provided static IP addresses.
Unreachable Database Host/Port [#unreachable-database-hostport]
If the database’s server address (hostname) and port are incorrect or unreachable then you may encounter this error.
**Suggested solution:** Verify the hostname/port of the database connection string that was provided while creating the Prisma Accelerate project. Additionally, attempt to connect to the database using a Database GUI tool (e.g., [Prisma Studio](https://www.prisma.io/studio), [TablePlus](https://tableplus.com/), or [DataGrip](https://www.jetbrains.com/datagrip/)) for further investigation.
Incorrect username/password/database name [#incorrect-usernamepassworddatabase-name]
This error can happen when the wrong credentials are provided to Prisma Accelerate, preventing it from establishing a connection to your database.
**Suggested solution:** Verify the correctness of your database's username, password, and name in the connection string provided to Prisma Accelerate. Ensure that these credentials match those required by your database. Testing the connection using a direct database GUI tool can also help in confirming if the provided credentials are correct.
Database taking too long to respond [#database-taking-too-long-to-respond]
If the database is taking too long to respond to the connection request, Prisma Accelerate may timeout and throw this error. This could happen if the database is not active or is waking up from sleep mode.
**Suggested solution:** Verify that the database is active and reachable. If the database is in sleep mode, try to wake it up by sending a request to it using a direct database GUI tool or wake it up using the database's management console.
P5011 (TooManyRequests) [#p5011-toomanyrequests]
This error occurs when Prisma Accelerate detects a high volume of requests that surpasses allowable thresholds. It acts as a protective measure to safeguard both Prisma Accelerate and your underlying database from excessive load.
Possible causes for P5011 [#possible-causes-for-p5011]
Aggressive retry loops [#aggressive-retry-loops]
If your application retries queries immediately or with minimal delay, especially after receiving certain errors, the rapid accumulation of requests can surpass the threshold.
**Suggested solution:**
* Implement an exponential backoff strategy. Rather than retrying immediately or with a fixed delay, gradually increase the delay period after each failed attempt.
* This allows the system time to recover and reduces the likelihood of overwhelming Prisma Accelerate and your database.
Sudden traffic spikes [#sudden-traffic-spikes]
Unpredicted traffic surges (for example, during product launches, flash sales, or viral growth events) can cause the threshold to be met and result into `P5011`.
**Suggested solution:**
* Consider proactive scaling strategies for both Prisma Accelerate and your database.
* Monitor traffic and resource usage. If you anticipate a surge, please contact [support](/console/more/support) for capacity planning and potential configuration adjustments.
Prolonged or planned high workloads [#prolonged-or-planned-high-workloads]
Certain processes, such as bulk data imports, ETL operations, or extended CRON jobs, can generate continuous high query volume over time.
**Suggested solution:**
* Use batching or chunking techniques to break large operations into smaller parts.
* Establish throttling or scheduling to distribute the load more evenly.
Other errors [#other-errors]
Error with MySQL (Aiven): "We were unable to process your request. Please refresh and try again." [#error-with-mysql-aiven-we-were-unable-to-process-your-request-please-refresh-and-try-again]
Issue [#issue]
When using an Aiven MySQL connection string that includes the `?ssl-mode=REQUIRED` parameter, you may encounter the following error:
```
We were unable to process your request. Please refresh and try again.
```
Cause [#cause]
The `ssl-mode=REQUIRED` parameter is incompatible with Accelerate, which leads to connection issues.
Suggested solution [#suggested-solution]
To resolve this error, remove the `?ssl-mode=REQUIRED` parameter from your MySQL connection string.
Example [#example]
* Original connection string: `mysql://username:password@host:port/database?ssl-mode=REQUIRED`
* Updated connection string: `mysql://username:password@host:port/database`
## Related pages
- [`FAQ`](https://www.prisma.io/docs/accelerate/more/faq): Frequently asked questions about Accelerate
- [`Feedback`](https://www.prisma.io/docs/accelerate/more/feedback): Learn where to submit feedback about Accelerate
- [`Known limitations`](https://www.prisma.io/docs/accelerate/more/known-limitations): Learn about limitations of Accelerate
# API Reference (/docs/accelerate/reference/api-reference)
Location: Accelerate > Reference > API Reference
The Accelerate API reference documentation is based on the following schema:
```prisma
model User {
id Int @id @default(autoincrement())
name String?
email String @unique
}
```
All example are based on the `User` model.
cacheStrategy [#cachestrategy]
With the Accelerate extension for Prisma Client, you can use the `cacheStrategy` parameter for model queries and use the [`ttl`](/accelerate/caching) and [`swr`](/accelerate/caching) parameters to define a cache strategy for Accelerate. The Accelerate extension requires that you install Prisma Client version `4.10.0`.
Options [#options]
The `cacheStrategy` parameter takes an option with the following keys:
| Option | Example | Type | Required | Description |
| ------ | ---------- | ---------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `swr` | `60` | `Int` | No | The stale-while-revalidate time in seconds. |
| `ttl` | `60` | `Int` | No | The time-to-live time in seconds. |
| `tags` | `["user"]` | `String[]` | No | The `tag` serves as a variable to control the invalidation of specific queries within your application. It is an optional array of strings to [invalidate](/accelerate/reference/api-reference#accelerateinvalidate) the cache, with each tag containing only alphanumeric characters and underscores, and a maximum length of 64 characters. |
|
Examples [#examples]
Add a caching strategy to the query, defining a 60-second stale-while-revalidate (SWR) value, a 60-second time-to-live (TTL) value, and a cache tag of `"emails_with_alice"`:
```ts highlight=7:11;normal
await prisma.user.findMany({
where: {
email: {
contains: "alice@prisma.io",
},
},
cacheStrategy: {
// [!code highlight]
swr: 60, // [!code highlight]
ttl: 60, // [!code highlight]
tags: ["emails_with_alice"], // [!code highlight]
}, // [!code highlight]
});
```
Supported Prisma Client operations [#supported-prisma-client-operations]
The following is a list of all read query operations that support `cacheStrategy`:
* [`findUnique()`](/orm/reference/prisma-client-reference#findunique)
* [`findUniqueOrThrow()`](/orm/reference/prisma-client-reference#finduniqueorthrow)
* [`findFirst()`](/orm/reference/prisma-client-reference#findfirst)
* [`findFirstOrThrow()`](/orm/reference/prisma-client-reference#findfirstorthrow)
* [`findMany()`](/orm/reference/prisma-client-reference#findmany)
* [`count()`](/orm/reference/prisma-client-reference#count)
* [`aggregate()`](/orm/reference/prisma-client-reference#aggregate)
* [`groupBy()`](/orm/reference/prisma-client-reference#groupby)
The `cacheStrategy` parameter is not supported on any write operations, such as `create()`.
withAccelerateInfo [#withaccelerateinfo]
Any query that supports the `cacheStrategy` can append `withAccelerateInfo()` to wrap the response data and include additional information about the Accelerate response.
To retrieve the status of the response, use:
```ts
const { data, info } = await prisma.user
.count({
cacheStrategy: { ttl: 60, swr: 600 },
where: { myField: "value" },
})
.withAccelerateInfo();
console.dir(info);
```
Notice the `info` property of the response object. This is where the request information is stored.
Return type [#return-type]
The `info` object is of type `AccelerateInfo` and follows the interface below:
```ts
interface AccelerateInfo {
cacheStatus: "ttl" | "swr" | "miss" | "none";
lastModified: Date;
region: string;
requestId: string;
signature: string;
}
```
| Property | Type | Description |
| -------------- | ------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `cacheStatus` | `"ttl" \| "swr" \| "miss" \| "none" ` | The cache status of the response.