Autoparse

Autoparse is deprecated. Use Extract (extract=auto) instead.The autoparse parameter still works and existing integrations keep running, so nothing breaks today. It is no longer the recommended way to get JSON from a page, and new integrations should start with Extract. Any sunset will be announced separately, with notice.

Autoparse returns structured JSON instead of raw HTML. A small set of sites has a dedicated parser behind the parameter; on every other site, Autoparse returns the JSON objects it finds embedded in the page’s <script> tags, which may or may not hold the data you are after.

Migrate to Extract

Swap one parameter. Everything else about the request stays the same:

# before
params = {'url': url, 'apikey': apikey, 'autoparse': 'true'}

# after
params = {'url': url, 'apikey': apikey, 'extract': 'auto'}

// before
params: { url: url, apikey: apikey, autoparse: 'true' }

// after
params: { url: url, apikey: apikey, extract: 'auto' }

# before
curl "https://api.zenrows.com/v1/?apikey=YOUR_ZENROWS_API_KEY&url=YOUR_URL&autoparse=true"

# after
curl "https://api.zenrows.com/v1/?apikey=YOUR_ZENROWS_API_KEY&url=YOUR_URL&extract=auto"

Two things change, so test before you switch a production job over:

The response shape. Autoparse returns whatever JSON it can find on the page, with no guaranteed keys. Extract returns named fields for the entities on the page, so any code that reads Autoparse output by position or by a key it discovered by inspection needs updating.
Domain coverage. Extract serves prepared domains. If yours is not prepared yet, request it; preparation usually takes minutes and then applies to every Zenrows API key.

On the eCommerce page used throughout this guide, the difference is concrete:

Parameter	What comes back
`autoparse=true`	The JSON embedded in the page: WordPress and WooCommerce configuration objects and a breadcrumb list. The product listing is not part of it.
`extract=auto`	The 188 products, each with `name`, `price`, `currency`, `sku`, `availability`, `image_url` and `product_url`, plus a `page_context` object with the pagination.

How Autoparse works

Autoparse takes one of two paths, depending on the site:

A dedicated parser, where Zenrows ships one for that site. These cover a limited set of well-known sites and return named fields such as product details, job listings or search results.
Embedded JSON, everywhere else. Autoparse collects the JSON objects it finds in the page’s <script> tags and returns them as an array. On sites that render their data into those objects this is useful; on sites that do not, it returns page configuration and little else.

Neither path is tailored to the site you are requesting, which is the gap Extract closes: it builds and maintains an extraction per domain and returns named fields for the entities on the page.

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 returns JSON instead of raw HTML. What that JSON holds depends on the site: a dedicated parser where one exists, otherwise the JSON objects embedded in the page. On this eCommerce page it is WordPress and WooCommerce configuration rather than the product listing, which is what Extract returns instead.

Where Autoparse is still used

New integrations should start with Extract. These are the cases the parameter covers today: 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
Extract (`extract=auto`)	Any site where you want structured data	Tailored to each website, adapts when the site’s layout changes, richer fields	The domain has to be prepared first
Autoparse (deprecated)	Integrations already built on it	No coding required, works across sites, JSON output	General-purpose rules, often returns page scaffolding rather than the data you want
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. Extract may also capture more complete fields once the domain is prepared.

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.

Open Analytics Open notification settings

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
X-Key-Credits-Remaining: Lowest remaining credits across your API key’s credit caps, sent only for keys with at least one cap

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 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.

What replaces Autoparse?

Extract (extract=auto). 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. See Migrate to Extract for the parameter swap and what changes in the response.

Is the autoparse parameter going away?

Not today. It is deprecated, which means it still works and existing integrations keep running, but it is no longer recommended and new work should start with Extract. If a removal is scheduled, it will be announced separately with notice.

Get Started

Fetch

Extract

Crawl

Batch

Browser

Residential Proxies (Legacy)

Guides

Migrate to Extract

How Autoparse works

Basic usage

Where Autoparse is still used

Comparing extraction methods

Troubleshooting

Common issues and solutions

Improving extraction accuracy

Pricing

Frequently Asked Questions (FAQ)

​Migrate to Extract

​How Autoparse works

​Basic usage

​Where Autoparse is still used

​Comparing extraction methods

​Troubleshooting

​Common issues and solutions

​Improving extraction accuracy

​Pricing

​Frequently Asked Questions (FAQ)

Migrate to Extract

How Autoparse works

Basic usage

Where Autoparse is still used

Comparing extraction methods

Troubleshooting

Common issues and solutions

Improving extraction accuracy

Pricing

Frequently Asked Questions (FAQ)