If you're searching for "a parser," you almost certainly already know that A-Parser has long been the de facto standard for bulk data collection from search engines, marketplaces, maps, and arbitrary websites. But every powerful parser has a bottleneck that neither thread count nor a fast server can solve. It's IP addresses. Search engines and large platforms evaluate not just request frequency but also the reputation of an address, whether it belongs to a carrier network, and the activity history of its subnet. Server ranges lose out in that scoring system before they even start: they're known, predictable, and often already "burned" by someone else's automation.

Mobile proxies solve this problem in a fundamentally different way. Requests go out through real SIM cards on a cellular network, and a single carrier external address is simultaneously shared by thousands of regular subscribers. Any harsh sanction against such an IP would hit real people, so platforms treat mobile addresses noticeably more leniently. In this article, we'll walk through how to properly connect a MobileProxy.Space mobile proxy pool to A-Parser in 2026, how to choose the rotation mode for each task, and how to squeeze maximum practical value out of the combo.

One important caveat. In 2022, we already published a basic piece called "A-Parser and Mobile Proxies," where we covered the interface and initial setup. We won't repeat that here. Instead, we'll focus on what's changed: working with the IP change API, combining HTTP and SOCKS5 ports, sizing the pool for a specific workload, and six scenarios you can each reproduce in a single evening.

A-Parser Overview: What the Tool Can Do and Why It Needs Mobile Proxies

A-Parser is a server application with a web interface that runs on Windows or Linux and is managed from a browser. Inside, there are dozens of built-in parsers grouped into categories: SE for search engines, Shop for marketplaces, Maps for mapping services, Net for low-level HTTP requests, and HTML for parsing markup. Each task is assembled from a preset, a query list, and a result format. On top of that, there are JavaScript parsers you can use to write your own logic for any website, and a JSON API through which A-Parser integrates into external pipelines.

Key Features That Matter When Working With Proxies

  • Proxy checkers. A-Parser can load a proxy list from a file or URL, periodically re-check it, and exclude non-working entries. For mobile ports, this means a port that's temporarily "silent" during an IP change will be automatically set aside and brought back into rotation after a check.
  • Ban management. If a platform returns a captcha or a 429 code, the parser marks the proxy as banned for a set period. This is the key mechanism we'll tie to link-based rotation.
  • Retries. A failed request isn't lost: it goes out through another proxy as many times as you allow in the settings.
  • Throttled multithreading. Thread count is set at the task level, which lets you align it with the number of ports in your pool.
  • Macros and result formats. You assemble the fields you need into CSV, JSON, or txt without post-processing.
  • API. Methods for queuing a task, checking its status, and retrieving the result file. The API is exactly where it's convenient to sync parsing with the proxy-side IP change.

Why Mobile Proxies and Not Server Proxies

The search engine doesn't see your parser; it sees a sequence of requests from a specific address. For a server IP, the typical pattern looks suspicious: one address, dozens of requests per minute, zero history of normal user behavior. For a mobile IP, that same intensity dissolves into the background traffic of thousands of subscribers who are also using search over the carrier network at that moment. The platform can't distinguish your request from a neighbor's on the same cell tower, and that's the main advantage.

The second advantage is controlled rotation. In a MobileProxy.Space pool, each port is tied to a physical modem, and the IP on that port changes either on a timer or via a link/API (as of 22.09.2026). You decide when the address should refresh: on a schedule or in response to an event in A-Parser. By comparison, a server proxy has a static address, and once it's banned, your only option is to drop it from the list.

Daily network figures illustrate the scale of rotation well: over 24 hours, the entire network performed 2,196,242 IP changes involving 8,795 modems, with a median of 95 unique IPs per modem (as of 14.11.2026). In other words, a single port runs your parser through nearly a hundred different carrier addresses in a day, and each one looks like a new subscriber to the platform.

Connecting a Mobile Proxy Pool to A-Parser: Step-by-Step Setup in 2026

Before we get to the scenarios, let's lock down the basic connection scheme. It's the same for all the tasks below; only the rotation mode and thread count differ.

Step 1. Get to Grips With the Ports

