How to Fix Missing Rows in Browse AI Extraction Results

If a Browse AI extraction returns fewer rows than expected, check four things first: whether you captured a repeating list or table correctly, whether pagination matches how the site loads more records, whether dynamic content finished loading, and whether the configured item or row limit is high enough. Then inspect the task’s actual output. The training preview is not the full dataset.

Use the symptoms below to narrow down the cause. Change one setting at a time and compare the resulting task data with the records visible on the source page.

1. Confirm the capture mode and selected records

For repeated search results, cards, listings, or rows, use Capture Text → From a list. Select the repeated item pattern as a list, rather than treating each value as an unrelated text field. Check that the selection outline covers one complete item and that the fields you want appear consistently across items.

If the robot groups records incorrectly or misses a field, retrain the selection. Manual selection can help when the page’s structure does not make the repeated pattern clear. If the target is a straightforward visible table, Browse AI’s Table Studio may fit; if the page requires interactions, use Robot Studio.

See Browse AI’s guides for extracting data from a list, training a robot, and extracting table data.

2. Match pagination to what the page actually does

Watch the page after its first set of records appears. Choose the pagination behavior that matches the site’s visible control and what happens when you use it:

What you see	Pagination behavior to try	What to check
A Next button or numbered pages	Click next	Confirm the page advances and the next set of records is present before capture.
A Show more or Load more button that appends records	Load more	Confirm each click adds records to the current list rather than replacing it.
New records appear as you scroll	Infinite scroll	Demonstrate scrolling during training so the page loads additional items.
All desired records are already visible	No more items	Check that the visible list really contains the full set you need.

Two symptoms from Browse AI’s pagination troubleshooting guide are especially useful:

• “Only captures first page”: try Load more instead of Click next. Some sites use JavaScript in a way that responds better to the load-more behavior.
• “Missing items between pages”: test Scroll down. Items may load dynamically as the page moves.

These are troubleshooting suggestions, not guarantees. Verify the output after changing the mode. The full pagination setup and troubleshooting guide explains the available behaviors.

3. Wait for JavaScript and lazy-loaded items

A page can look open while its results are still loading. Before selecting records, wait until the content appears and any loading indicator clears. If items load only after scrolling or clicking, demonstrate that interaction in the training sequence. For staged loading, allow more time between the interaction and capture, then rerun and inspect the result.

1. Open the page and note when the first results appear.
2. Perform the scroll, click, or navigation that causes more results to load.
3. Wait for the new items to appear before the robot captures them.
4. Run the task again and compare the extracted count with the source page.

Browse AI’s guidance says to wait for content to load before capturing, and scroll if needed. If a wait alone does not resolve gaps, revisit the interaction order and pagination mode: a longer wait cannot load items if the page needs a scroll or button click first.

4. Check item limits and table-specific omissions

Review the configured number of items or rows. A low limit can produce a partial result even when the robot navigates and captures correctly. If you do not know the total, Browse AI recommends setting a limit higher than the expected count, then checking how many records the task actually returned.

For tables, check these common sources of apparent omissions:

• Horizontal scrolling: columns outside the visible area may not be included. Scroll horizontally and confirm the needed fields are exposed.
• Delayed row population: JavaScript may fill table cells after the page shell appears. Wait for the values, not just the table outline.
• Nonuniform structure: a page that looks like a table may be assembled from separate elements or need an interaction before rows appear. Try another capture pattern or a site-provided export if the structure is unsuitable.
• Repeated headers or sections: verify that the selected region covers all intended rows and does not stop at a section boundary.

Browse AI’s table extraction guide covers row limits, horizontal scrolling, and alternative selection approaches.

5. Inspect the task result, not only the training preview

The training approval screen previews how the robot is configured; it is not the complete dataset from a full task run. Open the task’s resulting data in the robot history or result view and compare the record count there. This tells you whether the robot captured fewer items or whether a downstream view is showing only part of the output.

For API-based workflows, also check that you retrieved every page of task records. A task-list request can itself be limited by its page or pageSize parameters. Inspect task status and, when supplied, userFriendlyError and debug video information. Browse AI documents these checks in its API guide for retrieving and managing scraped data.

6. Troubleshooting by symptom

Symptom	Likely cause	Fix to try
Only the first page’s records appear	Pagination mode does not match the site’s behavior, or the next interaction was not trained.	Try Load more instead of Click next; verify that the interaction actually exposes the next records.
Some records are missing between pages	Items load dynamically during scrolling or between page transitions.	Try infinite scroll and demonstrate scrolling during training; wait for newly loaded records.
First records appear, later ones do not	Lazy loading, staged JavaScript rendering, or an item limit.	Trigger the required scroll or click, wait for content to render, and raise the configured limit.
A table has only some rows	Row limit is too low, the table is still loading, or the selection covers only part of the table.	Increase the limit, wait for cell values, and reselect the full table region.
Expected columns are absent	Columns may be beyond the horizontal viewport or the page may not be a simple table.	Scroll horizontally, try manual selection, or use a site export if available.
The preview looks incomplete but the run may be fine	The training preview is not the full task dataset.	Inspect the completed task result or history.
The API consumer receives fewer records than the task produced	The retrieval query may be paginated or limited.	Follow all pages using the API’s pagination parameters and inspect task status and available error/debug details.

7. A repeatable verification checklist

1. Count a small, identifiable set of records on the source page.
2. Confirm the robot captures the repeated structure as a list or the intended table.
3. Choose pagination based on observed behavior: next, load more, infinite scroll, or no more items.
4. Train necessary clicks and scrolling, and wait until dynamic content is visible.
5. Set a limit above the expected number of rows.
6. Run the task and inspect the completed output rather than relying on the training preview.
7. If using the API, retrieve every page of records and check task status and supplied error/debug information.
8. Change one setting per run so you can identify which change affects the row count.

8. Or skip the browser setup

If your goal is to capture the rendered page as an image or PDF for review or documentation, ScreenshotNeo is a website screenshot API and MCP server. A single GET request returns a PNG, JPEG, WebP, or PDF. It captures pages rather than extracting structured rows, so it is useful for inspecting what the browser rendered, not as a replacement for a dataset extractor.

Example cURL request:

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp

Python:

import requests

r = requests.get(
    "https://api.screenshotneo.com/v1/shot",
    params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"},
    timeout=90,
)
open("shot.webp", "wb").write(r.content)

Node.js:

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);
if (!res.ok) throw new Error(`Screenshot request failed: ${res.status}`);
await import('node:fs/promises').then(fs => fs.writeFile('shot.webp', Buffer.from(await res.arrayBuffer())));

Read the ScreenshotNeo API documentation for request options. Cookie banners are accepted and removed before capture, along with 60+ known consent platforms, newsletter popups, and chat widgets; each cleanup step can be turned off. Bot checks or CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are not billed, and response headers report the page verdict and billing status. An MCP server provides take_screenshot, get_page_info, and capture_pdf for AI agents. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000.

Create a free ScreenshotNeo account for 1,000 screenshots a month, with no card required.

FAQ

Does a Browse AI training preview show every row?

No. It previews the robot setup; inspect the completed task’s result for the extracted dataset.

Should I use Click next or Load more?

Use the behavior that matches what the page does. If only the first page is captured, test Load more as an alternative.

Can a screenshot tell me whether rows are missing?

A screenshot can show the rendered page state, but it does not provide structured rows or prove that every record was extracted. Compare the task output with the source page and its pagination behavior.

Where should I look if an API result appears truncated?

Check both the task status and the retrieval pagination parameters; the extraction may be complete while the client has fetched only one page of records.