Extract

Extract turns a web page into structured JSON in a single request. Add extract=auto to your Fetch call, and Zenrows identifies the meaningful data on the page and returns it as clean JSON, together with the raw HTML. There are no selectors to write, no schema to define, and no parser to maintain. The extraction adapts automatically when a website changes its layout.

Extract is in Beta and works on domains Zenrows has prepared. Any active Zenrows API key can use it on those, with no extra setup needed, and you can ask for a new domain to be prepared yourself.

How Extract works

Unlike general-purpose parsing rules that apply the same logic to every website, Extract builds and maintains an extraction that’s tailored to each individual site. Zenrows analyzes a domain’s pages, identifies its meaningful data points, and keeps that extraction working as the site evolves, so you get richer and more complete fields than a one-size-fits-all approach can offer. That tailoring is per domain, so a domain has to be prepared before Extract can serve it. Any domain can be: see Domain coverage.

Basic usage

Enable Extract by adding the extract=auto parameter to your Zenrows request:

# pip install requests
import requests

url = 'https://www.scrapingcourse.com/ecommerce/'
apikey = 'YOUR_ZENROWS_API_KEY'
params = {
    'url': url,
    'apikey': apikey,
    'extract': 'auto',
}
response = requests.get('https://api.zenrows.com/v1/', params=params)
print(response.json())

// npm install axios
const axios = require('axios');

