> ## Documentation Index
> Fetch the complete documentation index at: https://docs.zenrows.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Premium Proxy (Residential IPs)

> Bypass anti-bot detection by routing scraping requests through 55 million residential IP addresses with ZenRows Premium Proxy for higher success.

Premium Proxy routes your requests through residential IP addresses instead of standard datacenter IPs. These residential IPs come from real Internet Service Provider (ISP) connections assigned to actual households, making them significantly harder for websites to detect and block.

When websites implement anti-scraping measures, they typically target datacenter IP ranges first. Premium Proxy addresses this challenge by utilizing IP addresses that appear as regular user traffic, thereby dramatically improving your scraping success rates on protected websites.

## How Premium Proxy works

Premium Proxy automatically selects residential IP addresses from ZenRows' global pool when the feature is enabled. Each request routes through a different residential connection, mimicking natural user behavior and avoiding the IP-based blocking that affects datacenter proxies.

The system handles IP rotation automatically, so you don't need to manage proxy lists or worry about IP exhaustion. ZenRows maintains thousands of residential IPs across multiple countries to ensure reliable access to your target websites.

## Basic usage

Enable Premium Proxy by adding the `premium_proxy=true` parameter to your ZenRows request:

<CodeGroup>
  ```python Python theme={null}
  # pip install requests
  import requests

  url = 'https://httpbin.io/anything'
  apikey = 'YOUR_ZENROWS_API_KEY'
  params = {
      'url': url,
      'apikey': apikey,
      'premium_proxy': 'true',
  }
  response = requests.get('https://api.zenrows.com/v1/', params=params)
  print(response.text)
  ```

  ```javascript Node.js theme={null}
  // npm install axios
  const axios = require('axios');

  const url = 'https://httpbin.io/anything';
  const apikey = 'YOUR_ZENROWS_API_KEY';
  axios({
      url: 'https://api.zenrows.com/v1/',
      method: 'GET',
      params: {
          'url': url,
          'apikey': apikey,
          'premium_proxy': 'true',
      },
  })
      .then(response => console.log(response.data))
      .catch(error => console.log(error));
  ```

  ```java Java theme={null}
  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%2Fhttpbin.io%2Fanything&premium_proxy=true";
          String response = Request.get(apiUrl)
                  .execute().returnContent().asString();

          System.out.println(response);
      }
  }
  ```

  ```php PHP theme={null}
  <?php
  $ch = curl_init();
  curl_setopt($ch, CURLOPT_URL, 'https://api.zenrows.com/v1/?apikey=YOUR_ZENROWS_API_KEY&url=https%3A%2F%2Fhttpbin.io%2Fanything&premium_proxy=true');
  curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
  curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
  $response = curl_exec($ch);
  echo $response . PHP_EOL;
  curl_close($ch);
  ?>
  ```

  ```go Go theme={null}
  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%2Fhttpbin.io%2Fanything&premium_proxy=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))
  }
  ```

  ```ruby Ruby theme={null}
  # gem install faraday
  require 'faraday'

  url = URI.parse('https://api.zenrows.com/v1/?apikey=YOUR_ZENROWS_API_KEY&url=https%3A%2F%2Fhttpbin.io%2Fanything&premium_proxy=true')
  conn = Faraday.new()
  conn.options.timeout = 180
  res = conn.get(url, nil, nil)
  print(res.body)
  ```

  ```bash cURL theme={null}
  curl "https://api.zenrows.com/v1/?apikey=YOUR_ZENROWS_API_KEY&url=https%3A%2F%2Fhttpbin.io%2Fanything&premium_proxy=true"
  ```
</CodeGroup>

This example enables Premium Proxy for your request. ZenRows automatically selects an available residential IP and routes your request through it, improving your chances of successful data extraction.

## When to use Premium Proxy

Premium Proxy is essential in these scenarios:

* **High-security websites** - Sites protected by CloudFlare, Akamai, or similar anti-bot systems
* **E-commerce platforms** - Online stores that actively block datacenter IPs
* **Social media sites** - Platforms with sophisticated bot detection
* **Financial websites** - Banking and trading sites with strict access controls
* **Streaming services** - Video platforms that block automated access
* **Government websites** - Official sites with enhanced security measures

## Best practices

### Combine with other features

