Mastering Apex Cursors: Scaling Salesforce Data Processing to 50 Million Records

Posted by Vinay Vernekar 24th January 2026

The Evolution of Large-Scale Data Processing in Salesforce

For years, Salesforce developers and architects have relied on Batch Apex or specialized Queueable chains to process large datasets that exceed the standard 50,000-record SOQL limit. While effective, Batch Apex is often rigid, difficult to monitor mid-execution, and restricted by a fixed batch size. With the General Availability of Apex Cursors in the Spring ’26 release, Salesforce provides a more modern, flexible, and powerful way to handle up to 50 million records.

What are Apex Cursors?

Apex Cursors are a server-side query mechanism that allows you to cache the results of a SOQL query and traverse through them in segments. Unlike traditional SOQL, which loads the entire result set into memory (and hits limits), a cursor maintains a pointer to the result set on the server. This enables you to “fetch” specific chunks of data as needed, significantly reducing memory overhead.

Key Technical Capabilities

  • Massive Scalability: Standard Apex Cursors can handle up to 50 million records, while Pagination Cursors (optimized for UI) support up to 100,000 records.
  • Stateful Traversal: Cursors are stateful across a single transaction and can even be passed between Queueable jobs, allowing for sophisticated asynchronous chaining.
  • Bidirectional Navigation: Unlike Batch Apex, which moves only forward, cursors allow you to move backward or jump to specific positions in the result set.

Implementation Example: Using Database.Cursor

Implementing a cursor involves the Database.getCursor() method. Below is a code snippet demonstrating how to process a high-volume dataset by fetching records in batches of 200.

// Initialize the cursor with a SOQL query
Database.Cursor myCursor = Database.getCursor(
    'SELECT Id, Name, Email FROM Contact WHERE CreatedDate = THIS_YEAR'
);

// Process records in segments
while (myCursor.hasNext()) {
    List<Contact> contactBatch = myCursor.fetch(200);
    
    for (Contact c : contactBatch) {
        // Perform business logic
        System.debug('Processing Contact: ' + c.Name);
    }
}

When to Use Apex Cursors vs. Batch Apex

Architects should evaluate the following criteria when choosing between these patterns:

  • Batch Apex: Best for scheduled, heavy-duty processing where each batch can run independently and order of operations is less critical.
  • Apex Cursors + Queueable: Best for scenarios requiring flexible batch sizes, bidirectional traversal, or when you need to maintain a shared state more easily between execution segments.

Governor Limits and Considerations

While powerful, Apex Cursors are subject to specific limits to ensure platform health. Developers can have up to 10 active cursors per transaction, and each cursor has a maximum lifetime before the server-side cache is cleared. Additionally, for UI-centric use cases, the Pagination Cursor variant provides consistent page sizes even if records are deleted during the fetch process, ensuring a smooth user experience.