Introduction

In this step-by-step guide, you will learn how to initiate web scraping without programming in two popular no-code tools—Octoparse and ParseHub—using mobile proxies. We’ll set up the environment, connect to a mobile proxy provider, tackle a real data collection task, adjust for anti-ban measures and limits, and finally validate and export the results. By the end, you'll have a robust scraping process that is resistant to blocking and ready for scaling and regular data updates.

Who this guide is for: beginners looking to get started quickly without coding; marketers, analysts, and data specialists who need a reliable and straightforward data collection process; and advanced users will find optimization tips in the "Advanced Features" section.

What you should know beforehand: basic computer and browser skills. No programming knowledge is required.

Estimated time required: 2–4 hours for the full process, including installation, proxy setup, and test scraping. If you already have experience with the tools, it will take around 60–90 minutes.

Preparation

Required tools and access:

  • An Octoparse account (Windows, macOS; a cloud version is available). Any current version from 2025–2026 will work.
  • A ParseHub account (desktop app for Windows/macOS and web account). Choose the most recent build.
  • An account and access to mobile proxies from a reliable provider. A service that offers real mobile IPs, authentication by username and password, and flexible rotation management will suffice. A suitable example is mobileproxy.space as a supplier of mobile proxies and automation tools.
  • A test website that permits academic scraping. We will use a demo resource for training purposes—"Books to Scrape" (a public demo site for practice). You can replace this example with another site if you have permission and it doesn’t violate the resource's rules.

System requirements:

  • A PC running Windows 10/11 or macOS 12+ with 8GB RAM and 2–4GB of free disk space.
  • A stable internet connection of 10 Mbps or higher.
  • The ability to install software and access network settings to check proxies.

What to download and install:

  1. Download and install Octoparse from the developer's official site. During installation, select the language and installation directory. Once completed, log into your account or create a new one.
  2. Download and install ParseHub. Launch the app and log into your account.
  3. Purchase a plan from the mobile proxy provider. In your personal account, obtain the proxy address (host and port), username, and password. If an IP rotation panel is available, set the address change interval, e.g., every 3–10 minutes.

Creating backups (relevant for projects):

  • In Octoparse, export the project to an .otd file after each major change.
  • In ParseHub, save the project and create a local copy of the project file from the "File" → "Save As" menu.

Tip: Keep your proxy authentication data separate from your projects. Use a password manager and create distinct access for training and production tasks.

Basic Concepts

Key terms in simple language:

  • No-code scraper—a program that allows you to collect data from websites without programming. Users set it up by clicking to specify what to open, what to click, and what to extract.
  • Proxy—an intermediary server that processes your internet requests. The site sees an IP address from the proxy rather than your real IP.
  • Mobile proxies—proxies utilizing real IP addresses from mobile operators (3G/4G/5G). These change more frequently and appear natural to websites, reducing the risk of bans with careful use.
  • IP rotation—periodic changing of the IP address. In mobile proxies, this can be automatic via a timer or API switch on the provider's panel.
  • Selector—a way to specify which element on the page to extract (e.g., product title, price). In Octoparse and ParseHub, this is done by clicking on page elements.
  • Pagination—navigation through pages containing a list of results ("Next" buttons, page numbers).
  • Session—a series of requests from a single IP. A "sticky" session holds the IP temporarily to complete a task without changing addresses mid-task.

Basic operational principles:

  • The scraper opens a page, waits for it to load, finds the necessary elements, extracts text, links, or attributes, moves to the next page, and repeats the process.
  • Proxy settings are established once in the project settings. After that, all network requests go through it.
  • For stability, use moderate speeds, pauses between actions, and IP rotation.

What to keep in mind before starting:

  • Follow the source website's rules and the laws of your country. Respect robots.txt and terms of service. Get permission if you plan on intensive data scraping.
  • Do not extract personal data not meant for automated collection. Work only with open and permitted information.
  • The purpose of mobile proxies is reliable and correct operation, not to bypass restrictions set by law or site owners.

⚠️ Attention: Never use proxies and scraping tools for actions prohibited by local law or site rules. This guide is meant for legitimate educational and professional scenarios with authorized access to data.

Step 1: Plan Your Task and Prepare the Data Structure

Goal of the Stage

