Skip to main content
JavaScript Rendering processes web pages through a headless browser - a browser without a graphical interface that can execute JavaScript and render dynamic content. Many modern websites load content dynamically after the initial page load, making this data invisible to standard HTTP requests that only capture the initial HTML. When you enable JavaScript Rendering, ZenRows simulates a real browser environment, executing all JavaScript code and waiting for dynamic content to load before returning the fully rendered page. This browser simulation also helps bypass sophisticated anti-bot protections that analyze browser behavior, JavaScript execution patterns, and other browser-specific characteristics that Premium Proxy alone cannot address.

​
How JavaScript Rendering Works

JavaScript Rendering launches a headless browser instance that navigates to your target URL just like a regular browser would. The browser executes all JavaScript code, processes CSS, loads additional resources, and waits for the page to fully render before extracting the HTML content. This process captures content that appears after the initial page load, such as:
  • AJAX-loaded product listings
  • Single-page application (SPA) navigation
  • Dynamic pricing information
  • User-generated content loaded via JavaScript
Additionally, the browser simulation helps bypass advanced anti-bot measures that detect:
  • Missing browser APIs and properties
  • Unusual JavaScript execution patterns
  • Absence of browser-specific behaviors
  • Automated request signatures

​
Basic usage

Enable JavaScript Rendering by adding the js_render=true parameter to your ZenRows request: 
# pip install requests
import requests

url = 'https://httpbin.io/anything'
apikey = 'YOUR_ZENROWS_API_KEY'
params = {
    'url': url,
    'apikey': apikey,
	'js_render': 'true',
}
response = requests.get('https://api.zenrows.com/v1/', params=params)
print(response.text)
This example enables JavaScript Rendering for your request. ZenRows processes the page through a headless browser, executing all JavaScript and returning the fully rendered HTML content, rather than just the initial server response.

​
When to use JavaScript Rendering

​
Content-related needs:

  • Single-page applications (SPAs) - React, Vue, Angular applications that load content dynamically
  • E-commerce sites - Product listings, prices, and reviews loaded via JavaScript
  • Search results - Dynamic search results and pagination
  • Infinite scroll content - Content that loads as users scroll down
  • AJAX-heavy websites - Sites that rely heavily on asynchronous data loading
  • Progressive web apps - Modern web applications with dynamic content updates

​
Protection bypass needs:

  • Advanced anti-bot systems - Sites that analyze browser fingerprints and JavaScript execution
  • Behavioral detection - Websites that monitor mouse movements, timing patterns, and user interactions
  • Browser API validation - Sites that check for the presence of browser-specific APIs and properties
  • CloudFlare challenges - Advanced protection that requires JavaScript execution to pass
  • Captcha systems - Some captchas that rely on browser behavior analysis
For the highest success rate, especially on heavily protected websites, combine JavaScript Rendering with Premium Proxy. This combination provides both residential IP addresses and realistic browser behavior:
Python
# Maximum protection: JS Rendering + Premium Proxy
params = {
    'url': 'https://httpbin.io/anything',
    'apikey': 'YOUR_ZENROWS_API_KEY',
    'js_render': 'true',        # Browser simulation
    'premium_proxy': 'true',    # Residential IP
}
response = requests.get('https://api.zenrows.com/v1/', params=params)
print(response.text)
This combination addresses multiple layers of protection:
  • Premium Proxy: Provides residential IP addresses that are harder to detect and block
  • JavaScript Rendering: Simulates genuine browser behavior and executes anti-bot detection scripts

​
Identifying when you need JavaScript Rendering

You can determine if a website requires JavaScript Rendering by comparing the initial HTML with what you see in the browser:
Python
import requests

# Test without JavaScript Rendering
url = 'https://httpbin.io/anything'
response_standard = requests.get('https://api.zenrows.com/v1/', params={
    'url': url,
    'apikey': 'YOUR_ZENROWS_API_KEY',
})

# Test with JavaScript Rendering
response_js = requests.get('https://api.zenrows.com/v1/', params={
    'url': url,
    'apikey': 'YOUR_ZENROWS_API_KEY',
    'js_render': 'true',
})

# Compare content lengths
print(f"Standard HTML length: {len(response_standard.text)}")
print(f"JS-rendered HTML length: {len(response_js.text)}")

# If JS-rendered content is significantly longer, you need JavaScript Rendering

​
Troubleshooting

​
Common issues and solutions

IssueCauseSolution
Content still missing or incompletePage needs more time to loadIncrease wait time or use wait_for parameter
Still getting blockedNeed residential IPsAdd premium_proxy=true
Slow response timesBrowser processing overheadUse JavaScript Rendering only when necessary
Higher costs than expectedUsing both features unnecessarilyImplement progressive enhancement strategy
Advanced bot detectionSophisticated fingerprintingCombine JS Rendering + Premium Proxy + Custom Headers

​
Debugging protection bypassing

When you’re still getting blocked despite using JavaScript Rendering:
1

Add Premium Proxy for residential IPs

Python
params = {
    'js_render': 'true',
    'premium_proxy': 'true',
}
2

Increase wait time or wait for a specific selector for detection scripts

Python
params = {
    'js_render': 'true',
    'premium_proxy': 'true',
    'wait': '5000',
}
See more on the Wait and Wait_for documentation pages
3

Add realistic headers

Python
params = {
    'js_render': 'true',
    'premium_proxy': 'true',
    'wait': '5000',
}
headers = {
    'referer': 'https://www.google.com'
}
4

Return the original status from the website

Python
params = {
    'js_render': 'true',
    'original_status': 'true',
}
Returning the original status helps you identify what HTML status code the website is returning.
See more about the original_status parameter here

​
Pricing

JavaScript Rendering costs 5 times the standard request rate due to the additional computational resources required for browser processing. Monitor your usage through the ZenRows analytics page to track costs and optimize your scraping strategy accordingly.

​
Frequently Asked Questions (FAQ)

Several features rely on js_render being set to true. These include:
  • Wait: Introduces a delay before proceeding with the request. Useful for scenarios where you need to allow time for JavaScript to load content.
  • Wait For: Waits for a specific element to appear on the page before proceeding. When used with js_render, this parameter will cause the request to fail if the selector is not found.
  • JSON Response: Retrieves the rendered page content in JSON format, including data loaded dynamically via JavaScript.
  • Block Resources: Block specific types of resources from being loaded.
  • JavaScript Instructions: Allows you to execute custom JavaScript code on the page. This includes additional parameters.
  • Screenshot: Capture an above-the-fold screenshot of the target page by adding screenshot=true to the request.
Use JavaScript Rendering when the content you need is loaded dynamically via JavaScript, when dealing with single-page applications, or when facing advanced anti-bot protection that analyzes browser behavior. If the content is present in the initial HTML response and the site has no protection, standard requests are more cost-effective.
For the highest success rate on protected websites, yes. However, this combination costs 25x the standard rate. Start with individual features and combine them only when necessary. Use progressive enhancement to find the most cost-effective approach for each target.
JavaScript Rendering simulates a real browser environment, executing anti-bot detection scripts and providing browser-specific APIs that automated tools typically lack. This makes requests appear more like genuine user traffic, helping bypass sophisticated behavioral analysis systems.
If the combination of JavaScript Rendering and Premium Proxy doesn’t work, the website likely uses very advanced protection. Try adding longer wait times, custom headers, or contact ZenRows support for assistance with particularly challenging targets.
Yes, you can specify proxy countries when using both features by adding the proxy_country parameter. This can help access geo-restricted content while maintaining the protection benefits of both features.
⌘I