Build the smallest useful scraper in Make with two modules: an HTTP Make a request module to fetch an allowed HTTPS page, followed by the Text parser module to extract fields from the returned HTML. This works when the data is already present in the HTTP response. If a site fills its content only after browser JavaScript runs, use its official API or a browser-based scraping service instead of assuming the same scenario will work.
What this Make scraper can and cannot do
Make’s HTTP app can request webpages and APIs. Its documentation explicitly lists unauthenticated requests as appropriate when the target needs no credentials, including web scraping. Requests must use HTTPS, and Make rejects connections that rely on unverified, self-signed certificates.
The workflow below is intentionally simple:
- Choose a page or API you are permitted to access and list the fields you need.
- Fetch the target with HTTP > Make a request.
- Inspect the response to confirm the required content is actually present.
- Use Text parser to retrieve values from the HTML.
- Map those values into the next module in your scenario.
It is not a universal crawler. A page can return a shell of HTML and create the visible content later with JavaScript. In that case, the HTTP response will not contain the records you see in a normal browser.
Before you create the scenario
Pick an allowed target and define fields
Use a public page or API that you are allowed to access. Write down exact fields such as title, price, publication date, product URL, or an API’s JSON keys. Check the target’s terms, robots guidance where relevant, and any contractual restrictions. Make’s August 2023 Master Service Agreement puts responsibility for compliance with applicable laws and legally necessary privacy consents on the customer; that agreement does not decide whether a particular scrape is lawful in your jurisdiction.
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 →Scan for outdated or missing drivers - takes under a minuteDriver Scan →#1 Best Overall
Decide whether you need an API
If the publisher offers an official API, prefer it. APIs generally provide stable fields, authentication instructions, and documented pagination. A webpage scrape is more fragile because a redesign can change the markup without warning.
Confirm the response type
- HTML page: the Text parser can work when the desired values are in the response body.
- JSON API: map the returned JSON fields directly and follow that API’s authentication and pagination rules.
- Browser-rendered page: the initial response may omit the data; plan for an official API or a managed browser integration.
Build the basic two-module scenario
1. Add HTTP > Make a request
- Create a new Make scenario and add HTTP > Make a request.
- Enter the target’s complete
https://URL. Do not use an unverified or self-signed HTTPS certificate. - Select the method required by the target. Use
GETfor a normal page or a read-only API endpoint; use another method only when the API documentation requires it. - Choose the authentication mode required by the target. Select No authentication only when no credentials are required.
- Add query-string parameters, headers, cookies, or a user agent only when the target documentation calls for them.
- Configure pagination only for an endpoint that documents pagination. Make’s HTTP app supports request pagination, and its current documentation describes native pagination in HTTP Version 4; follow the endpoint’s cursor, page, limit, and stopping rules rather than guessing.
- Run the module once. Expand the output and inspect the status, headers, content type, and body.
Do not start by writing selectors. First verify that the response contains the text or markup you want. Search the captured body for a known title or value and compare it with the live page.
2. Extract values with Text parser
- Add Make’s Text parser module after the HTTP module.
- Map the HTTP response body into the parser’s source text.
- Configure an extraction pattern for each field you need. The parser documentation establishes the extraction capability, but it does not prescribe selectors for a particular website, so inspect the target’s actual HTML and choose patterns that match its structure.
- Run the parser and check every output. Test a missing field as well as a normal result; a changed class name or absent element should not silently create bad records.
For an API response, skip HTML parsing and map the returned JSON properties. If the API returns an array, add the appropriate iterator or array-processing module before your destination.
3. Send the records somewhere useful
Add the destination that fits your workflow—for example, a spreadsheet, database, notification, or another API—and map the extracted fields. This is an example design choice, not a guaranteed configuration for every destination. Preserve the source URL and capture time so you can audit where each record came from.
HTML extraction that survives small changes
Prefer a distinctive element or attribute that represents the field, rather than depending on a long chain of layout-specific classes. Keep separate extraction rules for separate fields, and validate the result against a known page. If a field is optional, define what an empty result means before writing it downstream.
Store the raw response or a diagnostic sample during development, but avoid retaining personal data you do not need. Add a route or error handler for non-success HTTP statuses, empty bodies, and parser results that contain no records. A successful HTTP status only means the server returned a response; it does not prove that the expected content was present.
When the HTTP module returns no visible data
JavaScript-rendered content
Many sites send an initial document and then fetch products, listings, or article text in the browser. If your Make output lacks content that is visible in Chrome, inspect the page’s network behavior and look for an official data endpoint first. If there is no suitable API, Make’s ScrapeNinja integration documentation describes processing JavaScript and CSS with a real Chrome browser. Make also lists a ScrapingBee integration with headless-browser, proxy, and structured-output capabilities. These are optional managed services, not requirements for a static page.
Which approach fits?
| Situation | Best first choice | Reason |
|---|---|---|
| Data is in the HTTP body | Make HTTP + Text parser | Fewest moving parts and direct mapping in one scenario. |
| Structured data is available from an official API | Make HTTP API request | Use documented fields, authentication, and pagination. |
| Content appears only after browser JavaScript | Official API, then a managed browser integration | The initial HTTP response does not contain the required records. |
| Need browser behavior such as waiting for rendered elements | ScrapeNinja or ScrapingBee integration | The listed integrations provide browser-oriented processing features; current terms and limits must be checked before deployment. |
Pagination, authentication, and request controls
Pagination
Read the target API’s documentation to determine whether it uses page numbers, offsets, cursors, or a next-link. Configure Make’s HTTP pagination settings to stop on the documented condition. Make’s documentation mentions a configurable limit up to 10,000 items and a 3,200-item limit in certain pagination contexts; treat these as product configuration details and verify the current behavior in the live documentation before relying on an exact ceiling.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Authentication and headers
Use the target’s required method—basic authentication, a bearer token, an API key, or another documented scheme. Keep secrets in Make’s connection or secured field rather than embedding them in a URL or logging them. Add an Accept header when an API documents a preferred response format. Do not copy browser cookies or authorization headers unless you have permission and a clear operational need.
Rate and failure handling
Respect the target’s published rate limits. Add error handling for timeouts, HTTP 4xx/5xx responses, empty bodies, and parser output with zero matches. Use retries only for transient failures and avoid retrying authentication errors or a blocked request indefinitely. For scheduled scenarios, record the last successful page or cursor so a rerun does not duplicate data.
Troubleshooting common failures
| Symptom | Likely cause | Fix |
|---|---|---|
| Connection rejected before a response | Non-HTTPS URL or unverified/self-signed certificate | Use the target’s valid HTTPS endpoint and certificate. |
| 401 or 403 response | Missing, expired, or incorrect credentials; access is not permitted | Follow the target’s authentication instructions and confirm you are authorized. |
| 200 response but no records | Content is loaded by JavaScript or the selector no longer matches | Search the raw body; use an API or browser-based integration when the data is not present. |
| Parser returns empty or wrong values | HTML structure changed, pattern is too broad, or optional field is absent | Inspect a fresh response, narrow the pattern, and add validation for missing fields. |
| Only the first page is collected | Pagination was not configured or the stop rule is wrong | Read the API’s pagination documentation and configure its cursor/page semantics. |
| Scenario becomes slow or times out | Too many requests, large responses, or a browser-rendered target | Reduce the batch, honor rate limits, request only needed fields, and use a suitable browser service when rendering is required. |
Performance, reliability, and maintenance
- Request the smallest useful representation. An API endpoint with selected fields is usually easier to parse than a full page.
- Separate fetching, parsing, and storage so you can replace one stage without rebuilding the scenario.
- Keep a fixture response for parser changes, then compare it with a current response before publishing updates.
- Monitor zero-result runs, status-code changes, and sudden field shifts; these often indicate a redesign or access change.
- Make no guarantee that a target remains stable. Your reliability depends on the target’s availability, markup, rate limits, and access policy as well as on Make.
Or skip the browser setup
If the page requires browser rendering or you simply want a screenshot rather than parsed fields, ScreenshotNeo provides a website screenshot API and MCP server. It accepts a URL and returns PNG, JPEG, WebP, or PDF. Before capture it accepts cookie/consent banners and removes more than 60 known consent platforms, newsletter popups, and chat widgets; each cleanup step can be turned off. Bot checks/CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are not billed, and the response identifies the result with X-Page-Verdict and X-Billed headers.
One request is enough:
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp
Python:
import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)
open("shot.webp", "wb").write(r.content)
Node.js:
const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);
See the complete options and response details in the ScreenshotNeo documentation. Its MCP server exposes take_screenshot, get_page_info, and capture_pdf to Claude, Cursor, and other MCP clients. Plans include 1,000 screenshots per month free with no card; paid plans start at $5 for 3,000 screenshots. Create a free ScreenshotNeo account.
FAQ
Can Make scrape any public website?
No. It can fetch only what the target returns and permits you to access. JavaScript-only content, authentication barriers, rate limits, and legal or contractual restrictions can require a different approach.
PC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchShould I parse HTML or use an API response?
Use the official API when one exposes the fields you need. Parse HTML when the values are present in the page response and no better supported interface exists.
Best Value
How do I know whether JavaScript is the problem?
Run the HTTP module and search its raw body for a value visible in the browser. If it is absent while the browser displays it, the page likely obtains it after the initial response.
Frequently Asked Questions
Can I schedule this scraper in Make?
Yes. Add a schedule to the scenario, but monitor empty results, status changes, and target rate limits so a scheduled run does not create duplicates or excessive requests.
Is Text parser required for JSON APIs?
No. Map documented JSON fields directly; use Text parser for values embedded in HTML text.
What should I do when a target changes its markup?
Capture a fresh response, update the extraction patterns, test missing-field behavior, and keep a small fixture response for future parser checks.
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.