Define what data you need, where it’s located on the page, how to navigate pages, and set rules for request frequency. The result will be a simple plan mapping fields to selectors and sources, along with a list of URLs to get started.

Detailed Instruction

  1. Open the educational site with products (e.g., Books to Scrape). Ensure that this is a demo resource allowing academic data collection.
  2. Identify the fields for extraction: product name, price, rating, availability (In stock), link to the product card, and cover (image URL).
  3. Document the data structure: create a table in Google Sheets or Excel with columns Title, Price, Rating, Availability, ProductURL, ImageURL.
  4. Check pagination: find the "next" button or page numbers at the bottom of the list. Note the CSS class or text of the button (e.g., "li.next a").
  5. Assess the depth: how many pages and products there are. For testing, take 3-5 pages.
  6. Determine request frequency: start with 1 request every 2–4 seconds and gradual pauses before pagination.

Tip: The simpler your initial goal, the easier the debugging will be. Start with 1–2 fields (e.g., name and price), then add the others.

Expected Result

You will have a list of starting URLs, a list of fields, and an understanding of how to navigate pages.

Potential Problems and Solutions

  • Unclear where the required element is located. Solution: hover over the element in your browser and use "View page source" to find a unique attribute or class.
  • Unstable pagination. Solution: use the "next" button instead of page numbers, which tends to be simpler and more stable.

✅ Verification: Your table contains a list of fields and 3-5 starting URLs. Understanding of pagination is confirmed.

Step 2: Acquire and Test Your Mobile Proxy

Goal of the Stage

Set up the mobile proxy, obtain the address, port, username, and password, choose the IP rotation mode, and ensure that the proxy functions reliably.

Detailed Instruction

  1. Log in to the mobile proxy provider’s personal account. A relevant example would be mobileproxy.space, where mobile IPs from operators are available, along with customizable rotation and authentication documentation.
  2. Create a proxy account. Specify the necessary pool of cities or countries if needed for the task. For the educational project, use the default region.
  3. Copy the settings: host (e.g., gw.provider.example), port (e.g., 10000–20000), username, and password. Save the data in your password manager.
  4. Set the IP rotation: choose an interval of 3–10 minutes. For stable page scraping, use a sticky session for 5–15 minutes so that the IP does not change mid-extraction.
  5. Test the proxy for functionality: open a browser and set your system proxy (HTTP) to the provided host:port with the username and password. Visit an "IP check" page or any permitted service where you can view your external address, and ensure the IP has changed to a mobile one.
  6. Disable the system proxy in your browser after testing so that it does not interfere with further tool operations.

Tip: If your provider offers an API button for "change IP," note its URL. This will come in handy for manually switching IPs between task runs.

Expected Result

You will have active mobile proxy credentials and confirmation that the IP is correctly swapped and the rotation is set up.

Potential Problems and Solutions

  • Authorization error in the browser. Solution: check the accuracy of the username and password and consider case sensitivity.
  • Website won’t load through the proxy. Solution: change the node or port in the provider’s dashboard or contact support. Ensure that you’re using a supported protocol (HTTP/HTTPS).

✅ Verification: You confirm the external IP of the mobile proxy and know how to initiate rotation if necessary.

Step 3: Configure Mobile Proxy in Octoparse

Goal of the Stage

Connect the mobile proxy to a specific project in Octoparse so that all requests go through it with the necessary rotation and delays.

Detailed Instruction

  1. Open Octoparse and log into your account. On the main screen, click "+ New" or "Create Task".
  2. Enter the starting URL from your list (e.g., the main page in the "Books" section). Click "Save URL" or "Start" to preview.
  3. Open project settings. In the left panel, find the sections "Settings," "Advanced," or "Task Settings" (the name may differ depending on the version). Navigate to the "Proxy" or "IP Rotation" block.
  4. Select "Use my proxy" or "Custom proxy." Enter the host and port of your mobile proxy.
  5. Provide authorization: enter the username and password. If there’s an option "Remember credentials," enable it.
  6. Activate IP rotation in Octoparse (if available), or leave it to the provider's side. If Octoparse allows "Change IP every X minutes," synchronize the interval with the settings in the proxy dashboard (e.g., 5 minutes).
  7. Set speed: in "Speed" or "Execution settings," set delays of 2–4 seconds between actions and 5–8 seconds before pagination. Enable "Randomize delay" if available.
  8. Save your settings. Click "Test connection" (if available) to ensure the project can access the internet through the proxy.