Each proxy in your MobileProxy.Space dashboard comes with an address, an HTTP port, and credentials. You don't need to memorize the SOCKS5 port separately: it's always the HTTP port plus one (as of 22.09.2026). If the HTTP port is 20010, the SOCKS5 port will be 20011. This rule simplifies generating lists for A-Parser: you take one base list and derive the second with simple arithmetic.

When should you use which protocol? An HTTP proxy is sufficient for all built-in SE and Shop parsers. SOCKS5 comes in handy if you're writing a JavaScript parser with non-standard connections or connecting A-Parser to tasks that need more than just HTTP traffic.

Step 2. Prepare the Proxy File

The line format for A-Parser is ip:port:login:password or login:password@ip:port; both are recognized. Put all the ports in your pool into a single text file. If you plan to split the pool across tasks, create several files: one for Google, another for Yandex, and a third for marketplaces. That way, a ban on one platform won't affect the other tasks.

Step 3. Add a Proxy Checker

  1. Open the settings section and the proxy checkers tab.
  2. Create a new checker and specify the source: a local file or a URL that serves the list.
  3. Select the check type that matches the protocol: HTTP for base ports, SOCKS5 for ports with the offset.
  4. Set the re-check interval. There's a nuance here that we'll cover below: the interval should account for the IP change time.
  5. Save and wait for the first check. Live ports will appear in the available proxy counter.

Step 4. Choose the Rotation Mode for Your Task

In the MobileProxy.Space dashboard, each port offers two modes: timer-based IP change and link/API-based change (as of 22.09.2026). Network practice shows both modes are used almost equally: the share of timer-based changes was 51.1%, with the rest being link/API changes (as of 14.11.2026). We recommend a simple rule:

  • Timer for long-running background tasks where predictability matters: rank tracking, suggestion collection, regular catalog crawling.
  • Link/API for tasks where reacting to an event matters: as soon as A-Parser gets a captcha or a 429 code, the script triggers the IP change link for that specific port.

Step 5. Align the Timer With A-Parser Settings

An IP change isn't instantaneous. The average duration of a change from command to the appearance of a new address was 4.56 seconds, and 80.8% of changes completed within five seconds (as of 14.11.2026). This means that during rotation, the port is unavailable for a few seconds, and a request that lands in that window will fail with a connection error. To keep those errors from becoming data loss, do two things:

  • Enable retries in the task settings. The retry will go out through a different port in the pool.
  • Don't set the proxy checker's re-check interval shorter than the change duration. Otherwise, the checker will "catch" ports during rotation and temporarily exclude them for no real reason.

Step 6. Match Threads to Ports

The biggest beginner mistake is launching a task with a hundred threads on a pool of just a few ports. Each port gets a flood of requests from one IP, and the platform responds with a captcha before you even collect the first results page. Start with a thread count equal to the number of ports and ramp up gradually, watching the error rate in the task log. If errors grow, you've found your pool's ceiling. From there, either expand the pool or slow down the task.

Scenario 1: Building a Keyword Universe From Google and Yandex SERPs via A-Parser

Who it's for: SEO specialists, agencies, content site owners. What it's for: getting an accurate picture of the SERPs across thousands of queries so you can cluster keywords by URL overlap and find competitors you never suspected existed.

How It Works

The SE::Google and SE::Yandex parsers in A-Parser return, for each query, a list of results with position, URL, title, and snippet. If enough addresses in the top results overlap between two queries, those queries belong to the same cluster. Accurate clustering requires undistorted data, which means the SERP must be collected from one region and without personalization. Mobile proxies help twice over here: the search engine serves genuine regional results, and request frequency doesn't trigger captchas because each port regularly gets a new carrier address.

Step-by-Step Instructions

  1. Prepare your query list. Remove duplicates, lowercase everything, and split into files by region if you're collecting for multiple cities.
  2. Create a task with the SE::Yandex or SE::Google parser. In the parameters, specify the region, language, and number of results per page.
  3. Connect the proxy file with ports in timer mode. Choose an interval that's a multiple of a minute: that's how most ports on the network are set up, with the share of timer intervals that are exactly one minute at 78.1% (as of 14.11.2026). The median interval between timer-based changes is 120 seconds (as of 14.11.2026), and that's a reasonable starting point for search tasks.
  4. Set the thread count equal to the number of ports. Enable retries and proxy banning on captcha.
  5. In the result format, keep only the fields you need: query, position, URL, domain. This speeds up downstream processing.
  6. Run the task and monitor the ratio of successful to failed requests in the log. If errors grow, reduce threads or lengthen the timer interval.
  7. Export the CSV and load it into a clustering tool or your own Python script.

