# Multiple databases (/docs/guides/database/multiple-databases)

Location: Guides > Database > Multiple databases

Introduction [#introduction]

This guide shows you how to use multiple databases using Prisma ORM in a single [Next.js app](https://nextjs.org/). You will learn how to connect to two different Prisma Postgres databases, manage migrations, and deploy your application to Vercel. This approach is useful for multi-tenant applications or when you need to separate concerns when managing connections to multiple databases.

Prerequisites [#prerequisites]

Before you begin, make sure that you have the following:

* Node.js 20+ installed.
* A [Prisma Data Platform account](https://pris.ly/pdp?utm_campaign=multi-client\&utm_source=docs).
* A Vercel account (if you plan to deploy your application).

1. Set up a Next.js project [#1-set-up-a-nextjs-project]

Create a new Next.js app using `create-next-app` from your desired directory:

  

#### npm

```bash
npx create-next-app@latest my-multi-client-app
```

#### pnpm

```bash
pnpm dlx create-next-app@latest my-multi-client-app
```

#### yarn

```bash
yarn dlx create-next-app@latest my-multi-client-app
```

#### bun

```bash
bunx --bun create-next-app@latest my-multi-client-app
```

You will be prompted to answer a few questions about your project. Select all of the defaults.

> [!NOTE]
> For completeness, those are:
> 
> * TypeScript
> * ESLint
> * Tailwind CSS
> * No `src` directory
> * App Router
> * Turbopack
> * Default custom import alias: `@/*`

Then, navigate to the project directory:

```bash
cd my-multi-client-app
```

2. Set up your databases and Prisma Clients [#2-set-up-your-databases-and-prisma-clients]

In this section, you will create two separate Prisma Postgres instances—one for user data and one for post data. You will also configure the Prisma schema and environment variables for each.

First, install Prisma and the required dependencies:

  

#### npm

```bash
npm install prisma tsx @types/pg --save-dev
```

#### pnpm

```bash
pnpm add prisma tsx @types/pg --save-dev
```

#### yarn

```bash
yarn add prisma tsx @types/pg --dev
```

#### bun

```bash
bun add prisma tsx @types/pg --dev
```

  

#### npm

```bash
npm install @prisma/client @prisma/adapter-pg dotenv pg
```

#### pnpm

```bash
pnpm add @prisma/client @prisma/adapter-pg dotenv pg
```

#### yarn

```bash
yarn add @prisma/client @prisma/adapter-pg dotenv pg
```

#### bun

```bash
bun add @prisma/client @prisma/adapter-pg dotenv pg
```

> [!NOTE]
> If you are using a different database provider (MySQL, SQL Server, SQLite), install the corresponding driver adapter package instead of `@prisma/adapter-pg`. For more information, see [Database drivers](/orm/core-concepts/supported-databases/database-drivers).

You have installed the required dependencies for the project.

2.1. Create a Prisma Postgres instance to contain user data [#21-create-a-prisma-postgres-instance-to-contain-user-data]

Initialize Prisma with a [Prisma Postgres](/postgres) instance by running:

  

#### npm

```bash
npx prisma@latest init --db
```

#### pnpm

```bash
pnpm dlx prisma@latest init --db
```

#### yarn

```bash
yarn dlx prisma@latest init --db
```

#### bun

```bash
bunx --bun prisma@latest init --db
```

> [!NOTE]
> If you are not using a Prisma Postgres database, do not use the `--db` flag. Instead, create two PostgreSQL database instances and add their connection URLs to the `.env` file as `PPG_USER_DATABASE_URL` and `PPG_POST_DATABASE_URL`.

Follow the prompts to name your project and choose a database region.

The `prisma@latest init --db` command:

* Connects your CLI to your [Prisma Data Platform](https://console.prisma.io/?utm_source=docs\&utm_medium=content\&utm_content=guides) account. If you are not logged in or do not have an account, your browser will open to guide you through creating a new account or signing into your existing one.
* Creates a `prisma` directory containing a `schema.prisma` file for your database models.
* Creates a `.env` file with your `DATABASE_URL` (e.g., `DATABASE_URL="postgresql://user:password@host:5432/database?sslmode=require"`).

Rename the `prisma` folder to `prisma-user-database`:

```bash
mv prisma prisma-user-database
```

Edit your `.env` file to rename `DATABASE_URL` to `PPG_USER_DATABASE_URL`:

```bash title=".env"
DATABASE_URL="postgresql://user:password@host:5432/database?sslmode=require" # [!code --]
PPG_USER_DATABASE_URL="postgresql://user:password@host:5432/database?sslmode=require" # [!code ++]
```

Open `prisma-user-database/schema.prisma` file and update it to define a `User` model. Also, set the environment variable and specify a [custom `output` directory](/orm/reference/prisma-schema-reference#fields-for-prisma-client-provider) for the generated Prisma Client:

```prisma title="prisma-user-database/schema.prisma"
generator client {
  provider = "prisma-client"
  output = "../prisma-user-database/user-database-client-types" // [!code ++]
}

datasource db {
  provider = "postgresql"
}

model User { // [!code ++]
  id    Int     @id @default(autoincrement()) // [!code ++]
  email String  @unique // [!code ++]
  name  String? // [!code ++]
} // [!code ++]
```

Create a `prisma.config.ts` file for the user database:

```typescript title="prisma-user-database/prisma.config.ts"
import "dotenv/config"; // [!code ++]
import { defineConfig, env } from "prisma/config"; // [!code ++]
// [!code ++]
export default defineConfig({
  // [!code ++]
  schema: "prisma-user-database/schema.prisma", // [!code ++]
  migrations: {
    // [!code ++]
    path: "prisma-user-database/migrations", // [!code ++]
  }, // [!code ++]
  datasource: {
    // [!code ++]
    url: env("PPG_USER_DATABASE_URL"), // [!code ++]
  }, // [!code ++]
}); // [!code ++]
```

> [!NOTE]
> You'll need to install the `dotenv` package if you haven't already:
> 
> 
>   
> 
>   #### npm

>     ```bash
>     npm install dotenv
>     ```
>
> 
>   #### pnpm

>     ```bash
>     pnpm add dotenv
>     ```
>
> 
>   #### yarn

>     ```bash
>     yarn add dotenv
>     ```
>
> 
>   #### bun

>     ```bash
>     bun add dotenv
>     ```
>
> 

Your user database schema is now ready.

2.2. Create a Prisma Postgres instance for post data [#22-create-a-prisma-postgres-instance-for-post-data]

Repeat the initialization for the post database:

  

#### npm

```bash
npx prisma init
npx create-db
```

#### pnpm

```bash
pnpm dlx prisma init
pnpm dlx create-db
```

#### yarn

```bash
yarn dlx prisma init
yarn dlx create-db
```

#### bun

```bash
bunx --bun prisma init
bun x create-db
```

Replace the generated `DATABASE_URL` in your `.env` file with the value from `npx create-db`, then rename the new `prisma` folder to `prisma-post-database`:

```bash
mv prisma prisma-post-database
```

Rename the `DATABASE_URL` variable in `.env` to `PPG_POST_DATABASE_URL`:

```bash title=".env"
DATABASE_URL="postgresql://user:password@host:5432/database?sslmode=require" # [!code --]
PPG_POST_DATABASE_URL="postgresql://user:password@host:5432/database?sslmode=require" # [!code ++]
```

Edit the `prisma-post-database/schema.prisma` file to define a `Post` model. Also, update the datasource URL and set a [custom `output` directory](/orm/reference/prisma-schema-reference#fields-for-prisma-client-provider):

```prisma title="prisma-post-database/schema.prisma"
generator client {
  provider = "prisma-client"
  output = "../prisma-post-database/post-database-client-types" // [!code ++]
}

datasource db {
  provider = "postgresql"
}

model Post { // [!code ++]
  id    Int     @id @default(autoincrement()) // [!code ++]
  title String // [!code ++]
  content  String? // [!code ++]
} // [!code ++]
```

Create a `prisma.config.ts` file for the post database:

```typescript title="prisma-post-database/prisma.config.ts"
import "dotenv/config"; // [!code ++]
import { defineConfig, env } from "prisma/config"; // [!code ++]
// [!code ++]
export default defineConfig({
  // [!code ++]
  schema: "prisma-post-database/schema.prisma", // [!code ++]
  migrations: {
    // [!code ++]
    path: "prisma-post-database/migrations", // [!code ++]
  }, // [!code ++]
  datasource: {
    // [!code ++]
    url: env("PPG_POST_DATABASE_URL"), // [!code ++]
  }, // [!code ++]
}); // [!code ++]
```

Your post database schema is now set.

2.3. Add helper scripts and migrate the schemas [#23-add-helper-scripts-and-migrate-the-schemas]

To simplify your workflow, add helper scripts to your `package.json` file that run Prisma commands for both databases:

```json title="package.json"
"script":{
    "dev": "next dev --turbopack",
    "build": "next build",
    "start": "next start",
    "lint": "next lint",
    "postinstall": "npx prisma generate --schema ./prisma-user-database/schema.prisma && npx prisma generate --schema ./prisma-post-database/schema.prisma", // [!code ++]
    "generate": "npx prisma generate --schema ./prisma-user-database/schema.prisma && npx prisma generate --schema ./prisma-post-database/schema.prisma", // [!code ++]
    "migrate": "npx prisma migrate dev --schema ./prisma-user-database/schema.prisma && npx prisma migrate dev --schema ./prisma-post-database/schema.prisma", // [!code ++]
    "deploy": "npx prisma migrate deploy --schema ./prisma-user-database/schema.prisma && npx prisma migrate deploy --schema ./prisma-post-database/schema.prisma", // [!code ++]
    "studio": "npx prisma studio --schema ./prisma-user-database/schema.prisma --port 5555 & npx prisma studio --schema ./prisma-post-database/schema.prisma --port 5556" // [!code ++]
}
```

Here is an explanation of the custom scripts:

* `postinstall`: Runs immediately after installing dependencies to generate Prisma Clients for both the user and post databases using their respective schema files.
* `generate`: Manually triggers the generation of Prisma Clients for both schemas, ensuring your client code reflects the latest models.
* `migrate`: Applies pending migrations in development mode for both databases using [Prisma Migrate](/orm/prisma-migrate), updating their schemas based on changes in your Prisma files.
* `deploy`: Executes migrations in a production environment, synchronizing your live databases with your Prisma schemas.
* `studio`: Opens Prisma Studio for both databases simultaneously on different ports (`5555` for the user database and `5556` for the post database) for visual data management.

Run the migrations:

  

#### npm

```bash
npm run migrate
```

#### pnpm

```bash
pnpm run migrate
```

#### yarn

```bash
yarn migrate
```

#### bun

```bash
bun run migrate
```

When prompted, name the migration for each database accordingly.

3. Prepare the application to use multiple Prisma Clients [#3-prepare-the-application-to-use-multiple-prisma-clients]

Next, create a `lib` folder to store helper files for instantiating and exporting your Prisma Clients:

```bash
mkdir -p lib && touch lib/user-prisma-client.ts lib/post-prisma-client.ts
```

3.1. Instantiate and export the Prisma Client for the user database [#31-instantiate-and-export-the-prisma-client-for-the-user-database]

In `lib/user-prisma-client.ts`, add the following code:

```ts title="lib/user-prisma-client.ts"
import { PrismaClient } from "../prisma-user-database/user-database-client-types/client"; // [!code ++]
import { PrismaPg } from "@prisma/adapter-pg"; // [!code ++]
// [!code ++]
const adapter = new PrismaPg({
  // [!code ++]
  connectionString: process.env.PPG_USER_DATABASE_URL, // [!code ++]
}); // [!code ++]
// [!code ++]
const getPrisma = () =>
  new PrismaClient({
    // [!code ++]
    adapter, // [!code ++]
  }); // [!code ++]
// [!code ++]
const globalForUserDBPrismaClient = global as unknown as {
  // [!code ++]
  userDBPrismaClient: ReturnType<typeof getPrisma>; // [!code ++]
}; // [!code ++]
// [!code ++]
export const userDBPrismaClient = globalForUserDBPrismaClient.userDBPrismaClient || getPrisma(); // [!code ++] // [!code ++]
// [!code ++]
if (process.env.NODE_ENV !== "production")
  // [!code ++]
  globalForUserDBPrismaClient.userDBPrismaClient = userDBPrismaClient; // [!code ++]
```

3.2. Instantiate and export the Prisma Client for the post database [#32-instantiate-and-export-the-prisma-client-for-the-post-database]

In `lib/post-prisma-client.ts`, add this code:

```ts title="lib/post-prisma-client.ts"
import { PrismaClient } from "../prisma-post-database/post-database-client-types/client"; // [!code ++]
import { PrismaPg } from "@prisma/adapter-pg"; // [!code ++]
// [!code ++]
const adapter = new PrismaPg({
  // [!code ++]
  connectionString: process.env.PPG_POST_DATABASE_URL, // [!code ++]
}); // [!code ++]
// [!code ++]
const getPrisma = () =>
  new PrismaClient({
    // [!code ++]
    adapter, // [!code ++]
  }); // [!code ++]
// [!code ++]
const globalForPostDBPrismaClient = global as unknown as {
  // [!code ++]
  postDBPrismaClient: ReturnType<typeof getPrisma>; // [!code ++]
}; // [!code ++]
// [!code ++]
export const postDBPrismaClient = globalForPostDBPrismaClient.postDBPrismaClient || getPrisma(); // [!code ++] // [!code ++]
// [!code ++]
if (process.env.NODE_ENV !== "production")
  // [!code ++]
  globalForPostDBPrismaClient.postDBPrismaClient = postDBPrismaClient; // [!code ++]
```

4. Integrate multiple Prisma Clients in your Next.js app [#4-integrate-multiple-prisma-clients-in-your-nextjs-app]

Modify your application code to fetch data from both databases. Update the `app/page.tsx` file as follows:

```ts title="app/page.tsx"
import { postDBPrismaClient } from "@/lib/post-prisma-client"; // [!code ++]
import { userDBPrismaClient } from "@/lib/user-prisma-client"; // [!code ++]
 // [!code ++]
export default async function Home() { // [!code ++]
  const user = await userDBPrismaClient.user.findFirst(); // [!code ++]
  const post = await postDBPrismaClient.post.findFirst(); // [!code ++]
 // [!code ++]
  return ( // [!code ++]
    <main className="min-h-screen bg-gray-50 py-12"> // [!code ++]
      <div className="max-w-4xl mx-auto px-4"> // [!code ++]
        <header className="mb-12 text-center"> // [!code ++]
          <h1 className="text-5xl font-extrabold text-gray-900">Multi-DB Showcase</h1> // [!code ++]
          <p className="mt-4 text-xl text-gray-600"> // [!code ++]
            Data fetched from two distinct databases. // [!code ++]
          </p> // [!code ++]
        </header> // [!code ++]
 // [!code ++]
        <section className="mb-8 bg-white shadow-md rounded-lg p-6"> // [!code ++]
          <h2 className="text-2xl font-semibold text-gray-800 border-b pb-2 mb-4"> // [!code ++]
            User Data // [!code ++]
          </h2> // [!code ++]
          <pre className="whitespace-pre-wrap text-sm text-gray-700"> // [!code ++]
            {user ? JSON.stringify(user, null, 2) : "No user data available."} // [!code ++]
          </pre> // [!code ++]
        </section> // [!code ++]
 // [!code ++]
        <section className="bg-white shadow-md rounded-lg p-6"> // [!code ++]
          <h2 className="text-2xl font-semibold text-gray-800 border-b pb-2 mb-4"> // [!code ++]
            Post Data // [!code ++]
          </h2> // [!code ++]
          <pre className="whitespace-pre-wrap text-sm text-gray-700"> // [!code ++]
            {post ? JSON.stringify(post, null, 2) : "No post data available."} // [!code ++]
          </pre> // [!code ++]
        </section> // [!code ++]
      </div> // [!code ++]
    </main> // [!code ++]
  ); // [!code ++]
} // [!code ++]
```

4.1. Populate your databases with data [#41-populate-your-databases-with-data]

In a separate terminal window, open two instances of [Prisma Studio](/studio) to add data to your databases by running the script:

  

#### npm

```bash
npm run studio
```

#### pnpm

```bash
pnpm run studio
```

#### yarn

```bash
yarn studio
```

#### bun

```bash
bun run studio
```

This will open up two browser windows, one in `http://localhost:5555` and one in `http://localhost:5556`. Navigate to those windows and add sample data to both databases.

4.2. Run the development server [#42-run-the-development-server]

Before starting the development server, note that if you are using Next.js `v15.2.0`, do not use Turbopack as there is a known [issue](https://github.com/vercel/next.js/issues/76497). Remove Turbopack from your dev script by updating your `package.json`:

```json title="package.json"
"script":{
    "dev": "next dev --turbopack", // [!code --]
    "dev": "next dev", // [!code ++]
    "build": "next build",
    "start": "next start",
    "lint": "next lint",
    "postinstall": "npx prisma generate --schema ./prisma-user-database/schema.prisma && npx prisma generate --schema ./prisma-post-database/schema.prisma",
    "generate": "npx prisma generate --schema ./prisma-user-database/schema.prisma && npx prisma generate --schema ./prisma-post-database/schema.prisma",
    "migrate": "npx prisma migrate dev --schema ./prisma-user-database/schema.prisma && npx prisma migrate dev --schema ./prisma-post-database/schema.prisma",
    "deploy": "npx prisma migrate deploy --schema ./prisma-user-database/schema.prisma && npx prisma migrate deploy --schema ./prisma-post-database/schema.prisma",
    "studio": "npx prisma studio --schema ./prisma-user-database/schema.prisma --port 5555 & npx prisma studio --schema ./prisma-post-database/schema.prisma --port 5556"
}
```

In a separate terminal window, start the development server by running:

  

#### npm

```bash
npm run dev
```

#### pnpm

```bash
pnpm run dev
```

#### yarn

```bash
yarn dev
```

#### bun

```bash
bun run dev
```

Navigate to `http://localhost:3000` to see your Next.js app display data from both databases:

<img alt="App displaying data by querying two separate database instances" src="/img/guides/multi-client-app-demo.png" width="1033" height="714" />

Congratulations, you have a Next.js app running with two Prisma Client instances querying different databases.

5. Deploy your Next.js app using multiple databases to Vercel [#5-deploy-your-nextjs-app-using-multiple-databases-to-vercel]

Deploy your app by following these steps:

1. Ensure your project is version-controlled and pushed to a GitHub repository. If you do not have a repository yet, [create one on GitHub](https://docs.github.com/en/repositories/creating-and-managing-repositories/creating-a-new-repository). Once the repository is ready, run the following commands:
   ```bash
   git add .
   git commit -m "Initial commit with Prisma Postgres integration"
   git branch -M main
   git remote add origin https://github.com/<your-username>/<repository-name>.git
   git push -u origin main
   ```
   > [!NOTE]
> Replace `<your-username>` and `<repository-name>` with your GitHub username and the name of your repository.
2. Log in to [Vercel](https://vercel.com/) and navigate to your [Dashboard](https://vercel.com/docs/deployments).
3. Create a new project. Follow Vercel's [Import an existing project](https://vercel.com/docs/getting-started-with-vercel/import) guide, but stop at [step 3](https://vercel.com/docs/getting-started-with-vercel/import#optionally-configure-any-settings) where you will configure environment variables *before* clicking **Deploy**.
4. Configure the `DATABASE_URL` environment variable:
   1. Expand the **Environment variables** section.
   2. Add the `PPG_USER_DATABASE_URL` environment variable:
      * **Key**: `PPG_USER_DATABASE_URL`
      * **Value**: Paste your user database connection URL, e.g. by copying it from the `.env` file in your project.
   3. Add the `PPG_POST_DATABASE_URL` environment variable:
      * **Key**: `PPG_POST_DATABASE_URL`
      * **Value**: Paste your post database connection URL, e.g. by copying it from the `.env` file in your project.
        > [!WARNING]
> Do not deploy without setting the environment variables. Your deployment will fail if the application cannot connect to the databases.
5. Click the **Deploy** button. Vercel will build your project and deploy it to a live URL.

Open the live URL provided by Vercel and verify that your application is working.

Congratulations! You have deployed an application that uses multiple Prisma Clients to query two different databases, and it is now live and fully operational on Vercel.

Next steps [#next-steps]

In this guide, you learned how to use multiple databases using Prisma ORM in a single Next.js app by:

* Setting up separate Prisma schemas for user and post databases.
* Configuring custom output directories and environment variables.
* Creating helper scripts to generate and migrate each schema.
* Instantiating and integrating multiple Prisma Clients into your application.
* Deploying your multi-database application to Vercel.

This approach allows you to maintain a clear separation of data models and simplifies multi-tenant or multi-database scenarios.

For further improvements in managing your project, consider using a monorepo setup. Check out our related guides:

* [How to use Prisma ORM in a pnpm workspaces monorepo](/guides/deployment/pnpm-workspaces)
* [How to use Prisma ORM with Turborepo](/guides/deployment/turborepo)

## Related pages

- [`Expand-and-contract migrations`](https://www.prisma.io/docs/guides/database/data-migration): Learn how to perform data migrations using the expand and contract pattern with Prisma ORM
- [`Schema management in teams`](https://www.prisma.io/docs/guides/database/schema-changes): Learn how to use Prisma Migrate effectively when collaborating on a project as a team