Make

Scrape web data inside Make scenarios

Add the Scrappey web data API to any Make (formerly Integromat) scenario with a single HTTP module. POST a URL, get back clean HTML or LLM-ready Markdown, and map the result straight into your downstream modules — no code, no proxy setup.

Start your free trial Make app invite Scrappey docs Get an API key Make HTTP module docs

Quick start

No package to install — Scrappey runs as a standard HTTP request inside Make.

1
Add an HTTP module
In your Make scenario, add the HTTP > Make a request module (or accept the shared Scrappey app invite to use the prebuilt module). Set the method to POST.
text
```
Module: HTTP > Make a request
Method: POST
URL: https://publisher.scrappey.com/api/v1?key=YOUR_API_KEY
```
2
Send the JSON body
Set Body type to Raw, content type application/json, and paste the canonical Scrappey request. Add markdown to get clean Markdown instead of HTML.
json
```
{
  "cmd": "request.get",
  "url": "https://example.com",
  "markdown": true
}
```
3
Map the response downstream
Run the scenario once so Make parses the output, then map the returned solution.markdown (or solution.response for raw HTML) into the next module — a data store, Google Sheets, an AI module, or a webhook.
text
```
{{1.body.solution.markdown}}
```

Example scenarios

Fetch a page as Markdown and store it

POST https://publisher.scrappey.com/api/v1?key=YOUR_API_KEY
Content-Type: application/json

{
  "cmd": "request.get",
  "url": "https://example.com/product/123",
  "markdown": true
}

// Make HTTP module returns JSON. Map these in later modules:
//   {{1.body.solution.markdown}}   -> the page as Markdown
//   {{1.body.solution.statusCode}} -> upstream HTTP status
// Route {{1.body.solution.markdown}} into a Data Store,
// Google Sheets row, or an AI module prompt.

Loop over URLs from a trigger and collect HTML

// Scenario shape:
//   Trigger (Sheets / Webhook) -> Iterator -> HTTP (Scrappey) -> Aggregator
//
// HTTP module body, using the iterated URL:
{
  "cmd": "request.get",
  "url": "{{2.url}}"
}

// Each iteration returns clean HTML at:
//   {{3.body.solution.response}}
// Aggregate those into an array, then write to your destination.
// Failed requests are not billed, so retries stay cheap.

Why run Scrappey in Make

Zero-code setup

Works through Make's standard HTTP module. Paste the URL and JSON body once and the integration is live.

HTML or Markdown output

Return clean HTML for parsing, or add markdown for LLM-ready Markdown you can feed straight into AI modules.

JavaScript-heavy sites handled

Renders modern, JavaScript-heavy and dynamic pages with automatic web access handling, so you get the content a browser would see.

Proxies included

Residential proxies are built into every request — no separate proxy module, credentials, or billing inside your scenario.

Pay only for successes

A free trial to start, then pay-as-you-go. Failed requests are free, so retries in a scenario never cost extra.

Maps cleanly downstream

The JSON response slots into Sheets, data stores, AI modules, and webhooks using Make's standard field mapping.

Popular use cases

AI content pipelines

Fetch pages as Markdown and pipe them into Make's AI modules for summarization, classification, or enrichment.

Scheduled monitoring

Run a scenario on a schedule to track prices, listings, or public content and write changes to a sheet or database.

Lead and data enrichment

Trigger on a new row or form submission, fetch the target page, and append the extracted data back to your records.

Make FAQ

Do I need to install anything in Make?

No. Scrappey works through Make's built-in HTTP > Make a request module. You can also accept the shared Scrappey app invite to use a prebuilt module instead of configuring HTTP manually.

How do I get Markdown instead of HTML?

Add "markdown": true to the JSON body. The page comes back as clean, LLM-ready Markdown in solution.markdown, ideal for feeding into AI modules.

What does it cost to run in Make?

You get a free trial, then it is pay-as-you-go: about €0.10 per 1,000 direct HTTP requests or €1.00 per 1,000 full-browser requests, with residential proxies included. There is no subscription.

Do failed requests use up my credit?

No. You only pay for successful requests, so retries and error handling inside a scenario do not add cost.

How do I map the result into later modules?

After running the scenario once, Make parses the JSON. Reference the page content with {{body.solution.response}} from the HTTP module and map it into any downstream module.

Can I scrape JavaScript-heavy pages?

Yes. The default request.get command renders modern, JavaScript-heavy sites with automatic web access handling, returning the fully loaded content.

More ways to plug Scrappey into your stack

MCP server Claude & Codex LangChain LlamaIndex n8n Markdown for RAG All integrations

Start building with Scrappey

Try it free. No subscription, no credit card, instant setup — your trial is waiting.

Join the Discord community