Skip to main content

Make.com + Bright Data: Scale Web Data Collection with Visual Automation

· 10 min read
Yassine El Haddad
Yassine El Haddad
Software Developer & Automation Specialist

I build production AI agents, web scrapers, and automation pipelines. Most of what I publish here comes from the actual problems they run into: proxies that get banned, anti-bot stacks that fingerprint your client, RAG that drifts when the underlying data moves. Stack: Python, TypeScript, Go, FastAPI, LangChain, Crawlee, Playwright, deployed on AWS, GCP, and Cloudflare.

Connecting Bright Data's proxy network and extraction APIs to Make.com scenarios gives enterprise teams a visual, no-code automation layer over one of the most capable web data infrastructures available. The combination covers the three core obstacles in large-scale data collection: bypassing modern WAFs without custom code, routing scraped records directly into downstream SaaS tools, and scheduling recurring collection jobs without infrastructure management.

This guide walks through the exact configuration steps — calling the Bright Data Web Unlocker via Make's HTTP module, pulling dataset snapshots into a scenario, and wiring up error handling and retry logic for production-grade pipelines.

Why Make.com + Bright Data for enterprise data collection​

Most no-code automation platforms integrate well with structured APIs but collapse when the data source is a hostile website. Bright Data resolves the hostile-website problem; Make resolves the orchestration problem. Together they close the gap between raw web data and your operational stack.

StackScrapingOrchestrationBest for
Make + Bright DataManaged WAF bypass, residential proxiesVisual scenario builder, 2,000+ app integrationsEnterprise teams, non-developers
n8n + ApifyServerless actor executionSelf-hosted workflow engineDevelopers needing custom extraction code
Python + Scrapy + ProxiesFull custom controlCron / Airflow / customEngineering teams managing infra
Make + raw proxiesManual proxy config, no CAPTCHA solvingVisual scenario builderLight-traffic scraping, not hostile sites

Bright Data is the better proxy choice here when targets include Cloudflare-protected domains, geo-restricted content, or large-platform anti-bot measures. For publicly accessible APIs or simple RSS feeds, raw proxies or direct HTTP calls are sufficient and cheaper.

Architecture overview​

A production Make + Bright Data pipeline has three layers:

  1. Trigger — a schedule module (cron), a webhook from an upstream system, or a manual run.
  2. Extraction — Make's HTTP module calls the Bright Data Web Unlocker or a Bright Data Scraping Browser endpoint; the response carries the raw HTML or structured JSON.
  3. Processing and routing — JSON parser, iterator, filter, and destination modules push records to Google Sheets, a database, a CRM, Slack, or any of Make's 2,000+ app connectors.

The Bright Data API key lives in Make's built-in Connection vault and is never exposed in the visual scenario editor, satisfying most enterprise secret-management policies.

Step 1: Obtain your Bright Data API credentials​

  1. Log into the Bright Data Control Panel.
  2. Navigate to Proxies & Scraping Infrastructure → Add Zone.
  3. For anti-bot–protected targets, choose Web Unlocker. For general rotating residential proxies, choose Residential.
  4. Copy the generated credentials — you will need:
    • Customer ID: brd-customer-XXXXXXXX
    • Zone name: e.g., web_unlocker1
    • Zone password: ZONE_PASSWORD
    • API token (for dataset endpoints): from Account Settings → API Token

For the Web Unlocker, the proxy gateway is:

Host: brd.superproxy.io
Port: 22225
Auth: brd-customer-<CUSTOMER_ID>-zone-<ZONE_NAME>:<ZONE_PASSWORD>

Step 2: Call the Web Unlocker API from a Make HTTP module​

The Web Unlocker exposes a standard proxy endpoint. Make's HTTP → Make a Request module supports proxy authentication through custom headers or a direct proxy URL, depending on your scenario design.

Option A — Direct proxy routing (recommended for HTML scraping)​

  1. In your scenario, add HTTP → Make a Request.
  2. Set URL to your target page, e.g., https://www.amazon.com/s?k=laptop.
  3. Expand Advanced settings and configure:
    • Use proxy: true
    • Proxy host: brd.superproxy.io
    • Proxy port: 22225
    • Proxy username: brd-customer-XXXXXXXX-zone-web_unlocker1
    • Proxy password: ZONE_PASSWORD
  4. Set Parse response to Yes if the target returns JSON; leave as No for HTML.