Tip: Maintain different proxy profiles for different projects. Specify the region and rotation interval in the names to avoid confusion.

⚠️ Attention: Do not initiate parallel execution of multiple threads on one mobile IP. This could raise suspicion. It is better to scale by the number of proxies instead.

Expected Result

The project in Octoparse is saved, the connection test passes, and the preview of pages opens smoothly.

Potential Problems and Solutions

  • "Failed to connect via proxy." Solution: double-check the host:port, authorization, and ensure there’s no system proxy in the OS conflicting with the app.
  • The page loads too slowly. Solution: increase the loading timeout in "Advanced" and decrease the number of simultaneous requests.

✅ Verification: In the Octoparse preview, the pages open without errors, and the connection log indicates access through your proxy.

Step 4: Configure Mobile Proxy in ParseHub

Goal of the Stage

Connect the mobile proxy to the ParseHub project so that all network calls go through the specified IP address with authorization and delays.

Detailed Instruction

  1. Open ParseHub and create a new project: click "New Project," enter the starting URL. Wait for the page to load in the preview window.
  2. Go to project settings. In the right panel or through the gear icon, open "Project Settings" or "Network" (the name may vary depending on the version).
  3. Find the "Proxy" or "Use proxy server" section. Select the HTTP/HTTPS protocol, then enter the host and port of your mobile proxy.
  4. Provide the username and password for authorization. If a checkbox for "Save credentials" is available, activate it.
  5. Set delays in execution settings: "Delay before actions" to 2–4 seconds, "Page load timeout" to 20–40 seconds, and enable "Randomize delays" if that option is available.
  6. Save your settings. If a "Test proxy" or "Test connection" button is available, perform the test.
  7. Return to the preview window and refresh the page. Ensure that the content loads consistently and without authorization errors.

Tip: If your provider has different exit points (cities), use different hosts for separate ParseHub projects. This simplifies log analysis and enhances stability.

Expected Result

The ParseHub project opens pages without errors, and the proxy mode is active.

Potential Problems and Solutions

  • Authorization keeps popping up. Solution: re-enter the username and password in the settings, ensuring no extra spaces were included while copying.
  • The page won’t load in the preview. Solution: increase the timeout, ensure the proxy is functioning (check in the browser), and change nodes with the provider if necessary.

✅ Verification: In the ParseHub preview, the pages consistently open through the proxy. There are no 407 Proxy Authentication Required errors.

Step 5: Create and Run a Task in Octoparse (Example)

Goal of the Stage

Set up a chain of actions in Octoparse to extract title, price, rating, availability, link, and image from a list of products. Achieve a stable scenario with pagination and export.

Detailed Step-by-Step Instruction

  1. In the project with the proxy already connected, enter the starting URL of the catalog section. Click "Go" for the preview.
  2. Click "Auto-detect web page data." Wait for Octoparse to highlight the product list blocks and suggest fields.
  3. Check the suggested fields. If necessary, click on the product title and choose "Extract text"; for price—"Extract text"; for the link—"Extract URL"; for the image—"Extract image URL"; for the rating—extract the class attribute and then convert it to a readable rating.
  4. Create a "Loop Item" for cards: ensure Octoparse identified a repeating list. If it did not, manually select two identical items in the list and click "Select all" to create the loop.
  5. Add pagination: click on the "next" button at the bottom and choose "Click to Paginate." Set a limit on the number of pages, e.g., 3 for testing.
  6. Set pauses: in the "Click" settings for pagination, add a "Wait before next action" of 5–8 seconds.
  7. Open "Data preview." Verify that you have columns for Title, Price, Rating (possibly as the class "star-rating Three" etc.), Availability, ProductURL, ImageURL.
  8. If needed, add "Clean data" steps: remove currency symbols from prices, map rating classes to numbers (One–Five → 1–5), trim spaces.
  9. Save the project and run "Run" with the following parameters: "Local run" for testing; use default delay intervals from settings, set threads to 1.
  10. After the export is complete, choose the format as CSV or Excel. Specify the save path and filename, e.g., octoparse_books_test.xlsx.

Tip: If auto-detection selects extra elements, manually remove them in the "Fields" panel. Keep only the necessary columns to speed up processing and simplify post-processing.