const url = 'https://www.scrapingcourse.com/ecommerce/';
const apikey = 'YOUR_ZENROWS_API_KEY';
axios({
    url: 'https://api.zenrows.com/v1/',
    method: 'GET',
    params: {
        'url': url,
        'apikey': apikey,
        'extract': 'auto',
    },
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

import org.apache.hc.client5.http.fluent.Request;

public class APIRequest {
    public static void main(final String... args) throws Exception {
        String apiUrl = "https://api.zenrows.com/v1/?apikey=YOUR_ZENROWS_API_KEY&url=https%3A%2F%2Fwww.scrapingcourse.com%2Fecommerce%2F&extract=auto";
        String response = Request.get(apiUrl)
                .execute().returnContent().asString();

        System.out.println(response);
    }
}

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.zenrows.com/v1/?apikey=YOUR_ZENROWS_API_KEY&url=https%3A%2F%2Fwww.scrapingcourse.com%2Fecommerce%2F&extract=auto');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

package main

import (
    "io"
    "log"
    "net/http"
)

func main() {
    client := &http.Client{}
    req, err := http.NewRequest("GET", "https://api.zenrows.com/v1/?apikey=YOUR_ZENROWS_API_KEY&url=https%3A%2F%2Fwww.scrapingcourse.com%2Fecommerce%2F&extract=auto", nil)
    if err != nil {
        log.Fatalln(err)
    }
    resp, err := client.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

# gem install faraday
require 'faraday'

url = URI.parse('https://api.zenrows.com/v1/?apikey=YOUR_ZENROWS_API_KEY&url=https%3A%2F%2Fwww.scrapingcourse.com%2Fecommerce%2F&extract=auto')
conn = Faraday.new()
conn.options.timeout = 180
res = conn.get(url, nil, nil)
print(res.body)

curl "https://api.zenrows.com/v1/?apikey=YOUR_ZENROWS_API_KEY&url=https%3A%2F%2Fwww.scrapingcourse.com%2Fecommerce%2F&extract=auto"

This example extracts structured data from the Scraping Course eCommerce page. Instead of raw HTML alone, you get a JSON response with the meaningful data Zenrows identified on the page, plus the original HTML for reference.

Response

A request with extract=auto returns Content-Type: application/json with two fields:

JSON

{
  "html": "<!DOCTYPE html><html>...</html>",
  "parsed": {
    "products": [
      {
        "name": "Abominable Hoodie",
        "price": "69.00",
        "currency": "USD",
        "image_url": "https://www.scrapingcourse.com/.../mh09-blue_main.jpg",
        "product_url": "https://www.scrapingcourse.com/ecommerce/product/abominable-hoodie/"
      }
    ]
  }
}

parsed contains the structured data extracted from the page.
html contains the raw HTML of the scraped page. It’s included during the beta so you can validate the extracted data against the source.

Field names are in plain English and reflect the data each website actually exposes, so different websites can return different fields for similar pages. The set of fields inside parsed stays stable across requests for a given website, and new fields may be added over time as extraction improves, so treat unknown fields as additive rather than breaking. The html field is included for validation during the beta, and the overall response shape may evolve once the beta ends, so build your data pipeline around parsed and treat html as a validation aid rather than a permanent contract.

Extraction is fully automatic, and a field is only returned when it’s present on the page. Always run test requests on your target pages and verify all the data you need is extracted before using Extract in production.

Domain coverage

Extract works on any domain, once that domain has been prepared: Zenrows learns the shapes of its pages and checks that extraction returns the right data. A prepared domain then works for every Zenrows API key, so coverage is per domain and never per account, and there is no allowlist to manage on your side. Many domains are prepared already, and the set grows as people ask for the sites they need.

Checking whether a domain is ready

GET /v1/extract/domains returns everything Extract serves right now:

cURL

curl "https://api.zenrows.com/v1/extract/domains?apikey=YOUR_ZENROWS_API_KEY"

Response

{
  "domains": [
    {
      "domain": "zillow.com",
      "verticals": ["Real Estate/Houses", "Real Estate/Real Estate Buying and Selling"],
      "warm": true
    },
    {
      "domain": "amazon.com",
      "verticals": ["Shopping", "Technology & Computing/Consumer Electronics"],
      "warm": true
    }
  ]
}

An integration can check this before sending a request instead of handling an error after one. See the endpoint reference for the full response.

Asking for a domain

If the domain you need isn’t there, ask for it:

cURL

curl -X POST "https://api.zenrows.com/v1/extract/prepared-domains?apikey=YOUR_ZENROWS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "domain": "example-shop.com",
    "example_urls": ["https://example-shop.com/product/blue-shirt"]
  }'

Preparation usually takes minutes. Poll GET /v1/extract/prepared-domains/{domain} until status is ready, then send your extract=auto request as normal. Example URLs are worth including: they tell Zenrows exactly which kinds of page you care about. Each account can prepare a set number of new domains per month; the endpoint reference covers how to check what’s left. If you send extract=auto for a domain that isn’t prepared, the request fails with a 403 error (REQS007) naming the domain, and the message tells you how to get it prepared. Nothing about your plan or your account changes that: preparation is per domain.

Combining with other features

Extract works on the final HTML of the page, so it combines with the scraping features you already use. For JavaScript-heavy websites, add JavaScript Rendering with a short wait so dynamic content finishes loading before extraction. For protected websites, add Premium Proxy:

# pip install requests
import requests

url = 'https://www.scrapingcourse.com/ecommerce/'
apikey = 'YOUR_ZENROWS_API_KEY'
params = {
    'url': url,
    'apikey': apikey,
    'extract': 'auto',
    'js_render': 'true',
    'wait': '3000',
    'premium_proxy': 'true',
}
response = requests.get('https://api.zenrows.com/v1/', params=params)
print(response.json())

curl "https://api.zenrows.com/v1/?apikey=YOUR_ZENROWS_API_KEY&url=https%3A%2F%2Fwww.scrapingcourse.com%2Fecommerce%2F&extract=auto&js_render=true&wait=3000&premium_proxy=true"

When extract=auto is set, it takes precedence over other output formats. autoparse, css_extractor, response_type, and outputs are ignored on that request.

Extract vs. Autoparse vs. CSS Extractor

Method	Best for	Pros	Cons
Extract (`extract=auto`)	Any site where you want the richest data	Tailored to each website, adapts when the site’s layout changes, richer fields	The domain has to be prepared first
Autoparse (`autoparse=true`)	Quick, general-purpose extraction on any website	Works on any site, no setup, included at no extra cost	General-purpose rules, may miss specific fields
CSS Extractor (`css_extractor`)	Specific data points, single site, custom requirements	Full control, precise targeting	Requires HTML knowledge, selectors are site-specific

Pricing

Extract is free during Beta. You only pay the standard Fetch cost of the underlying request, including JavaScript Rendering or Premium Proxy if you use them.

You can monitor your Zenrows usage in multiple ways to stay informed about your account activity and prevent unexpected overages.Dashboard monitoring: View real-time usage statistics, remaining requests, success rates, and request history on your Analytics Page. You can also set up usage alerts in your notification settings to receive notifications when you approach your limits.Programmatic monitoring: For automated monitoring in your applications, call the /v1/subscriptions/self/details endpoint with your API key in the X-API-Key header. This returns real-time usage data that you can integrate into your monitoring systems. Learn more about the usage endpoint.Response header monitoring: Track your concurrency usage through response headers included with each request:

Concurrency-Limit: Your maximum concurrent requests
Concurrency-Remaining: Available concurrent request slots
X-Request-Cost: Cost of the current request

Frequently Asked Questions (FAQ)

How is Extract different from Autoparse?

Autoparse (autoparse=true) applies general-purpose extraction rules that work the same way on every website. Extract (extract=auto) builds an extraction tailored to each website, which returns richer, more complete fields and adjusts itself when the website’s layout changes. Extract needs a domain to be prepared first, which you can request; Autoparse works on any website with no preparation.

What happens on a domain that isn't prepared yet?

The request fails with a 403 error (REQS007) naming the domain, and the message tells you how to get it prepared: POST /v1/extract/prepared-domains, then retry once it reports ready. Nothing about your plan or your account changes the outcome, since preparation is per domain.

Will the extracted fields change over time?

The response shape for an enabled website stays stable. Your integration keeps receiving the same fields even as Zenrows improves extraction behind the scenes. New fields may be added over time, so treat unknown fields as additive rather than breaking.

Can I rely on the html field long term?

Treat html as a validation aid rather than a permanent part of the contract. It’s included during the beta so you can check the extracted data against the source page. Build your data pipeline around parsed, since the surrounding response shape may evolve once the beta ends.

Can I combine Extract with other Zenrows features?

Yes. Extract works alongside JavaScript Rendering, Premium Proxy, and other request options. It takes precedence over other output formats, so autoparse, css_extractor, response_type, and outputs are ignored on a request that sets extract=auto.

Get Started

Fetch

Batch

Browser Sessions

Residential Proxies (Legacy)

Guides

Extract

How Extract works

Basic usage

Response

Domain coverage

Checking whether a domain is ready

Asking for a domain

Combining with other features

Extract vs. Autoparse vs. CSS Extractor

Pricing

Frequently Asked Questions (FAQ)

​How Extract works

​Basic usage

​Response

​Domain coverage

​Checking whether a domain is ready

​Asking for a domain

​Combining with other features

​Extract vs. Autoparse vs. CSS Extractor

​Pricing

​Frequently Asked Questions (FAQ)

How Extract works

Basic usage

Response

Domain coverage

Checking whether a domain is ready

Asking for a domain

Combining with other features

Extract vs. Autoparse vs. CSS Extractor

Pricing

Frequently Asked Questions (FAQ)