# From the CLI (/docs/prisma-postgres/from-the-cli)

Location: Prisma Postgres > From the CLI

This page provides a step-by-step guide for Prisma Postgres after setting it up with `prisma init` and `npx create-db`:

1. Set up a TypeScript app with Prisma ORM
2. Migrate the schema of your database
3. Query your database from TypeScript

Prerequisites [#prerequisites]

This guide assumes you initialized Prisma with `prisma init` and created a Prisma Postgres database with `npx create-db`:

  

#### npm

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

#### pnpm

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

#### yarn

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

#### bun

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

Once these commands have terminated:

* The `prisma/` folder was created with an empty `schema.prisma` file.
* The `DATABASE_URL` env var was set in a `.env` file.
* The `prisma.config.ts` file was created with the default configuration.
* You have a Prisma Postgres connection string to paste into `.env`.

1. Organize your project directory [#1-organize-your-project-directory]

> [!NOTE]
> If you ran the `prisma init` command inside a folder where you want your project to live, you can skip this step and [proceed to the next section](/prisma-postgres/from-the-cli#2-set-up-your-project).

If you ran the command outside your intended project directory (e.g., in your home folder or another location), you need to move the generated `prisma` folder and the `.env` file into a dedicated project directory.

Create a new folder (e.g. `hello-prisma`) where you want your project to live and move the necessary files into it:

```bash
mkdir hello-prisma
mv .env ./hello-prisma/
mv prisma ./hello-prisma/
```

Navigate into your project folder:

```bash
cd ./hello-prisma
```

Now that your project is in the correct location, continue with the setup.

2. Set up your project [#2-set-up-your-project]

2.1. Set up TypeScript [#21-set-up-typescript]

Initialize a TypeScript project and add the Prisma CLI as a development dependency:

  

#### npm

```bash
npm init
```

#### pnpm

```bash
pnpm init
```

#### yarn

```bash
yarn init
```

#### bun

```bash
bun init
```

  

#### npm

```bash
npm install typescript tsx @types/node @types/pg -D
```

#### pnpm

```bash
pnpm add typescript tsx @types/node @types/pg -D
```

#### yarn

```bash
yarn add typescript tsx @types/node @types/pg --dev
```

#### bun

```bash
bun add typescript tsx @types/node @types/pg --dev
```

This creates a `package.json` file with an initial setup for your TypeScript app.

Next, initialize TypeScript with a `tsconfig.json` file in the project:

  

#### npm

```bash
npx tsc --init
```

#### pnpm

```bash
pnpm dlx tsc --init
```

#### yarn

```bash
yarn dlx tsc --init
```

#### bun

```bash
bunx --bun tsc --init
```

2.2. Configure ESM support [#22-configure-esm-support]

Update `tsconfig.json` for ESM compatibility:

```json title="tsconfig.json"
{
  "compilerOptions": {
    "module": "ESNext",
    "moduleResolution": "bundler",
    "target": "ES2023",
    "strict": true,
    "esModuleInterop": true,
    "ignoreDeprecations": "6.0"
  }
}
```

Update `package.json` to enable ESM:

```json title="package.json"
{
  "type": "module" // [!code ++]
}
```

2.3. Set up Prisma ORM [#23-set-up-prisma-orm]

Install the required dependencies to use Prisma Postgres:

  

#### npm

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

#### pnpm

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

#### yarn

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

#### bun

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

Here's what each package does:

* **`prisma`** - The Prisma CLI for running commands like `prisma migrate` and `prisma generate`
* **`@prisma/client`** - The Prisma Client library for querying your database
* **`@prisma/adapter-pg`** - The [`node-postgres` driver adapter](/orm/core-concepts/supported-databases/postgresql#using-driver-adapters) that connects Prisma Client to your database
* **`pg`** - The node-postgres database driver
* **`@types/pg`** - TypeScript type definitions for node-postgres
* **`dotenv`** - Loads environment variables from your `.env` file

2.4. Review the generated prisma.config.ts [#24-review-the-generated-prismaconfigts]

The `prisma init` command automatically created a `prisma.config.ts` file that looks like this:

```typescript title="prisma.config.ts"
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"),
  },
});
```

2.5. Create a script to query the database [#25-create-a-script-to-query-the-database]

Create an `index.ts` file in the root directory, this will be used to query your application with Prisma ORM:

```bash
touch index.ts
```

3. Migrate the database schema [#3-migrate-the-database-schema]

Update your `prisma/schema.prisma` file to include the `User` and `Post` models:

```prisma title="prisma/schema.prisma"
generator client {
  provider = "prisma-client"
  output   = "../generated/prisma"
}

datasource db {
  provider = "postgresql"
}

model User {
  id    Int     @id @default(autoincrement())
  email String  @unique
  name  String?
  posts Post[]
}

model Post {
  id        Int     @id @default(autoincrement())
  title     String
  content   String?
  published Boolean @default(false)
  author    User    @relation(fields: [authorId], references: [id])
  authorId  Int
}
```

After adding the models, migrate your database using [Prisma Migrate](/orm/prisma-migrate):

  

#### npm

```bash
npx prisma migrate dev --name init
```

#### pnpm

```bash
pnpm dlx prisma migrate dev --name init
```

#### yarn

```bash
yarn dlx prisma migrate dev --name init
```

#### bun

```bash
bunx --bun prisma migrate dev --name init
```

This command creates the database tables based on your schema.

Now run the following command to generate the Prisma Client:

  

#### npm

```bash
npx prisma generate
```

#### pnpm

```bash
pnpm dlx prisma generate
```

#### yarn

```bash
yarn dlx prisma generate
```

#### bun

```bash
bunx --bun prisma generate
```

4. Send queries with Prisma ORM [#4-send-queries-with-prisma-orm]

4.1. Instantiate Prisma Client [#41-instantiate-prisma-client]

Create a `lib/prisma.ts` file to instantiate Prisma Client with the driver adapter:

```typescript title="lib/prisma.ts"
import "dotenv/config";
import { PrismaPg } from "@prisma/adapter-pg";
import { PrismaClient } from "../generated/prisma/client";

const connectionString = `${process.env.DATABASE_URL}`;

const adapter = new PrismaPg({ connectionString });
const prisma = new PrismaClient({ adapter });

export { prisma };
```

> [!NOTE]
> If you need to query your database via HTTP from an edge runtime (Cloudflare Workers, Vercel Edge Functions, etc.), use the [Prisma Postgres serverless driver](/postgres/database/serverless-driver#use-with-prisma-orm).

4.2. Write your first query [#42-write-your-first-query]

Paste the following boilerplate into `index.ts`:

```ts title="index.ts"
import { prisma } from "./lib/prisma";

async function main() {
  // ... you will write your Prisma ORM queries here
}

main()
  .then(async () => {
    await prisma.$disconnect();
  })
  .catch(async (e) => {
    console.error(e);
    await prisma.$disconnect();
    process.exit(1);
  });
```

This code contains a `main` function that's invoked at the end of the script. It also instantiates `PrismaClient` which you'll use to send queries to your database.

4.3. Create a new User record [#43-create-a-new-user-record]

Let's start with a small query to create a new `User` record in the database and log the resulting object to the console. Add the following code to your `index.ts` file:

```ts title="index.ts"
import { prisma } from "./lib/prisma";

async function main() {
  const user = await prisma.user.create({
    // [!code ++]
    data: {
      // [!code ++]
      name: "Alice", // [!code ++]
      email: "alice@prisma.io", // [!code ++]
    }, // [!code ++]
  }); // [!code ++]
  console.log(user); // [!code ++]
}

main()
  .then(async () => {
    await prisma.$disconnect();
  })
  .catch(async (e) => {
    console.error(e);
    await prisma.$disconnect();
    process.exit(1);
  });
```

Next, execute the script with the following command:

  

#### npm

```bash
npx tsx index.ts
```

#### pnpm

```bash
pnpm dlx tsx index.ts
```

#### yarn

```bash
yarn dlx tsx index.ts
```

#### bun

```bash
bunx --bun tsx index.ts
```

```text no-copy
{ id: 1, email: 'alice@prisma.io', name: 'Alice' }
```

Great job, you just created your first database record with Prisma Postgres! 🎉

4.4. Retrieve all User records [#44-retrieve-all-user-records]

Prisma ORM offers various queries to read data from your database. In this section, you'll use the `findMany` query that returns *all* the records in the database for a given model.

Delete the previous Prisma ORM query and add the new `findMany` query instead:

```ts title="index.ts"
import { prisma } from "./lib/prisma";

async function main() {
  const users = await prisma.user.findMany(); // [!code ++]
  console.log(users); // [!code ++]
}

main()
  .then(async () => {
    await prisma.$disconnect();
  })
  .catch(async (e) => {
    console.error(e);
    await prisma.$disconnect();
    process.exit(1);
  });
```

Execute the script again:

  

#### npm

```bash
npx tsx index.ts
```

#### pnpm

```bash
pnpm dlx tsx index.ts
```

#### yarn

```bash
yarn dlx tsx index.ts
```

#### bun

```bash
bunx --bun tsx index.ts
```

```text no-copy
[{ id: 1, email: 'alice@prisma.io', name: 'Alice' }]
```

Notice how the single `User` object is now enclosed with square brackets in the console. That's because the `findMany` returned an array with a single object inside.

4.5. Explore relation queries [#45-explore-relation-queries]

One of the main features of Prisma ORM is the ease of working with [relations](/orm/prisma-schema/data-model/relations). In this section, you'll learn how to create a `User` and a `Post` record in a nested write query. Afterwards, you'll see how you can retrieve the relation from the database using the `include` option.

First, adjust your script to include the nested query:

```ts title="index.ts"
import { prisma } from "./lib/prisma";

async function main() {
  const user = await prisma.user.create({
    // [!code ++]
    data: {
      // [!code ++]
      name: "Bob", // [!code ++]
      email: "bob@prisma.io", // [!code ++]
      posts: {
        // [!code ++]
        create: [
          // [!code ++]
          {
            // [!code ++]
            title: "Hello World", // [!code ++]
            published: true, // [!code ++]
          }, // [!code ++]
          {
            // [!code ++]
            title: "My second post", // [!code ++]
            content: "This is still a draft", // [!code ++]
          }, // [!code ++]
        ], // [!code ++]
      }, // [!code ++]
    }, // [!code ++]
  }); // [!code ++]
  console.log(user); // [!code ++]
}

main()
  .then(async () => {
    await prisma.$disconnect();
  })
  .catch(async (e) => {
    console.error(e);
    await prisma.$disconnect();
    process.exit(1);
  });
```

Run the query by executing the script again:

  

#### npm

```bash
npx tsx index.ts
```

#### pnpm

```bash
pnpm dlx tsx index.ts
```

#### yarn

```bash
yarn dlx tsx index.ts
```

#### bun

```bash
bunx --bun tsx index.ts
```

```text no-copy
{ id: 2, email: 'bob@prisma.io', name: 'Bob' }
```

In order to also retrieve the `Post` records that belong to a `User`, you can use the `include` option via the `posts` relation field:

```ts title="index.ts"
import { prisma } from "./lib/prisma";

async function main() {
  const usersWithPosts = await prisma.user.findMany({
    // [!code ++]
    include: {
      // [!code ++]
      posts: true, // [!code ++]
    }, // [!code ++]
  }); // [!code ++]
  console.dir(usersWithPosts, { depth: null }); // [!code ++]
}

main()
  .then(async () => {
    await prisma.$disconnect();
  })
  .catch(async (e) => {
    console.error(e);
    await prisma.$disconnect();
    process.exit(1);
  });
```

Run the script again to see the results of the nested read query:

  

#### npm

```bash
npx tsx index.ts
```

#### pnpm

```bash
pnpm dlx tsx index.ts
```

#### yarn

```bash
yarn dlx tsx index.ts
```

#### bun

```bash
bunx --bun tsx index.ts
```

```text no-copy
[
  { id: 1, email: 'alice@prisma.io', name: 'Alice', posts: [] },
  {
    id: 2,
    email: 'bob@prisma.io',
    name: 'Bob',
    posts: [
      {
        id: 1,
        title: 'Hello World',
        content: null,
        published: true,
        authorId: 2
      },
      {
        id: 2,
        title: 'My second post',
        content: 'This is still a draft',
        published: false,
        authorId: 2
      }
    ]
  }
]
```

This time, you're seeing two `User` objects being printed. Both of them have a `posts` field (which is empty for `"Alice"` and populated with two `Post` objects for `"Bob"`) that represents the `Post` records associated with them.

Next steps [#next-steps]

You just got your feet wet with a basic Prisma Postgres setup. Check out the official [Quickstart](/prisma-orm/quickstart/prisma-postgres).

View and edit data in Prisma Studio [#view-and-edit-data-in-prisma-studio]

Prisma ORM comes with a built-in GUI to view and edit the data in your database. You can open it using the following command:

  

#### npm

```bash
npx 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
```

#### bun

```bash
bunx --bun prisma studio --config ./prisma.config.ts
```

With Prisma Postgres, you can also directly use Prisma Studio inside the [Console](https://console.prisma.io/?utm_source=docs\&utm_medium=content\&utm_content=%28index%29) by selecting the **Studio** tab in your project.

Build a fullstack app with Next.js [#build-a-fullstack-app-with-nextjs]

Learn how to use Prisma Postgres in a fullstack app:

* [Build a fullstack app with Next.js 15](/guides/frameworks/nextjs)
* [Next.js 15 example app](https://github.com/prisma/nextjs-prisma-postgres-demo) (including authentication)

Explore ready-to-run examples [#explore-ready-to-run-examples]

Check out the [`prisma-examples`](https://github.com/prisma/prisma-examples/) repository on GitHub to see how Prisma ORM can be used with your favorite library. The repo contains examples with Express, NestJS, GraphQL as well as fullstack examples with Next.js and Vue.js, and a lot more.

These examples use SQLite by default but you can follow the instructions in the project README to switch to Prisma Postgres in a few simple steps.

## Related pages

- [`Import from MySQL`](https://www.prisma.io/docs/prisma-postgres/import-from-existing-database-mysql): Learn how to import data from an existing MySQL database into Prisma Postgres
- [`Import from PostgreSQL`](https://www.prisma.io/docs/prisma-postgres/import-from-existing-database-postgresql): Learn how to import data from an existing PostgreSQL database into Prisma Postgres