A Real-World Example

An agency was collecting keyword data for a chain of clinics across several cities. The first run on server proxies stalled after just a few hundred queries: Yandex started serving captchas on nearly every other request, and retries only accelerated the banning of the remaining addresses. After switching to a MobileProxy.Space mobile port pool with timer-based rotation, the task ran to completion without manual intervention, and the regional breakdown revealed different competitor sets for each city, something that had simply been invisible in the shared SERP before.

Tips

  • Split regions across different ports. Although the search engine relies on the region parameter in the query, results are more stable when the IP and region are aligned.
  • Collect SERPs at the same time of day for every query in a cluster. That way you eliminate the effect of intraday SERP fluctuations.
  • Skip snippet collection if you don't need it: the result volume shrinks by an order of magnitude, and so does processing time.

Scenario 2: Scheduled Rank Tracking Without Captchas or Manual Oversight

Who it's for: in-house SEO teams, agencies with dozens of clients, online store owners. What it's for: capturing rankings daily or weekly for a list of queries and tracking the dynamics without paying a third-party service for every check.

How It Works

A-Parser has dedicated rank parsers that take a query and a domain and return the site's position in the SERP. Essentially, it's the same SERP as in the first scenario, but the result is already aggregated. The difference is the operating mode: rank tracking runs on a regular schedule, so the proxy pool has to withstand recurring load day after day. Timer-based rotation wins here: you set the interval once and never touch the settings again.

Step-by-Step Instructions

  1. Prepare a list in "query;domain" format, or use a domain substitution macro for all queries in the project.
  2. Create a task with the rank parser for the search engine you need, and specify the region and check depth.
  3. Assign the task a dedicated proxy file. Don't mix tracking ports with bulk collection ports: tracking has a predictable load and needs "calm" addresses.
  4. Set up the A-Parser scheduler to run the task at a fixed time. That makes rank snapshots comparable.
  5. Use the A-Parser API to retrieve the result file when the task completes and load it into a database or spreadsheet for charting.

A Real-World Example

A home goods online store was tracking rankings across several thousand queries on two search engines. Initially, the team used a third-party service where every additional check cost money, so snapshots were taken infrequently and dips were missed. After moving tracking to A-Parser on a mobile port pool, daily snapshots became free in terms of checks, and dips in specific categories became visible on the same day they occurred. That made it possible to link drops to specific site changes.

Tips and Pitfalls

  • Use ports in timer mode with an interval that's a multiple of a minute. That's the most common setup on the network: the share of timer intervals that are exactly one minute stood at 78.1% (as of 14.11.2026), and it aligns well with the A-Parser scheduler.
  • Don't run tracking and keyword collection at the same time on the same ports. The peak load from one task will eat into the address's trust budget for the other.
  • Keep the raw results, not just the rankings. A month from now, you may need to see who held the top spots on a specific day.

Scenario 3: Parsing Yandex Wordstat and Search Suggestions via A-Parser

Who it's for: content marketers, editorial teams, product teams. What it's for: expanding your keyword universe through search volume and suggestions, finding new topics and seasonal demand peaks.

How It Works

The Wordstat parser in A-Parser returns a query's search volume and a list of related phrases, while the Google and Yandex suggestion parsers return autocomplete results for each prefix you enter. Both tasks are sensitive to request frequency from a single address: Wordstat is especially cautious about automation, and suggestions come back fast but the platform starts dropping responses at high intensity. A mobile pool with a short timer works best here: the address refreshes often, and each new IP looks like a new cellular subscriber to the platform.