Tip: For correct "Availability," extract not just text but also check for the presence of an "availability" element on the card. If the element has an attribute with quantity, add it as a separate field.

Expected Result

You will obtain a correct data set from 3–5 pages: no less than 60–100 rows with all fields and valid links.

Potential Problems and Solutions

  • The "Loop Item" is not created. Solution: manually select two adjacent identical items on the card and press "Select all." Then add "Extract data" for each required sub-element.
  • The rating is extracted as a class text. Solution: use "Clean data" with the "Replace" function for mapping "star-rating Three" → "3."
  • Pagination won't click. Solution: increase "Wait for element" and "Timeout," ensuring you selected the link element and not the container.

✅ Verification: In preview and final export, the values in the columns match expectations. There are no blank rows, links are clickable, and images open correctly.

Step 6: Create and Run a Task in ParseHub (Example)

Goal of the Stage

Gather a similar data set in ParseHub by configuring the selection of elements, pagination, and export.

Detailed Step-by-Step Instruction

  1. In the open ParseHub project, click the "Select" tool and click on the title of the first product. Then click on the title of the second product to set a template for the repeating element. The list will be highlighted in green.
  2. In the right panel, click "Extract" to extract the header text. Rename the field to Title.
  3. Similarly, select the price from the first and second cards. Click "Extract," select the type "Text," and name the field Price.
  4. For the product card link, select the product title and in the field properties choose "Extract" → "URL" instead of text. Name the field ProductURL.
  5. For the image, select the image on the card and choose "Extract" → "Image URL." Name the field ImageURL.
  6. For the rating, click the star icon or text block of the rating. If it is embedded in the class, extract the attribute "class," then set up a "Transform" rule for replacing "One"–"Five" with numbers.
  7. Add "Availability": click the availability block and extract the text. Name the field Availability.
  8. Set up pagination: click on the "next" button or the number of the next page and select "Click." Set "Repeat current template" for up to 3–5 pages.
  9. Add delays in "Click" and "Wait" actions of 4–8 seconds before switching pages. Enable "Randomize" if available.
  10. Click "Run" for a local execution. Wait for completion and then export the result to CSV/Excel.

Tip: If ParseHub highlights too broad a container, narrow the selection: click on the necessary sub-element again or use "Empty selection" and add elements gradually.

Tip: For complex pages, add a "Wait for element" step with a specific CSS attribute to wait for the desired block before extraction.

Expected Result

You will obtain a similar data set comparable to the export from Octoparse, confirming the logic and stability of the proxy.

Potential Problems and Solutions

  • The list is not recognized. Solution: select two identical cards in a row so that ParseHub sees the repetition pattern.
  • Fields are occasionally empty. Solution: increase delays after page load and use "Wait for element" for content.

✅ Verification: Data exports consistently without gaps; the export to CSV/Excel opens and matches the expected structure.

Step 7: Anti-Ban Measures and Limits: How to Maintain Stability

Goal of the Stage

Protect processes from excessive blocking by maintaining a careful pace, appropriate rotation, and quality control of requests.

Recommended Settings

  1. Request pace: maintain a maximum of 1–2 requests per second, but preferably slower—1 request every 2–4 seconds.
  2. Delays during pagination: 5–10 seconds, ideally with randomization.
  3. IP rotation: every 3–10 minutes. For lengthy product cards, use a sticky session of 5–15 minutes to avoid losing context.
  4. Parallelism: 1 thread per mobile IP. For scaling, add new proxies, not threads on one IP.
  5. Timeouts: Page Load Timeout of 20–45 seconds, with retry attempts of 1–2 times on failure.
  6. Pause between runs: 3–5 minutes to let the network "cool down" after a long session.

Tip: Keep a log: record the rotation interval, the number of pages collected, and error metrics. This helps fine-tune your limits.

⚠️ Attention: Avoid circumventing the technical restrictions of the website. If a resource explicitly bans automated collection, do not use scraping. Operate only within permitted realms and at volumes that the site can handle without harm.

Expected Result

Lower loading errors, no spikes of CAPTCHAs or bans, and even data collection rates.