The Web Unlocker handles TLS fingerprint spoofing, CAPTCHA resolution, and IP rotation transparently. Make receives a clean 200 response with the final page HTML.

Option B — Bright Data REST API endpoint (recommended for structured extraction)​

Bright Data also exposes a REST endpoint that accepts a target URL and returns the resolved content:

POST https://api.brightdata.com/request
Authorization: Bearer <BRIGHT_DATA_API_TOKEN>
Content-Type: application/json

{
  "zone": "web_unlocker1",
  "url": "https://target-domain.com/page",
  "format": "raw"
}

In Make:

  1. Add HTTP → Make a Request.
  2. Method: POST
  3. URL: https://api.brightdata.com/request
  4. Headers: add Authorization: Bearer {{YOUR_API_TOKEN}} and Content-Type: application/json
  5. Body type: Raw / JSON
  6. Request content:
{
  "zone": "web_unlocker1",
  "url": "{{1.url}}",
  "format": "raw"
}

Replace {{1.url}} with whatever dynamic URL you're feeding into the scenario (from a Google Sheets row, a webhook payload, or a hardcoded value).

Step 3: Download Bright Data datasets in Make scenarios​

Bright Data's Web Scraper API and Dataset Marketplace expose REST endpoints for downloading structured datasets. This is useful when you need pre-collected or scheduled data rather than real-time scraping.

Trigger a dataset snapshot​

POST https://api.brightdata.com/datasets/v3/trigger
Authorization: Bearer <BRIGHT_DATA_API_TOKEN>
Content-Type: application/json

{
  "dataset_id": "<DATASET_ID>",
  "notify": "https://hook.make.com/<YOUR_MAKE_WEBHOOK>"
}

Configure this in Make as follows:

  1. Add a Webhooks → Custom webhook trigger module at the start of a secondary scenario.
  2. Use the generated Make webhook URL as the notify value in the Bright Data trigger call.
  3. When Bright Data finishes collecting the snapshot, it fires a POST to your Make webhook with a snapshot_id.
  4. The Make scenario wakes up and proceeds to download the data.

Download the snapshot​

Add a second HTTP → Make a Request module after the webhook trigger:

  • Method: GET
  • URL: https://api.brightdata.com/datasets/v3/snapshot/{{1.snapshot_id}}?format=json
  • Headers: Authorization: Bearer {{YOUR_API_TOKEN}}

The response is a JSON array of structured records. Pass this to a JSON → Parse JSON module, then an Array Iterator module to push each record individually to your destination (Airtable, HubSpot, BigQuery, etc.).

Step 4: Build a proxy-powered scraping pipeline​

This end-to-end pattern covers a recurring competitor price monitor: scrape a list of product URLs through Bright Data's residential proxies, extract pricing data, and write updated records to Google Sheets.

Scenario structure​

[Schedule: Every 6 hours]
    ↓
[Google Sheets: Get rows from "URLs to monitor" sheet]
    ↓
[Iterator: Loop over each URL]
    ↓
[HTTP: Make a Request via Bright Data Web Unlocker]
    ↓
[Text Parser: Parse HTML or JSON response]
    ↓
[Google Sheets: Update row with extracted price + timestamp]
    ↓
[Slack: Notify if price drops >5%]

Key module settings for the HTTP step:

FieldValue
URL{{iterator.url}} (dynamic from sheet row)
MethodGET
Proxy hostbrd.superproxy.io
Proxy port22225
Proxy usernamebrd-customer-XXXXXXXX-zone-residential1
Proxy passwordZONE_PASSWORD
Timeout45 seconds (allow for CAPTCHA resolution)
Parse responseYes (if target returns JSON)

For HTML parsing, add a Text Parser → Match pattern module after the HTTP module and write a regex to extract the price element. For more complex DOM extraction, feed the HTML into an OpenAI module and use a structured extraction prompt — Make's native OpenAI integration makes this straightforward.

Scheduling and error handling​

Scheduling​

Make's Schedule trigger supports:

  • Interval: every N minutes, hours, or days
  • Daily at: specific UTC time
  • Weekly / Monthly: day-specific triggers