Step-by-Step Instructions for Suggestions

  1. Build a list of seed phrases. Append alphabet letters to each phrase if you want to collect the maximum suggestion tree.
  2. Create a task with the suggestion parser for the chosen search engine, and enable recursive collection if you want to go deeper into the tree.
  3. Assign ports in timer mode with a short interval. Use the network median of 120 seconds as a reference (as of 14.11.2026) and decrease it if you see a rise in missed responses.
  4. Enable result deduplication at the task level so you don't store duplicates.
  5. Export the list and filter out branded and irrelevant phrases.

Step-by-Step Instructions for Wordstat

  1. Prepare your credentials if the parser requires authorization, plus your query list.
  2. Create a task with the Wordstat parser, and specify the region and volume type.
  3. Use a separate proxy file and a low thread count. Wordstat doesn't like to be rushed, and it's better to collect data overnight than to get your account blocked.
  4. Configure proxy banning on captcha and a long ban timeout, so that a banned port comes back into rotation already bearing a new address after rotation.

A Real-World Example

A personal finance media outlet was building a suggestion tree across several hundred seed topics to plan content for the quarter. The task on server proxies produced patchy results: some prefixes came back empty, and they had to selectively re-run. With a mobile pool and a short timer, the entire tree was collected in a single run, and the report surfaced seasonal phrases that the team then used in headlines.

Tips

  • HTTP ports are enough for suggestions. SOCKS5 offers no advantage here.
  • Combine steps: collect suggestions first, then run them through Wordstat for volume, then through the SERP parser for clustering. That's a closed loop that lives entirely inside A-Parser.
  • If you're collecting for multiple regions, run separate tasks on separate ports so regional suggestions don't get mixed up.

Scenario 4: Parsing Prices and Stock Levels on Marketplaces With A-Parser and Mobile Proxies

Who it's for: sellers, category managers, e-commerce analysts. What it's for: tracking competitor prices, product availability, ratings, and review counts to adjust your own pricing and assortment.

How It Works

A-Parser has built-in Shop parsers for major platforms, and for the rest you use Net::HTTP paired with the HTML parser or a custom JavaScript parser. Marketplaces protect their catalogs more aggressively than search engines: they track not just IP but also session behavior, headers, and request order. Mobile proxies cover the biggest risk factor — address reputation — and everything else is handled with proper headers and moderate frequency.

Step-by-Step Instructions

  1. Build a list of product pages or categories you need to track. Working by category is better: one category page yields dozens of products in a single request.
  2. Choose the parser: a built-in Shop parser for a supported platform, or Net::HTTP with subsequent HTML and JSON parsing. On modern marketplaces, data often sits in JSON inside the page, and it's easier to extract with a regular expression than to parse the markup.
  3. Configure request headers to look like a mobile browser. Since traffic goes over a cellular network, it makes sense for the User-Agent to be mobile too.
  4. Assign ports in link/API mode. For marketplaces, it's important to change the IP in response to an event: got a 403 or 429 — triggered the change link for that port.
  5. Limit the thread count to the number of ports and add pauses between requests on the same proxy.
  6. Set the output to JSON: SKU, price, old price, availability, rating, review count, collection date.
  7. Schedule the task to run daily and build up a price history.

How to Tie an A-Parser Ban to Link-Based IP Change

The most reliable approach in 2026 is an intermediary script. A-Parser writes proxy ban events to the log; the script reads the log, identifies the port, and calls the IP change link for that port. Two facts from the network statistics are important to factor in. First, a change takes an average of 4.56 seconds, and 80.8% of changes finish within five seconds (as of 14.11.2026), so the proxy ban duration in A-Parser should be well above that window. Second, the share of duplicate records for link-based changes with an interval of no more than two seconds and the same IP was 1.2% (as of 14.11.2026). That means calling the link again immediately after the first call doesn't yield a new address and just creates a redundant record. Build in protection against repeat calls: if the link for a port has already been triggered, wait for the change to complete before calling it again.

A Real-World Example

A home appliance seller was tracking the prices of several hundred competitors across key categories. On server addresses, the platform stopped returning prices after just a few dozen pages, substituting a verification placeholder. After switching to a mobile pool with link-based changes and a script reacting to response codes, the daily collection ran without placeholders, and pricing decisions started relying on fresh data instead of week-old exports.

