The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →“Mocking test data with BrowserStack” can mean several different jobs. Use the Espresso mock server when an Android app must receive controlled API responses; use Low Code Automation datasets to repeat a UI test for many input rows; use Test Management datasets to compose reusable test-case combinations; and use Load Testing external inputs to feed virtual-user iterations. Requestly is a separate BrowserStack-documented option for changing browser/API requests and responses.
This guide maps each need to the supported workflow, shows the important limits and trade-offs, and explains how to avoid accidentally multiplying your execution count.
First, identify what you are trying to mock
| Goal | BrowserStack workflow | How data is controlled | Important caveat |
|---|---|---|---|
| Return deterministic API responses to an Android app | App Automate Espresso mock server | The app request is answered by your configured mock instead of the real service | Local Testing, Network Logs and IP geolocation are unavailable when enabled |
| Run one UI flow with many input records | Low Code Automation data-driven testing | Upload CSV or connect a database, then select rows | Each row is a separate cloud execution |
| Reuse data in planned test cases | Test Management datasets | Associate datasets with cases and select rows | Multiple datasets create a Cartesian product; configurations multiply it again |
| Feed values to browser or API load tests | Load Testing external test data | CSV or JSON files, including a project Test Data Library | Framework parsing and some defaults differ between current documentation pages |
| Alter browser/API traffic for debugging | Requestly | Rules modify requests, responses, headers or destinations | The overview does not provide a complete rule-authoring procedure |
These are not interchangeable settings. An Espresso mock-server flag does not turn a Low Code test into a data-driven test, and a load-test CSV does not automatically become an app API mock.
Mock API responses in an Espresso app test
BrowserStack’s Espresso mock-server guide describes a mock web server that accepts an API request and returns the response configured for the test instead of contacting the production or staging endpoint. This is useful for deterministic success, error and empty-state scenarios.
Enable the device mock server
Add allowDeviceMockServer: true to the Espresso build API payload you submit to App Automate. Keep the flag in the build configuration used by the tests that need mocked responses.
{
"allowDeviceMockServer": true
}- Configure the mock endpoints and response bodies your Espresso test expects.
- Submit the app build with
allowDeviceMockServerset totrue. - Run the test and verify that the app receives the mock response rather than making the remote call.
- Assert both the UI result and the request-dependent behavior, such as an error banner or retry state.
If you use a mock server without enabling the parameter, BrowserStack warns that the test can return a 503 error. Treat that response as a configuration failure first, not as evidence that the app’s endpoint is unavailable.
Trade-offs you must plan for
While allowDeviceMockServer is enabled, BrowserStack says that Local Testing, Network Logs and IP geolocation do not work. You therefore cannot combine this mode with a workflow that depends on an internal network tunnel, BrowserStack network-capture data or location-based routing. Run separate suites when you need those capabilities.
This documented mechanism is specifically for Espresso in App Automate. Do not assume the same flag or behavior applies to every mobile framework.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Run one Low Code test against many data rows
Low Code Automation’s data-driven testing is the right choice when the steps stay the same but values change: account credentials, search terms, addresses, product IDs or boundary-case inputs. BrowserStack describes it as running a single test against multiple sets of data without duplicating the test.
Create or upload a dataset
- Open the Low Code Automation test authoring area and create a dataset by uploading a CSV file, or choose the database option.
- For a database dataset, use a publicly reachable MySQL or PostgreSQL connection and verify that it can handle the expected concurrent connection load.
- Map dataset columns to the test steps that consume them.
- Select the rows needed for the scenario. During authoring, the test uses the first data row; cloud execution runs once for every selected row.
Limits and execution accounting
- BrowserStack documents a maximum of 100 rows and 40 columns for this dataset workflow.
- Every row is a separate execution and counts toward execution usage.
- A large file does not make one cheaper execution; it creates many independent runs.
Use a small representative subset while debugging selectors, then expand to the rows that answer your test question. Keep malformed records in a dedicated negative-test dataset so a failed validation is intentional and easy to diagnose.
Compose reusable data in Test Management
Test Management datasets are designed for reusable test-case data rather than a one-off UI run. Associate a dataset with a test case, select the rows for a run, and retain the data definition for later plans.
Understand Cartesian multiplication
When you link multiple datasets, selected rows are combined as a Cartesian product. For example, three user rows and four locale rows produce 12 data combinations before browser or operating-system configurations are considered. Selected run configurations multiply the total again.
Calculate the count before starting a large run:
execution count = (rows in dataset A × rows in dataset B × ...) × selected configurationsSelect only the rows and configurations that test the stated objective. Otherwise, a useful coverage model can become an expensive collection of near-duplicate executions. The returned documentation lists dataset access for Pro plans and above; confirm the current plan and UI for your account before designing a process around it.
Inject CSV or JSON into Load Testing
BrowserStack’s Per-VU external inputs with test data documentation covers CSV and JSON values for browser and API load tests. You can attach files to a project-level Test Data Library for reuse, then assign data to the scenarios that need it.
Choose a mapping model
- Sequential mapping: virtual-user iterations consume rows in order and loop when they reach the end.
- Random mapping: an iteration can receive any row, so the same row may repeat.
Browser frameworks such as Playwright, WebdriverIO, Nightwatch and Selenium read and parse the injected files themselves. Protocol-oriented frameworks use their native or standard-library mechanisms. Confirm the exact schema, file limits and assignment controls in the current Load Testing interface.
Resolve conflicting product details cautiously
BrowserStack’s returned documentation pages disagree about Hybrid Load Test support and which mapping mode is the default. Do not hard-code either claim into a test plan. Check the current official page and the project UI immediately before implementation, and set the mapping mode explicitly when the interface allows it. Treat a documented default as changeable rather than a contract.
Modify requests and responses with Requestly
BrowserStack’s Requestly overview describes a separate route for browser-oriented traffic control. Its listed capabilities include API mocking, API response modification for edge-case testing, request-body modification, request redirection and header changes.
Use this approach when the browser must continue using its normal client code but you need to alter traffic at the request/response layer. It is conceptually different from the Espresso device mock server: one is a browser/API traffic rule product, while the other is an App Automate Espresso build setting. The overview does not establish a complete click-by-click rule-creation procedure, so follow Requestly’s current API-mocking documentation for implementation details.
Design a reliable mocked-data suite
Separate deterministic and integration tests
Mocked responses make failures reproducible, but they cannot prove that the real service, authentication flow or network path works. Keep a smaller integration suite against a controlled real environment alongside the broader mocked suite.
Give every record an explicit purpose
- Valid baseline record for the normal path.
- Boundary values, such as minimum, maximum and empty fields.
- Authentication and authorization failures.
- Not-found, timeout and server-error responses.
- Locale, currency or timezone variants where the product supports them.
Make data traceable
Include a stable identifier in each row or response. Log that identifier with the test name so a failed cloud execution can be reproduced locally. Avoid putting real customer secrets in CSV, JSON or mock payloads.
Free tools Windows power users keep installed
One-click scans. No signup required.
Control concurrency deliberately
Database-backed Low Code datasets and load-test data can create many simultaneous reads. Check connection capacity before a high-concurrency run, and prefer a static file when the dataset does not need live database values.
Troubleshooting
Espresso run returns 503
Check that the build payload contains allowDeviceMockServer: true and that the mock endpoint and response are available to the test. A missing flag is the first documented cause to eliminate.
Rank #4
Local Testing or Network Logs are missing
That behavior is expected while the Espresso mock-server flag is enabled. Split the test into a mocked suite and a network-enabled suite instead of trying to enable both modes simultaneously.
Only one data row runs
Verify that the rows were selected for cloud execution, not merely imported, and remember that authoring uses the first row while cloud execution runs per row.
Execution usage is unexpectedly high
Count selected rows, dataset combinations and browser/OS configurations. Test Management’s Cartesian product and configuration multiplication can expand a run much faster than the visible dataset size suggests.
Load-test values repeat unexpectedly
Determine whether random mapping is selected or whether sequential mapping has looped past the final row. Confirm the current mapping setting rather than relying on a documentation default.
Database dataset fails under concurrency
Check public reachability, credentials and database connection capacity. BrowserStack specifically advises ensuring the database can handle the expected connection load.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Or skip the browser setup
If your next task is producing visual evidence of a page rather than exercising its API behavior, ScreenshotNeo provides a one-request website screenshot API and MCP server. It accepts the cookie or consent banner like a visitor, removes more than 60 known consent platforms plus newsletter popups and chat widgets before capture, and lets you turn each cleanup step off. Bot checks or CAPTCHAs, blank pages, timeouts, failed loads and cache hits are not billed; response headers identify the page verdict and billing status. Its MCP tools—take_screenshot, get_page_info and capture_pdf—can be used by Claude, Cursor and other MCP clients.
Recommended Free Tools
Use the API documentation at screenshotneo.com/docs/ for the full option set, including full-page and element captures, device presets, custom CSS/JavaScript, waits, request blocking, cookies, headers, geolocation, PDFs, caching, signed links, asynchronous webhooks and bulk capture.
Best Value
cURL
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpPython
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}`);The Free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000 shots, and every feature is available on every plan. Create a free ScreenshotNeo account.
Frequently Asked Questions
Can I use the Espresso mock-server flag for every BrowserStack mobile framework?
The cited BrowserStack workflow is specifically documented for Espresso in App Automate; verify support separately for another framework.
Does a Low Code dataset execute once per column?
No. Cloud execution runs once per selected data row; columns supply values to the steps.
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Repair Windows errors before they cause bigger problemsFix Now →What happens when two Test Management datasets are linked?
Selected rows form a Cartesian product, and selected browser or operating-system configurations multiply the resulting executions.
Should I trust the documented Load Testing default mapping mode?
The returned official pages conflict, so check the current documentation and UI and set the mode explicitly when possible.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