Premium Proxy works best when combined with other ZenRows features:

```python Python theme={null}
params = {
    'url': target_url,
    'apikey': 'YOUR_ZENROWS_API_KEY',
    'premium_proxy': 'true',
    'js_render': 'true',  # For JavaScript-heavy sites
    'wait_for': '.content',  # Wait for specific elements
}
```

### Monitor success rates

Track your scraping success to optimize your approach:

```python Python theme={null}
successful_requests = 0
total_requests = 0

for url in url_list:
    total_requests += 1
    response = requests.get('https://api.zenrows.com/v1/', params={
        'url': url,
        'apikey': 'YOUR_ZENROWS_API_KEY',
        'premium_proxy': 'true',
    })
    
    if response.status_code == 200:
        successful_requests += 1

success_rate = (successful_requests / total_requests) * 100
print(f"Success rate: {success_rate}%")
```

## Troubleshooting

### Common issues and solutions

| Issue                      | Cause                                               | Solution                                                                                                                                                                                |
| -------------------------- | --------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Still getting blocked      | Website uses advanced fingerprinting                | Add `js_render=true` and custom headers                                                                                                                                                 |
| Inconsistent results       | Different residential IPs may see different content | Use session management or sticky sessions ([session\_id](/universal-scraper-api/features/other#session-id)), or test using [Geolocation](/universal-scraper-api/features/proxy-country) |
| Higher costs than expected | Premium Proxy costs 10x base rate                   | Monitor usage and optimize request frequency                                                                                                                                            |

### Debugging blocked requests

If you're still getting blocked with Premium Proxy enabled:

<Steps>
  <Step title="Add JavaScript rendering">
    ```python Python theme={null}
    params = {
        'premium_proxy': 'true',
        'js_render': 'true',
    }
    ```

    <Tip>
      See more about the `js_render` parameter [here](./js-rendering)
    </Tip>
  </Step>

  <Step title="Return the original status from the website">
    ```python Python theme={null}
    params = {
        'premium_proxy': 'true',
        'original_status': 'true',
    }
    ```

    <Tip>
      See more about the `original_status` parameter [here](/universal-scraper-api/features/other#original-http-code)
    </Tip>
  </Step>

  <Step title="Include realistic headers">
    ```python Python theme={null}
    params = {
        'premium_proxy': 'true',
        'js_render': 'true',
        'custom_headers': 'true',
    }
    headers = {
        'referer': 'https://www.google.com'
    }
    ```

    <Tip>
      See more about the `custom_headers` parameter [here](/universal-scraper-api/features/headers)
    </Tip>
  </Step>

  <Step title="Add wait times for dynamic content">
    ```python Python theme={null}
    params = {
        'premium_proxy': 'true',
        'js_render': 'true',
        'wait': '3000',
    }
    ```
  </Step>
</Steps>

## Pricing

Premium Proxy requests cost 10 times the standard rate. This pricing reflects the higher cost and limited availability of residential IP addresses compared to datacenter proxies.

<Tip>
  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](https://app.zenrows.com/analytics/scraper-api). You can also set up usage alerts in your [notification settings](https://app.zenrows.com/account/notifications) 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](https://docs.zenrows.com/universal-scraper-api/features/other#plan-usage).

  **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
</Tip>

## Frequently Asked Questions (FAQ)

<Accordion title="How does Premium Proxy differ from standard proxies?">
  Premium Proxy utilizes residential IP addresses from genuine ISP connections, whereas standard proxies employ data center IPs. Residential IPs are much harder for websites to detect and block, resulting in higher success rates for scraping protected websites.
</Accordion>

<Accordion title="Can I specify which residential IP to use?">
  No, ZenRows automatically selects residential IPs from its pool to ensure optimal performance and avoid IP exhaustion. Manual IP selection could lead to blocking and reduced success rates.
</Accordion>

<Accordion title="Do I need Premium Proxy for all websites?">
  No, Premium Proxy is primarily needed for websites with anti-scraping measures. Simple websites without bot protection can often be scraped successfully using standard datacenter proxies.
</Accordion>

<Accordion title="Can I use Premium Proxy with custom headers?">
  Yes, Premium Proxy works with all other ZenRows features, including custom headers, JavaScript rendering, and wait parameters. Combining features often provides the best results.
</Accordion>