# Supported versions (/docs/orm/supported-versions)

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

The versions of Node.js, Bun, Deno, PostgreSQL, MongoDB, and TypeScript that Prisma ORM 8 needs, and the tsconfig settings it expects.

Location: ORM > Supported versions

Prisma ORM 8 is a [release candidate](https://www.prisma.io/docs/orm/release-status). This page lists the oldest version of each runtime, database, and tool it runs on. Older versions are not supported.

## Runtimes [#runtimes]

| Runtime | Minimum                                                                                                                               |
| ------- | ------------------------------------------------------------------------------------------------------------------------------------- |
| Node.js | 22.18 or newer on the 22 line, 24.11 or newer on the 24 line, or 26 or newer. Node.js 23 and 25 are not supported. 24 is recommended. |
| Bun     | 1.3 or newer. See [Bun](https://www.prisma.io/docs/guides/runtimes/bun).                                                                                        |
| Deno    | 2.6 or newer. Deno support is experimental. See [Deno](https://www.prisma.io/docs/guides/runtimes/deno).                                                        |

Node.js is the main runtime and gets the most testing. Bun and Deno work, and Deno support is experimental. Any package manager works: the npm that comes with these Node.js releases, pnpm, Bun, or Yarn 4.10 or newer.

On PostgreSQL, Prisma ORM 8 reads and writes a `DateTime` field as a JavaScript `Date`, as on MongoDB, and needs no polyfill for it. A field you type to read a `Temporal` value, such as `DateTime(as: temporal)` or `TimestamptzTemporal`, needs a global `Temporal`. `Temporal` is built into Node.js 26, Bun 1.4, and Deno 2.7 and later; Node.js 22 and 24, Bun 1.3, and Deno 2.6 do not have it. Check in the runtime that runs your app, because Homebrew's build of Node.js 26 leaves it out: `node -p "typeof Temporal"`, `bun -p "typeof Temporal"`, or `deno eval "console.log(typeof Temporal)"`. Wherever that prints `undefined`, install the polyfill with your package manager:

  

#### bun

```bash
bun add temporal-polyfill
```

#### pnpm

```bash
pnpm add temporal-polyfill
```

#### yarn

```bash
yarn add temporal-polyfill
```

#### npm

```bash
npm install temporal-polyfill
```

Then add this line at the top of the file that creates your client, which is `src/prisma/db.ts` in a project that `npx prisma orm init` set up:

```ts
import "temporal-polyfill/full/global";
```

Without it, reading such a field, or writing a row whose default generates the current time for it, throws an error whose `code` is `RUNTIME.TEMPORAL_UNAVAILABLE`. A TypeScript contract that writes a `Temporal` value as a default, such as `.default(Temporal.Instant.from(...))`, runs that code when `npx prisma contract emit` loads the file, so put the same import at the top of `src/prisma/contract.ts` as well. [Models and fields](https://www.prisma.io/docs/orm/contract-authoring/psl-syntax#models-and-fields) lists which types read `Temporal` values.

## Databases [#databases]

| Database   | Minimum | Driver                                                                                                         |
| ---------- | ------- | -------------------------------------------------------------------------------------------------------------- |
| PostgreSQL | 15      | Built into `@prisma/orm-postgres`.                                                                             |
| MongoDB    | 8.0     | `mongodb` 7, a peer dependency that npm and pnpm install with `@prisma/orm-mongo`. With Yarn, add it yourself. |

`@prisma/orm-postgres` and `@prisma/orm-mongo` are the libraries your app imports. Each is the one package your app installs for its database, in place of `@prisma/client`. MariaDB, SQL Server, and CockroachDB have no Prisma ORM 8 library yet. SQLite's library, `@prisma/orm-sqlite`, is experimental, and MySQL's, `@prisma/orm-mysql`, is an early preview that runs migrations against MySQL 8.4 and reads data, but cannot write rows through the ORM yet. [Supported databases](https://www.prisma.io/docs/orm/supported-databases) has the list.

## TypeScript [#typescript]

Prisma ORM does not require TypeScript, so a plain JavaScript project works, but when TypeScript is present it must be 5.9 or newer.

The `tsconfig.json` settings depend on how you run the app. An app that runs through `tsx`, or that a bundler such as Vite, Next.js, or esbuild builds, uses `"module": "preserve"` and `"moduleResolution": "bundler"`, which is what `npx prisma orm init` writes, along with `"strict": true` and `"resolveJsonModule": true`. If your project already has a `tsconfig.json`, `orm init` sets `module`, `moduleResolution`, and `resolveJsonModule` to those values, adds `node` to `types`, and keeps your other settings. An app that compiles with `tsc` and runs the output with `node` uses `"module": "nodenext"` and `"moduleResolution": "nodenext"` instead, so change them back after `orm init`. [Set up tsconfig.json](https://www.prisma.io/docs/guides/upgrade-prisma-orm/postgresql#26-set-up-tsconfigjson-for-the-prisma-orm-8-client) covers each way of running an app, and it applies to MongoDB projects too.

## ES modules only [#es-modules-only]

Every Prisma ORM 8 package is published as ES modules. Your project can be ES modules too, with `"type": "module"` in `package.json`, which `npx prisma orm init` adds when `package.json` lists no `dependencies` yet. Or it can stay CommonJS: keep `package.json` as it is, use the `nodenext` settings above, and load the packages with `require` as before. [In a CommonJS project](https://www.prisma.io/docs/cli/orm-init#in-a-commonjs-project) walks through it.

## Check your versions [#check-your-versions]

```bash
node --version
npx tsc --version
npx prisma --version
psql "$DATABASE_URL" -c "SELECT version();"
```

`psql --version` on its own prints the version of the `psql` program, not the server. For MongoDB, run `db.version()` in `mongosh`. For Bun or Deno, run `bun --version` or `deno --version`.

`prisma` is the command-line tool, installed as a dev dependency beside the library, and the two are versioned separately. The versions on this page were last checked on 22 October 2026.

## Related pages

- [`Coming from Prisma ORM 7`](https://www.prisma.io/docs/orm/coming-from-prisma-orm-7): What each Prisma ORM 7 schema attribute, command, and query is called in Prisma ORM 8, and what is not available.
- [`Core concepts`](https://www.prisma.io/docs/orm/core-concepts): How Prisma ORM 8 fits together, in the order you meet each piece: the contract, the files contract emit writes, the database signature, queries, and migrations.
- [`Extensions`](https://www.prisma.io/docs/orm/extensions): Every package that plugs into Prisma ORM: database packages, column types, indexes, query operations, and middleware, by Prisma and the community.
- [`Overview`](https://www.prisma.io/docs/orm/data-modeling): Describe the data your application needs with models, primary keys, scalar fields, and relations.
- [`Prisma 7`](https://www.prisma.io/docs/orm/v7): Prisma ORM is a next-generation Node.js and TypeScript ORM that provides type-safe database access, migrations, and a visual data editor.