Potential Problems and Solutions

  • Frequent CAPTCHA occurrences. Solution: reduce speed, increase delays, cut down parallelism, and if necessary, change the proxy region with the provider.
  • Random 403/429 responses. Solution: add more pauses, minimize depth per run, and use a scheduler with intervals.

✅ Verification: Log files show decreased denial rates. Average time per page remains stable, and the overall percentage of filled fields increases.

Step 8: Export, Validation, and Structuring Data

Goal of the Stage

Correctly export results, verify their integrity, and structure them for easier analysis.

Detailed Instruction

  1. Export results from Octoparse to Excel (XLSX) and from ParseHub to CSV. Rename the files with the date, e.g., books_octoparse_2026-06-22.xlsx and books_parsehub_2026-06-22.csv.
  2. Open the exports and check for all columns. Manually verify 5–10 random entries against the website.
  3. Check for duplicates: sort by ProductURL and remove repeating rows.
  4. Clean the data: remove currency symbols, convert prices to numbers, normalize ratings from 1 to 5, and trim spaces.
  5. Save the final file as a master version. Make a copy for working and another for archiving.

Tip: Introduce simple quality control rules: at least 95% filled key fields and no more than 2% duplicates in the test run.

Expected Result

A clean and complete dataset ready for analysis or upload into BI/CRM.

Potential Problems and Solutions

  • Incorrect CSV encoding. Solution: open the file in an editor, select UTF-8 or import it into Google Sheets specifying the encoding.
  • Mismatched delimiters. Solution: export to XLSX or specify a semicolon as the delimiter.

✅ Verification: Manual verification of 10 entries confirms accuracy. Fields match the expected format.

Step 9: Automating Runs and Stability Monitoring

Goal of the Stage

Set up regular task launches, logs, and monitoring to maintain results without manual involvement.

Detailed Instruction

  1. In Octoparse, open "Schedule" or "Task Scheduler." Create a schedule, e.g., daily at 02:00. Define limits on depth and line counts per run.
  2. In ParseHub, configure "Schedule Runs" through the web dashboard: select frequency (daily or weekly), limit execution time and number of pages.
  3. Set up alerts: enable email notifications for task completions and errors.
  4. Add IP rotation controls: in the provider’s panel, enable auto-refresh of IP on a timer, synchronizing it with task schedule starts. If necessary, set the IP change before task start.
  5. Maintain logs: export the run logs to CSV weekly for analysis. Record time, the number of collected rows, and error loading counts.

Tip: Do a short test run 10–15 minutes before the main schedule to ensure the site is accessible and the proxy is operational.

Expected Result

Tasks launch reliably on schedule, data is refreshed, and you receive alerts for errors to respond quickly.

Potential Problems and Solutions

  • The task fails overnight. Solution: enable retry on errors, extend timeout durations, and reduce depth.
  • Occasionally, the IP doesn’t switch in time. Solution: schedule IP changes 1–2 minutes before the task begins.

✅ Verification: The logs indicate successful overnight runs, completion emails are received, and data volume is growing as planned.

Outcome Verification

Checklist: what should be working

  • Octoparse and ParseHub open the starting pages without errors, and the proxy is active.
  • Fields are extracted correctly, pagination clicks through and waits for loading.
  • Export to CSV/XLSX creates readable files without distortion.
  • The average percentage of empty fields does not exceed 5% in the test set.
  • IP rotation works at the specified intervals, and there are no authorization errors.

How to test

  1. Run a short test on 2-3 pages and check the logs: the share of successful loads should be at least 95%.
  2. Verify ten random entries manually against the website.
  3. Check whether the external IP changes according to the schedule in the provider’s panel.

Indicators of successful execution

  • Launch without proxy authentication errors.
  • No frequent CAPTCHAs or 403/429 responses.
  • Stable average load time per page and consistent data volume per run.

Common Mistakes and Solutions

  • Issue: "407 Proxy Authentication Required." Cause: incorrect username/password. Solution: double-check credentials, remove unnecessary spaces while copying, save settings, and test again.
  • Issue: pages won’t load or load very slowly. Cause: too short timeout, overloaded node, high request speed. Solution: increase the timeout, lower the speed, change nodes with the provider.
  • Issue: some rows have empty fields. Cause: elements do not have time to render. Solution: add "Wait for element," increase delays and enable randomization.
  • Issue: pagination clicks but data does not change. Cause: incorrect element selection or need to wait for an update. Solution: select the link within the "next" button, add "Wait for navigation."
  • Issue: duplicate records. Cause: collection of identical cards from adjacent pages due to filters. Solution: filter by ProductURL, enable duplicate checks on export.
  • Issue: sudden IP bans. Cause: an overly aggressive pace. Solution: reduce parallelism to one thread per IP, increase pauses, and use a reasonable-length sticky session.
  • Issue: incorrect CSV encoding. Cause: system locale settings. Solution: use XLSX or import CSV with explicit UTF-8 setting.

