d1 insert loop dies around 1000 rows with too many API requests by single worker invocation Limits & Errors

Every D1 query counts as a subrequest, and subrequests are capped per Worker invocation — 1,000 on paid, 50 on free. Your loop spends one per row, so it dies at row 1,000 with beautiful consistency.

Use batch():

const stmt = env.DB.prepare(
  "INSERT INTO items (sku, name, price) VALUES (?, ?, ?)"
)
for (const chunk of chunked(rows, 100)) {
  await env.DB.batch(chunk.map(r => stmt.bind(r.sku, r.name, r.price)))
}

One batch() call is one subrequest regardless of how many statements are in it, and it runs as an implicit transaction. 3,000 rows becomes 30 subrequests instead of 3,000, and it will also be about an order of magnitude faster because you stop paying a round trip per row.

Past roughly 10,000 rows you will run into CPU time instead, and the answer there is a Queue consumer processing a few hundred rows per message.

Worth knowing that error is not D1-specific — outbound fetch() calls draw on the same budget, so a Worker that calls an API per row hits it identically. Add a counter around whatever you think is expensive so the next time this happens you know which category burned it.

And the budget is per invocation, so pushing work into ctx.waitUntil() does not hand you a fresh one. Splitting across Queue messages does, because each message is its own invocation.

The shape that holds up long term for imports: upload to R2, drop a message on a Queue, consumer reads the object and processes it in chunks, D1 gets batched writes. Right now a user's browser is sitting on an open connection while you import 3,000 rows, and that is its own bug waiting to be filed.

The thing that will bite you next: batch() is atomic, so one bad row rolls back all 100 of its neighbours. Combine that with a retry and you get duplicates from the chunks that already succeeded.

Put a unique constraint on your natural key and write INSERT ... ON CONFLICT DO NOTHING. Then re-running the whole import is free and you stop caring where it died.

Wrap the whole loop in BEGIN / COMMIT and it becomes a single transaction, which should count as one subrequest.