Bulk insertion
Importing or seeding many rows for one model efficiently.
Prisma · Function
createMany
createMany() inserts multiple records of the same model in one transactional bulk operation. It returns the number of inserted records and can skip supported duplicate conflicts.
- Since
- 2.20.0
How it works
Call createMany() on a model delegate with a data array containing records to insert. The operation runs in a transaction and returns an object containing the number of records created; skipDuplicates can omit rows that violate supported unique constraints.
Syntax
prisma.<model>.createMany({ data: [...], skipDuplicates?: boolean })Parameters
| Name | Type | Description |
|---|---|---|
data | Enumerable<ModelCreateManyInput> | An array of objects containing the fields for the records to create. |
skipDuplicates | boolean | Skips records whose supported unique fields conflict with existing records; unsupported by MongoDB, SQL Server, and SQLite. |
Returns
A result object containing count, the number of records created.
Key points
- Use it to insert several records of one model as a single transactional bulk operation.
- SQLite supports the operation, although it does not support the
skipDuplicatesoption. - The result reports the number of records created through its
countfield.
Common mistakes
- Do not use
skipDuplicateswith MongoDB, SQL Server, or SQLite. - A top-level
createMany()cannot create or connect related records.
Example: Create multiple users
const result = await prisma.user.createMany({
data: [
{ name: "Bob", email: "bob@prisma.io" },
{ name: "Yewande", email: "yewande@prisma.io" },
],
skipDuplicates: true,
});
console.log(result.count); // 2Creates multiple User records in one bulk operation and reports how many records were inserted.
When to use it
Idempotent seeding
Loading initial application data while avoiding supported unique conflicts.
Transactional batch write
Writing a set of same-model records where all-or-nothing behavior is desirable.
Interview questions
QWhat does createMany() return?
createMany() accepts a data array and inserts multiple records in a transaction. Its result contains a count property rather than the created records.
Follow-up: How would you avoid duplicate inserts? Use skipDuplicates where the database supports it, or enforce and handle unique constraints explicitly.
QWhy use createMany() instead of repeated create() calls?
It is intended for multiple records of the same model in one bulk operation. Prisma documents bulk writes as transactional, so a failed operation rolls back the entire write.
Follow-up: What limitation applies to relations? A top-level bulk insert cannot perform nested relation creation or connection.
QWhen can skipDuplicates be used?
skipDuplicates tells Prisma to omit records that conflict with supported unique constraints. The option is unavailable for MongoDB, SQL Server, and SQLite.
Follow-up: Does skipping duplicates guarantee every input row is inserted? No; conflicting rows are omitted, so the returned count can be lower than the input length.
Related
createcreateManyAndReturnupdateManydeleteManynested createMany