Autoparse

Extract structured data from any website automatically with Zenrows’ Autoparse feature. Instead of parsing HTML manually, Autoparse uses advanced algorithms to identify and extract key data points in clean JSON format.

Looking for richer, site-tailored extraction? Extract (extract=auto) is in Beta. It builds a dedicated extraction for each individual website instead of applying the same general-purpose rules everywhere, and it currently works on a curated set of enabled domains. Autoparse remains the right choice for any website, with no setup and no waitlist.

How Autoparse works

Autoparse analyzes the HTML structure and content of web pages to identify meaningful data patterns. The algorithms recognize common website elements such as titles, prices, descriptions, images, dates, and other structured information using semantic markup, CSS classes, and content positioning. This process extracts content such as:

Product details (title, price, description, images, ratings)
Article content (headline, author, publication date, body text)
Job listings (title, company, location, salary, requirements)
Contact information (names, addresses, phone numbers, emails)
Event details (title, date, location, description)

The feature automatically adapts to different website structures and layouts, making it particularly useful for scraping multiple sites with varying designs or for quickly prototyping data extraction workflows.

Remember that Autoparse is an automatic feature designed for general-purpose extraction. It may not capture all fields on every website. Always test requests to verify that all required data is present before implementing in production.

Basic usage

Enable Autoparse by adding the autoparse=true 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,
    'autoparse': 'true',
}
response = requests.get('https://api.zenrows.com/v1/', params=params)
print(response.text)

// 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,
        'autoparse': 'true',
    },
})
    .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&autoparse=true";
        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&autoparse=true');
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&autoparse=true", 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&autoparse=true')
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&autoparse=true"

This example extracts structured data from the Scraping Course eCommerce page. Instead of receiving raw HTML, you get organized JSON data containing key information automatically identified by Autoparse.

When to use Autoparse

Content extraction needs:

E-commerce scraping - Product catalogs, pricing data, reviews, and specifications
News and media - Article content, headlines, author information, and publication dates
Job board aggregation - Job listings, company details, requirements, and salary information
Real estate data - Property listings, prices, descriptions, and location details
Event information - Event details, dates, venues, and other event information

Development scenarios:

Rapid prototyping - Quick data extraction without writing custom parsers
Multi-site scraping - Extracting similar data from different website layouts
Unknown site structures - When you need to explore what data is available
Proof of concept projects - Testing data availability before building custom solutions

For dynamic content that loads via JavaScript, combine Autoparse with JavaScript Rendering:

# pip install requests
import requests

url = 'https://www.scrapingcourse.com/ecommerce/'
apikey = 'YOUR_ZENROWS_API_KEY'
params = {
    'url': url,
    'apikey': apikey,
    'autoparse': 'true',
    'js_render': 'true',
}
response = requests.get('https://api.zenrows.com/v1/', params=params)
print(response.text)

// 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,
        'autoparse': 'true',
        'js_render': 'true',
    },
})
    .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&autoparse=true&js_render=true";
        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&autoparse=true&js_render=true');
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&autoparse=true&js_render=true", 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&autoparse=true&js_render=true')
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&autoparse=true&js_render=true"

This combination ensures that dynamically loaded content is available for parsing while still providing structured JSON output. For more information about JavaScript Rendering, see the JavaScript Rendering documentation.

Comparing extraction methods

Method	Best for	Pros	Cons
Autoparse	Quick extraction, multiple sites, prototyping	No coding required, works across sites, JSON output	Less control, may miss specific fields
Extract (Beta)	Enabled domains where you want the richest data	Tailored to each website, adapts when the site’s layout changes, richer fields	Only available on domains enabled for Beta
CSS Extractor	Specific data, single site, custom requirements	Full control, precise targeting, efficient	Requires HTML knowledge, site-specific
Custom Parsing	Complex logic, data transformation	Maximum flexibility, custom processing	Time-intensive, maintenance overhead

Troubleshooting

Common issues and solutions

Issue	Cause	Solution
Missing expected data	Content not in standard format	Contact support for analysis or switch to custom parsing
Empty or incomplete extraction	JavaScript-loaded content	Add `js_render=true` and `wait` parameters
Page blocked or captcha	Site protection systems	Combine `js_render=true` + `premium_proxy=true`
Unexpected data structure	Site uses non-standard markup	Test with manual CSS Extractor instead of Autoparse

Improving extraction accuracy

When Autoparse doesn’t capture all the data you need:

Test if the content loads dynamically

Python

# For empty or missing content, enable JavaScript rendering
params = {
    'autoparse': 'true',
    'js_render': 'true',
    'wait': '3000',  # Wait for content to load
}

Bypass protection if the site is blocked

Python

# For blocked pages or captchas
params = {
    'autoparse': 'true',
    'js_render': 'true',
    'premium_proxy': 'true',
}

Wait for specific elements to appear

Python

# Wait for specific elements to appear
params = {
    'autoparse': 'true',
    'js_render': 'true',
    'wait_for': '.product-price',
}

Contact support or switch to manual parsing

If Autoparse consistently misses the specific fields you need, contact Zenrows support for analysis, or consider switching to the manual CSS Extractor for precise control. If your target domain is enabled for Extract, Extract may also capture more complete fields.

Remember that Autoparse is an automatic feature designed for general-purpose extraction. It may not capture all fields on every website. Always run test requests to verify that all required data is present before implementing in production.

Pricing

The autoparse=true parameter is included at no additional cost with all Zenrows requests. You only pay extra for JavaScript Render and Premium Proxy when used.

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)

What types of websites work best with Autoparse?

Autoparse works best with structured content sites like e-commerce stores, news websites, job boards, real estate listings, and social media platforms. Sites with clear content hierarchy and semantic markup provide the most accurate results.

Can I combine Autoparse with other Zenrows features?

Yes, Autoparse works with all Zenrows features, except other output features like JSON Response or Markdown Response. If you also set extract=auto (Beta) on the same request, Extract takes precedence and Autoparse is ignored for that request.

What happens if Autoparse doesn't find the data I need?

If Autoparse misses specific data points feel free to contact Zenrows support for analysis or consider switching to manual CSS Extractor for precise control.

Does Autoparse work with JavaScript-heavy websites?

Autoparse processes whatever HTML is available. For JavaScript-heavy sites, combine it with js_render=true to ensure dynamic content is loaded before parsing. This combination provides comprehensive extraction for modern web applications.

Is there a more advanced version of Autoparse?

Yes. Extract (extract=auto) is in Beta. Instead of applying the same general-purpose rules to every website, it builds a dedicated extraction for each individual site, which returns richer fields and adapts automatically when the site’s layout changes. During Beta, Extract only works on a curated set of enabled domains, while Autoparse remains available on any website at no extra cost. Contact Zenrows support to check whether your target domain is enabled for Extract.

Get Started

Fetch

Extract

Batch

Browser Sessions

Residential Proxies (Legacy)

Guides

How Autoparse works

Basic usage

When to use Autoparse

Comparing extraction methods

Troubleshooting

Common issues and solutions

Improving extraction accuracy

Pricing

Frequently Asked Questions (FAQ)

​How Autoparse works

​Basic usage

​When to use Autoparse

​Comparing extraction methods

​Troubleshooting

​Common issues and solutions

​Improving extraction accuracy

​Pricing

​Frequently Asked Questions (FAQ)

How Autoparse works

Basic usage

When to use Autoparse

Comparing extraction methods

Troubleshooting

Common issues and solutions

Improving extraction accuracy

Pricing

Frequently Asked Questions (FAQ)