Common Mistakes

  • Collecting product pages one by one instead of using category pages: many times more requests for the same amount of data.
  • A server User-Agent paired with a mobile IP: the platform sees the mismatch and shows verification more often.
  • No protection against repeat calls to the change link: empty calls and extra connection errors.

Scenario 5: Collecting Business Listings From Maps for Lead Generation and Competitor Analysis

Who it's for: B2B sales teams, local business marketers, franchise agencies. What it's for: building a database of businesses by category and city with addresses, phone numbers, websites, ratings, and review counts.

How It Works

The Maps parsers in A-Parser take a query like "category + city" and return business cards. Maps serve data in chunks and throttle intensity from a single address, and the throttling often shows up not as an explicit error but as truncated results. Mobile proxies with regular rotation give Maps the pattern of ordinary subscribers looking up nearby businesses from their phones, and the results stay complete.

Step-by-Step Instructions

  1. Build a list of categories and cities. For large cities, split queries by district or add qualifiers to get around the limit on results per SERP.
  2. Create a task with the maps parser, and specify the fields you need: name, address, phone, website, rating, review count, category.
  3. Assign ports in timer mode. For maps, an interval that's a multiple of a minute, around the network median of 120 seconds, works well (as of 14.11.2026).
  4. Enable deduplication by name and address: a business may appear in results across multiple queries.
  5. Export to CSV and hand it off to your CRM or email tool, complying with data protection and advertising laws.

A Real-World Example

A supplier of coffee shop equipment was building a database of venues across several regions for cold outreach. Manual collection took weeks and produced incomplete data. The A-Parser task on a mobile pool ran overnight, and the district-level breakdown surfaced venues that simply never appeared in whole-city queries. The sales team got a structured database with ratings and could prioritize venues with more reviews as more active businesses.

Tips

  • Collect reviews as a separate task, and only for businesses that passed the initial filter. That saves requests.
  • Use the rating and review count field as a signal of business activity for lead prioritization.
  • For competitor analysis, compare category results on different days: new locations and rating changes become visible immediately.

Scenario 6: Indexation Checks and Technical Site Audits via A-Parser

Who it's for: technical SEO specialists, owners of large sites, developers. What it's for: checking at scale which pages are indexed, which status codes URLs return, where redirects are broken, and where titles are duplicated.

How It Works

Two groups of parsers come together here. The first is SE parsers with operators like "site:" and "url:" that show whether a page is in the index. The second is Net::HTTP and HTML parsers that crawl the site itself, capturing status codes, headers, canonical links, and meta tags. Search operators are among the most automation-sensitive requests, and server addresses get captcha'd on them fast. A mobile pool with event-driven link-based changes lets you get through even a large URL list.

Step-by-Step Instructions

  1. Export your URL list from a sitemap or server logs.
  2. Create a Net::HTTP task: collect the status code, the final URL after redirects, the page title, and the canonical address. Proxies aren't mandatory for crawling your own site, but if you're checking how the site responds to mobile users from different regions, mobile ports give you the real picture.
  3. Create a second task with an SE parser and an indexation check operator. Assign it ports in link/API mode and connect the script that triggers a change on captcha.
  4. Cross-reference the results: pages returning 200 but missing from the index are candidates for rework; pages in the index that return 404 or 301 need fixing first.
  5. Repeat the audit on a schedule to catch regressions after releases.

A Real-World Example

A large classifieds site lost part of its traffic after migrating to a new URL structure. Using A-Parser on a mobile pool, the team checked the indexation of tens of thousands of old and new addresses and found redirect chains that the search engine never followed to the end. Fixing the chains and re-checking through the same task confirmed that the new addresses started appearing in the index.

Tips

  • For search operators, use a separate small port pool with link-based changes. These are the "most expensive" requests reputation-wise, and it's not worth mixing them with other tasks.
  • Check site responses through SOCKS5 ports if your JavaScript parser uses non-standard connections: remember that the SOCKS5 port is the HTTP port plus one (as of 22.09.2026).
  • Save the check date in every result row so you can build an indexation history.

Sizing Your Pool and Automating via API: Insider Recommendations

The question we hear most often after first runs is: how many ports do I need? There's no universal number, and we deliberately don't give one, because it depends on the platform, SERP depth, region, and your tolerance for speed. But there's a method that gives you an answer in one evening.