Advanced Features

Advanced settings:

  • Rotation scheduling: set automatic IP change in the provider's dashboard before each scheduled start. This decreases the likelihood of behavioral footprints accumulating on one IP.
  • Sticky sessions for cards: while navigating to a product card, stick to an IP for 5–10 minutes to finish collecting from one address. This reduces the risk of discrepancies.
  • On-the-fly data cleansing: use "Clean data" in Octoparse and "Transform" in ParseHub for standardizing price, ratings, and links during collection.
  • Task separation: break the collection process into two phases—listing and card details. First, collect ProductURL, then separately process through them. This simplifies quality control and restarts.
  • Integrations: export directly to Google Sheets or databases if your plan supports it. Set up alerts on data quality.

Optimization:

  • Speed versus stability: don’t chase maximum speed. Consistently scraping 1–2 pages per minute is often better than bursts that risk bans.
  • Regionality: if the site is geo-sensitive, choose mobile proxies from specific regions for consistent results.

Tip: Keep a "project passport": list the site, frequency, limits, rotation strategy, failure points, and proxy support contacts. This speeds up incident responses.

FAQ

Question: How to know if the proxy is genuinely mobile?
Answer: The provider’s dashboard specifies the network type (3G/4G/5G) and operator. Additionally, mobile IPs frequently change during rotation and have characteristic ranges from telecom operators.

Question: Can one mobile proxy be used simultaneously in two tasks?
Answer: Not recommended. One thread per mobile IP is optimal for stability. Scale by adding more proxies.

Question: Which is better: rotation at the provider or in the scraper?
Answer: Provider rotation is more reliable. In the scraper, leave basic pauses and timeouts, and manage IP switching in the proxy panel to avoid conflicts.

Question: How to handle CAPTCHAs?
Answer: Slow down the speed, extend delays, use smoother rotation, and limit parallelism. Operate only within the site's allowable rules and legislation.

Question: What if the site changes its layout?
Answer: Reconfigure selectors: in Octoparse, update "Extract data" on new elements; in ParseHub, create refined selections. Always test on 2–3 pages.

Question: How to securely store proxy passwords?
Answer: Use a password manager and separate accounts for educational and production projects. Avoid saving passwords in open documents.

Question: How to quickly check if the rotation worked?
Answer: Check with the provider’s dashboard or execute a quick request to an IP display service in the browser through the same proxy before launching the task.

Question: How to avoid duplicates during regular runs?
Answer: Preserve a key field (like ProductURL) and compare it against history. In disabled duplicates, use filtering during import into storage.

Question: Can data from Octoparse and ParseHub be combined?
Answer: Yes. Merge exports by the ProductURL key and preferably retain the field with higher fill rates. This helps validate the result.

Question: Where to find all steps for proxy setup in this guide?
Answer: Refer to sections "Step 3" and "Step 4" using the internal links: setting up the proxy in Octoparse and setting up the proxy in ParseHub.

Conclusion

In summary: you have installed and set up Octoparse and ParseHub, connected mobile proxies, created working scraping templates with pagination and validation, configured anti-ban measures, export, and regular runs. The result is a reproducible data collection process without coding, resilient against blocks due to careful pacing and mobile IP usage.

What to do next: scale volume by adding mobile proxies and schedules, enhance quality through data transformations, and integrate exports into BI or CRM. If you're using services like mobileproxy.space, explore additional features in the rotation panel and activity logs.

Areas for growth: learn to analyze complex page structures, use enhanced cleansing and normalization of data, and introduce quality control with fill thresholds. For advanced tasks, consider cascading pipelines: collecting lists, then cards, then media. Remember to always operate within the website’s regulations and legislation.

Tip: Before making significant changes, back up your project and save the current proxy settings separately. This will save time during rollbacks.