Mobile MCP vs Zenrows MCP
A side-by-side look at the Mobile MCP and Zenrows MCP MCP servers: transport, auth, tools, quality signals, and the config to install either one in Claude, Cursor, Windsurf or VS Code.
Verdict: choose Mobile MCP for search & data extraction work as a local process; choose Zenrows MCP for search & data extraction as a local process. You can also run both side by side in one mcpServers block.
Which MCP server should you choose?
Choose Mobile MCP when
- You need dedicated capabilities in the Search & Data Extraction domain.
- You prefer a local stdio subprocess transport.
- Its auth model fits you: No auth required.
- You want tools like
mobile_list_available_devices, mobile_login_to_cloud_provider, mobile_list_remote_devices.
Choose Zenrows MCP when
- You need dedicated capabilities in the Search & Data Extraction domain.
- You prefer a local stdio subprocess transport.
- Its auth model fits you: API key required.
- You want tools like
scrape, extract, batch_create.
Feature & specification comparison
Rows where the two servers differ are marked.
| Spec | ||
|---|---|---|
| Category | Search & Data Extraction | Search & Data Extraction |
| Quality signal | 69/100 · Great | 67/100 · Great |
| Install command | Confirmed | Confirmed |
| Transport | Local subprocess (stdio) | Local subprocess (stdio) |
| Auth | No auth required | API key required |
| Pricing | Free | Freemium |
| Required env vars | None listed | None listed |
| Verified owner | Community listing | Community listing |
| GitHub stars | 9,896 | 20 |
| Directory activity | 7 views 0 installs 0 upvotes | 2 views 0 installs 0 upvotes |
| Tools | 33 | 52 |
| Full listing | View Mobile MCP | View Zenrows MCP |
Tools & capabilities
Mobile MCP tools 33
mobile_list_available_devicesList all available devices. This includes both physical mobile devices and mobile simulators and emulators. It returns both Android and iOS devices. These are local devices already connected to this machine, ready to use immediately at no cost - for devices from the shared remote cloud fleet, use mobile_list_remote_devices instead.mobile_login_to_cloud_providerStart authenticating this machine with the remote device cloud provider. This is required once before mobile_list_remote_devices or mobile_allocate_remote_device will work; if either of those fails with an authentication error, call this tool and then retry. This starts a browser-based device-code login and returns quickly with a URL and a one-time code - it does NOT wait for the login to complete. Show the URL and code to the user verbatim and ask them to open the URL and enter the code in their own browser. The login keeps running in the background after this tool returns; once the user confirms they've completed it, retry the remote devices tool that originally failed. Only call this after the user has explicitly asked to connect to, log into, or use remote/cloud devices - never call it speculatively, since it interrupts the user to act in their browser.mobile_list_remote_devicesList the catalog of device models (make, platform, OS version) available to reserve from the remote cloud device fleet. This is different from mobile_list_available_devices, which lists real devices and simulators/emulators already connected to this local machine and ready to use immediately at no cost. Remote devices live in a shared cloud fleet: they are not usable until reserved with mobile_allocate_remote_device, and reserving one may be a limited/billed resource. Requires mobile_login_to_cloud_provider to have been called first; if this fails with an authentication error, call that tool then retry.mobile_allocate_remote_deviceReserve a physical device from the remote cloud fleet for exclusive use, returning a device identifier usable with the other mobile_* tools. Unlike local devices, a remote device is a shared and billed resource borrowed for the session - only call this after the user has explicitly asked to use a remote/cloud device, never speculatively or as a fallback when a local device isn't found. Requires mobile_login_to_cloud_provider to have been called first; if this fails with an authentication error, call that tool then retry. Use mobile_list_remote_devices first to see which names and versions actually exist in the fleet before filtering by them. Release the device with mobile_release_remote_device once the whole task is finished - releasing wipes the device's state, so do not release and reallocate between steps of the same task just to be tidy.mobile_release_remote_deviceRelease a device previously reserved with mobile_allocate_remote_device back to the remote cloud fleet so it becomes available to others. Releasing is destructive to the device's state: apps installed, files pushed, and any other changes made during this session are lost, and a later mobile_allocate_remote_device call may take time and could return a different physical unit. Only release once the whole task is finished - if there is more work to do on the same device shortly, keep holding it rather than releasing and reallocating.mobile_list_appsList all the installed apps on the devicemobile_get_foreground_appGet the app currently in the foreground on the device. Use this to verify which app or screen you are on before interacting with it.mobile_launch_appLaunch an app on mobile device. Use this to open a specific app. You can find the package name of the app by calling list_apps_on_device.mobile_terminate_appStop and terminate an app on mobile devicemobile_install_appInstall an app on mobile devicemobile_uninstall_appUninstall an app from mobile devicemobile_get_screen_sizeGet the screen size of the mobile device in pixels- +21 more on the listing page
Zenrows MCP tools 52
scrapeScrape any webpage and return its content using Zenrows (Fetch). Returns full-page content (markdown/HTML/PDF/screenshot). For structured JSON fields (products, articles, listings), the extract tool returns parsed fields instead of a full page body. By default the request uses automatic mode (mode=auto): Zenrows adds JS rendering or premium proxies per page only when a plain request does not return the page, and charges only for the configuration that succeeds. Pass just the URL. Set js_render or premium_proxy only to force a fixed configuration. Doing so switches off automatic mode, and every request is billed at that configuration's cost (premium_proxy with js_render is 25x a basic request). Examples: Default: { url: "https://example.com" } Geo: { url: "https://example.com", proxy_country: "US" } Forced: { url: "https://spa.com", js_render: true }extractExtract structured data from a webpage via Zenrows. Returns JSON fields (products, articles, listings) rather than a full page body. Modes: - auto (default): extract=auto, site-tailored Extract (currently free, billing may apply later). Works on any domain Zenrows has prepared, with any API key; falls back to autoparse when the domain isn't prepared yet (REQS007) - autoparse: general-purpose structured JSON on any domain - css: css_extractor with an explicit selector map Requests use automatic mode (mode=auto) by default: Zenrows enables JS rendering and premium proxies only when the site needs them, and charges only for the configuration that succeeds. Pass just the URL. Set js_render or premium_proxy only to force a fixed configuration; that turns automatic mode off and bills every request at that configuration's cost. Check "empty" in the result: true means no field came back with a value. "noDataExtracted": true means Extract processed the page and found nothing to extract (not charged); retrying the same request returns the same answer. Full-page markdown, HTML and screenshots come from scrape.batch_createSubmit a cloud Batch job that fans out many URLs asynchronously (Zenrows Batch API). NOT the same as browser_batch — this hits https://async.api.zenrows.com/v1 with X-API-Key. Suited to large URL lists; scrape and extract handle single pages. Tasks use automatic mode (mode=auto) by default: Zenrows enables JS rendering and premium proxies only on the pages that need them, and charges only for the configuration that succeeds. Pass just the URLs. Set js_render or premium_proxy (job-level or in a task's zenrows_params) only to force a fixed configuration; that turns automatic mode off for the affected tasks and bills them at that configuration's cost. Returns job_id + latest_run.status/stats. batch_status and batch_wait report progress; batch_results lists the results. If you get BATCH_ACCESS_DENIED, Batch is not enabled for this account or API key.batch_statusGet status and stats for a Zenrows Batch job (latest_run.status + latest_run.stats).batch_resultsList result rows for a Batch job (cursor-paginated server-side; returns the full list). Each row may include task_id, external_id, status, and a short-lived result_url for the body. Download result_url soon — presigned links expire.batch_cancelStop an in-flight Batch job run (POST /jobs/:id/stop).batch_waitPoll batch_status until the job reaches a terminal state (completed, failed, stopped, or deleted). A run that hits an API key credit cap ends as failed with failure_reason api_key_cap_reached.crawl_createStart a crawl from one URL (Zenrows Crawl API). Crawl follows the links in each page's HTML up to depth hops (no depth limit when depth is omitted), keeps the URLs that match include_patterns / exclude_patterns, and stays on the start URL's registrable domain (subdomains count). Use crawl when you have one start page (a listing, category, blog index) and need the URLs behind it, optionally with each page's HTML. For a single page, use scrape. Each page fetched is billed as one scrape on this account; max_pages bounds the cost (default 100), max_items bounds how many URLs are kept (default 100). Without depth, the crawl keeps following links until max_pages or max_items stops it or nothing is left to open, so set max_pages to what you are willing to spend. The start page itself is never a result, but its fetch is billed: a crawl whose include_patterns / exclude_patterns match nothing still costs that one scrape. Set output_format "html" to also store each kept URL's page, then read it with crawl_content. Returns crawl_id, status and the crawl (with coverage) at once; the crawl runs asynchronously. Call crawl_wait, then crawl_results. Set idempotency_key to make a retry safe: the same key returns the crawl the first request created instead of starting another. CRAWL_NOT_ENABLED: Crawl is not enabled for this account; do not retry. CRAWL_TOO_MANY_CRAWLS: the account has reached its limit of active jobs (3 by default), shared with its Batch jobs; retry after retry_after seconds.crawl_getGet a crawl and one page of the URLs it kept: crawl_id, status (running, completed, stopped, failed), the crawl (with coverage: pages_fetched, pages_failed, items_found), results and next_cursor. completed with stop_reason max_items / max_pages means a limit ended it; failed carries error.code and error.detail. Pass next_cursor as cursor for the next page; while the crawl runs, next_cursor is never null. To read many pages at once, use crawl_results.crawl_resultsList the URLs a crawl kept, in the order it kept them, following the API's pages up to limit. Each result has url and, when the crawl has output_format, content_status (pending, fetched, failed) and, once fetched, content_url: pass it to crawl_content as content. While the crawl runs the list is partial (partial=true): call again later with the returned next_cursor to get only the URLs kept since. A stopped crawl can still add URLs from pages fetched before the stop for up to 10 minutes, so next_cursor stays set during that window: call again later. next_cursor is null once the crawl ended and every URL was read.crawl_contentRead the stored HTML of one URL a crawl kept. Works only for crawls created with output_format "html", and only for results whose content_status is fetched. Pass crawl_id and content_id: a content id, or content_url from a crawl_results row. Returns raw HTML, cut to max_chars (default 20000); a final note says when it was cut. For a markdown version of a page, use scrape on its URL instead.crawl_listList this account's crawls, newest first, with status and coverage (no results). Pass next_cursor as cursor for the next page; next_cursor is absent on the last page.- +40 more on the listing page
Ready-to-paste client configs
Paste either block (or both) into your client config, e.g. claude_desktop_config.json or ~/.cursor/mcp.json. We only show a config when the install command is confirmed.
Mobile MCP
{
"mcpServers": {
"mobile-next-mobile-mcp": {
"command": "npx",
"args": [
"-y",
"@mobilenext/mobile-mcp@latest"
]
}
}
}
Zenrows MCP
{
"mcpServers": {
"zenrows-mcp": {
"command": "npx",
"args": [
"-y",
"@zenrows/mcp"
]
}
}
}
Frequently asked questions
Mobile MCP is categorized under Search & Data Extraction and uses a local stdio subprocess. Zenrows MCP belongs to Search & Data Extraction and uses a local stdio subprocess. Pick Mobile MCP for search & data extraction work and Zenrows MCP for search & data extraction.
Copy the mcpServers block from the config section on this page into your client's config (for example claude_desktop_config.json or ~/.cursor/mcp.json), then fully restart the client.
Mobile MCP is listed as free. Auth: no auth required. Zenrows MCP is listed as freemium — a free tier with paid plans. Auth: api key required. If a server needs environment variables such as API keys, define them under the env key in your client's MCP config.
Yes. MCP clients support multiple servers: add mobile-next-mobile-mcp and zenrows-mcp as separate keys in the same mcpServers object, and your assistant will call tools from either one.
On AllMCPs, Mobile MCP has a quality signal of 69/100 (Great) with 7 views, 0 installs and 9,896 GitHub stars. Zenrows MCP has 67/100 (Great) with 2 views, 0 installs and 20 GitHub stars.