For data collection pipelines with large URL lists, pair a schedule trigger with a Google Sheets or Airtable module that reads only rows where last_scraped is older than your refresh interval. This prevents re-processing already-fresh records on every run.

Error handling with Make's error handler modules​

Make provides three error-handling patterns relevant to Bright Data integrations:

1. Retry on transient errors

Attach an Error Handler → Resume module to the HTTP step. Set a conditional: if the HTTP status is 429 (rate limited) or 503 (Bright Data overloaded), wait 30 seconds and retry up to 3 times. This pattern covers most transient proxy failures.

2. Route failed URLs to a retry queue

Attach an Error Handler → Ignore module. Route the failed item to a Google Sheets: Add Row module that appends it to a "failed URLs" sheet. A separate daily scenario re-processes that sheet, giving each URL a second chance outside peak traffic hours.

3. Alert on unexpected failures

Add a Slack: Send Message step after any permanent error route. Include the target URL, HTTP status code, and a direct link to the Make scenario execution log. Enterprise teams monitoring data freshness SLAs need these alerts immediately.

Handling the Web Unlocker's latency​

The Web Unlocker adds 3–8 seconds per request for CAPTCHA resolution and fingerprint generation. For scenarios iterating over 1,000+ URLs, set Make's sequential processing mode (disable parallel iteration) to avoid overwhelming Bright Data's rate limits. Alternatively, spread the work across multiple scheduled runs with a smaller batch size per execution.

Pricing and scalability​

ComponentCost basisTypical enterprise spend
Make Core / Pro / TeamsPer operation (module execution)$9–$29/month for 10k–150k ops
Make EnterpriseCustom, includes priority supportNegotiated
Bright Data Residential Proxies~$8.40 / GBVaries by volume
Bright Data Web UnlockerPay-per-success (billed per 1,000 requests)See Bright Data pricing
Bright Data Dataset MarketplacePer dataset / snapshotFixed per dataset

Practical note: Make charges one operation per module execution per scenario run. A scenario with 6 modules iterating over 500 URLs costs 3,000 operations per execution (6 × 500). On the Pro plan (150,000 ops/month), that supports 50 such executions — each processing 500 URLs — before hitting the monthly limit. For pipelines that run more frequently or with larger URL lists, the Teams plan or Enterprise tier is required. See Make pricing for current rates.

For Bright Data, the Web Unlocker is substantially more expensive than raw residential proxies but eliminates the engineering cost of maintaining anti-bot evasion code. The trade-off is correct for most enterprise automation buyers who reach for Make in the first place.

FAQ​

Can Make.com use proxies?​

Yes. Make's HTTP → Make a Request module accepts proxy configuration under Advanced settings. You can specify a proxy host, port, username, and password directly in the module. This works with any proxy provider that supports HTTP/HTTPS proxy authentication, including Bright Data's residential, datacenter, and ISP proxy zones.

How do I connect Bright Data to Make?​

The simplest path: add Bright Data proxy credentials to the HTTP → Make a Request module's proxy settings in your Make scenario. For API-based access (Web Unlocker REST endpoint, dataset downloads), add your Bright Data API token as an Authorization: Bearer header in the HTTP module. No native Make app connector is required — the HTTP module handles all communication.

What is enterprise web scraping automation?​

Enterprise web scraping automation combines a managed proxy infrastructure (like Bright Data) with an orchestration layer (like Make.com) to collect structured web data at scale, route it into business applications, and maintain it on a schedule — without requiring a dedicated engineering team to manage servers, proxies, or anti-bot evasion code. The result is a data pipeline that a business analyst can monitor and modify through a visual interface while the underlying infrastructure handles the technical complexity.

Start building your pipeline​

Register for Make and activate a Bright Data account to start with both free tiers. Make's free plan includes 1,000 operations/month — enough to validate the Web Unlocker integration and test the dataset download flow before committing to a paid tier.

For proxy setup details, see the Bright Data proxy configuration guide. For a deeper look at the Web Unlocker's anti-bot capabilities, read the Bright Data Web Unlocker review. If you need a fully serverless extraction stack with custom code instead of visual modules, the Apify + n8n guide covers that architecture.