Sizing Method

  1. Take a small pool of ports and one typical task.
  2. Run it with a thread count equal to the number of ports, and record the success rate and speed in the A-Parser log.
  3. Double the threads and repeat. If the error rate doesn't rise, keep doubling. As soon as errors start to grow, you've found the load ceiling per port for that platform.
  4. Divide your daily request volume by the volume one port handled without error growth during the test, scaled to a full day. That's the number of ports you need.
  5. Add a buffer for rotation windows: each IP change takes an average of 4.56 seconds (as of 14.11.2026), and the port is out of service during that time.

Automating the Combo via API

In 2026, a mature pipeline looks like this. An external orchestrator queues tasks in A-Parser via the add-task method, periodically polls their status, and retrieves the result file when they complete. At the same time, it listens to the A-Parser log for proxy bans and calls the IP change link for the specific port. Two rules make this scheme resilient:

  • Don't call for a change more often than it physically happens. The share of duplicate records for link-based changes with an interval of no more than two seconds and the same IP was 1.2% (as of 14.11.2026). Those are exactly the repeat calls that achieve nothing but extra errors.
  • Keep part of the pool on the timer, part on the link. That's how the network as a whole operates: 51.1% of changes happen on the timer, the rest via link/API (as of 14.11.2026). The timer portion provides background address freshness, and the link portion reacts to events.

Combinations With Other Tools

  • A-Parser plus spreadsheets and BI. The API result goes into storage, and a dashboard shows the dynamics of rankings, prices, or indexation.
  • A-Parser plus Python. A Python script reads the log, manages IP changes, and runs post-processing: clustering, price comparison, deduplication.
  • A-Parser plus an anti-detect browser. For pages that require full rendering, you go through an anti-detect browser using the same mobile ports, while leaving bulk collection to A-Parser. It's important not to use the same port in both systems at once, or the platform will see two different "devices" on the same address.
  • A-Parser plus custom JavaScript parsers. For sites without a built-in parser, you write the logic in JavaScript inside A-Parser, and proxies are connected with the same settings.

Comparing A-Parser and MobileProxy.Space Mobile Proxies Against the Alternatives

To make the choice an informed one, let's compare several approaches that are usually considered alongside A-Parser.

Server Proxies

Cheaper, but with fixed addresses and known subnets. For tasks with aggressive protection, they burn through their trust budget quickly, and once banned, your only option is to drop the address. There's no rotation, so reacting to a captcha amounts to manually refreshing the list. They're still appropriate for parsing your own sites or lightly protected sources, but they lose out for search engines, maps, and marketplaces.

Residential Proxies With Per-Minute Traffic Billing

Home user addresses look natural, but you don't control rotation: the address changes according to the provider's logic, and you can lose a session at the moment of change. Traffic-based billing makes bulk HTML collection unpredictable budget-wise. With MobileProxy.Space mobile ports, rotation is controlled by you — on a timer or via link/API (as of 22.09.2026) — and the cost doesn't depend on the volume of pages loaded.

Ready-Made Cloud Parsing Services and Rank Tracking Services

Convenient when you have few tasks and they're standard. But you pay per request, you don't control the proxies, and you can't tailor the collection logic to a non-standard site. A-Parser with your own pool gives you unlimited checks at a fixed infrastructure cost and lets you write any parsers you need.

DIY Python Scripts

Flexible but slow to build. You write the queues, retries, ban lists, SERP parsing, captcha handling, and markup-change support yourself. A-Parser already contains all of that and updates its built-in parsers to match platform changes. At the same time, nothing stops you from using Python as an orchestrator on top of A-Parser, which is exactly what we recommend.

Why MobileProxy.Space Specifically

  • Two rotation modes on every port: timer or link/API (as of 22.09.2026), covering both background and event-driven scenarios.
  • Fast changes: average duration 4.56 seconds, with 80.8% of changes completing within five seconds (as of 14.11.2026). The port's downtime window is minimal.
  • High address variety: the median number of unique IPs per modem per day was 95 (as of 14.11.2026).
  • Network scale: 8,795 modems changed IPs per day, with a total of 2,196,242 changes (as of 14.11.2026).
  • Predictable port scheme: the SOCKS5 port is the HTTP port plus one (as of 22.09.2026), which simplifies automatic list generation.

