How to fix P5009: Request timed out (Accelerate) in Prisma

First, enable Prisma query logging to identify which queries are timing out:

const prisma = new PrismaClient({
  log: [
    { emit: 'event', level: 'query' },
    { emit: 'stdout', level: 'error' },
    { emit: 'stdout', level: 'warn' },
  ],
});

prisma.$on('query', (e) => {
  console.log('Query: ' + e.query);
  console.log('Duration: ' + e.duration + 'ms');
});

Monitor your logs to identify queries that are approaching or exceeding the 10-second limit. Pay special attention to queries that fetch large amounts of data or perform complex operations.

Reduce the amount of data fetched by using Prisma's select clause to retrieve only necessary fields:

// Before: Fetching all fields
const users = await prisma.user.findMany({
  where: { isActive: true }
});

// After: Fetch only required fields
const users = await prisma.user.findMany({
  where: { isActive: true },
  select: {
    id: true,
    email: true,
    name: true,
  }
});

This significantly reduces data transfer time and query execution time, especially for tables with many columns or JSONB fields.

Break large queries into smaller chunks using cursor-based or offset-based pagination:

// Cursor-based pagination (recommended)
const pageSize = 100;
let cursor = undefined;

while (true) {
  const users = await prisma.user.findMany({
    take: pageSize,
    skip: cursor ? 1 : 0,
    cursor: cursor ? { id: cursor } : undefined,
    orderBy: { id: 'asc' },
  });

  if (users.length === 0) break;

  // Process users batch
  await processUsers(users);

  cursor = users[users.length - 1].id;
}

Pagination prevents fetching thousands of records in a single query, which can easily exceed timeout limits.

Ensure your most frequently queried fields have indexes. Update your Prisma schema:

model User {
  id        String   @id @default(cuid())
  email     String   @unique
  createdAt DateTime @default(now())
  status    String

  @@index([status])
  @@index([createdAt])
  @@index([status, createdAt])
}

Then apply the migration:

npx prisma migrate dev --name add-user-indexes

Indexes dramatically improve query performance for WHERE, ORDER BY, and JOIN operations, often reducing query time from seconds to milliseconds.

If timeouts occur during high traffic, your connection pool may be exhausted. Increase the connection_limit in your Accelerate connection string:

# Before (default is 10)
DATABASE_URL="prisma://accelerate.prisma-data.net/?api_key=YOUR_API_KEY"

# After: Increase connection limit
DATABASE_URL="prisma://accelerate.prisma-data.net/?api_key=YOUR_API_KEY&connection_limit=20"

The connection limit should align with your database's maximum connections. For example, if your PostgreSQL database allows 100 connections and you have 5 application instances, allocate roughly 20 connections per instance.

Restart your application after updating the connection string.

If your use case genuinely requires longer-running queries (such as complex analytics or batch operations), contact Prisma support:

Email: [email protected]
Subject: Request for increased Accelerate timeout limit

In your request, include:
- Your Accelerate project ID
- Specific use case requiring longer timeouts
- Example queries and their typical execution times
- Business justification for the increased limit

Prisma may grant exceptions to the 10-second limit for valid use cases, though it's generally recommended to optimize queries instead.