FAQ: Practical Questions About A-Parser and Mobile Proxies

Should I use SOCKS5 instead of HTTP for built-in parsers?

No. Built-in SE, Shop, and Maps parsers work through HTTP ports. SOCKS5 comes in handy for custom JavaScript parsers with non-standard connections. Remember the rule: the SOCKS5 port is the HTTP port plus one (as of 22.09.2026).

What timer interval should I start with?

Use network practice as a guide: the median interval between timer-based changes was 120 seconds, and 78.1% of intervals are exactly one minute (as of 14.11.2026). Start with that value and adjust based on the error rate in the task log.

Why do some requests fail with connection errors even though the proxies are live?

Most likely, the request landed in an IP change window. A change takes an average of 4.56 seconds (as of 14.11.2026), and the port is unavailable during that time. Enable retries in A-Parser: the retry will go out through a different port.

How can I get A-Parser to change the IP automatically on a captcha?

A-Parser doesn't directly call external links on a ban, but it does write the event to the log. A small script reads the log, identifies the port, and calls the IP change link from the MobileProxy.Space dashboard. Add protection against repeat calls: the share of duplicate records for link-based changes with an interval of no more than two seconds was 1.2% (as of 14.11.2026), and those are exactly the calls that don't yield a new address.

How many threads should I set per port?

Start with one thread per port and increase until the error rate starts to grow. The ceiling depends on the platform and SERP depth, so measure it on your own task using the method from the pool-sizing section.

Can I use the same pool for Google, Yandex, and marketplaces at the same time?

Technically yes, but it's better to split them. A ban on one platform sends the port to the A-Parser ban list for all tasks, and you'll lose throughput where there was no problem. Separate proxy files for different platforms solve this.

What should I do if results come back from a different region?

Check the region parameter in the parser settings and use ports that geographically match the region you need. Aligning the IP with the query region improves result stability.

How do I know my pool isn't enough?

The signs: a growing captcha rate at a constant thread count, frequent retries, falling task speed. Either expand the pool or reduce threads and lengthen the timer interval.

Is it legal to collect data this way?

Collecting publicly available information for analytics is legal in itself, but you must comply with platform rules, data protection law, and advertising law when using the collected contacts later. Don't collect or store personal data without a lawful basis, and don't use proxies for actions that violate the law.

Takeaways: Who the Combo Is For and How to Start

The combination of A-Parser and a MobileProxy.Space mobile proxy pool is a tool for anyone who needs to regularly and at scale pull data from protected sources: search results, suggestions, Wordstat, maps, and marketplaces. SEO specialists get per-check-free rank snapshots and genuine regional results for clustering. E-commerce analysts get daily competitor price history. Sales teams get business databases with ratings. Technical specialists get bulk indexation audits.

The main thesis of this article is simple: A-Parser's power only unfolds together with controlled address rotation. Two IP change modes per port — timer and link/API (as of 22.09.2026) — cover both background and event-driven tasks. Fast changes averaging 4.56 seconds (as of 14.11.2026) minimize the downtime window, and high address variety with a median of 95 unique IPs per modem per day (as of 14.11.2026) makes each port multifaceted in the platform's eyes.

How to Start in a Single Evening

  1. Get a small pool of ports in the MobileProxy.Space dashboard and note the HTTP ports; calculate the SOCKS5 ports by adding one.
  2. Add the proxy file to the A-Parser proxy checker and wait for the first check.
  3. Pick one task from this article, say suggestion collection, and run it with a thread count equal to the number of ports and a timer that's a multiple of a minute.
  4. Check the log, assess the error rate, and adjust threads and interval.
  5. Add the script for link-based IP change on a ban, and move part of the pool over to event-driven rotation.
  6. Scale the pool using the sizing method once you understand the ceiling per port.

Which task will you run first? If it's rank tracking, start with the timer. If it's marketplace parsing, set up link-based changes right away. In either case, A-Parser handles the queues, retries, and formats, while MobileProxy.Space mobile proxies provide what no server can: addresses that platforms consider their own regular subscribers.