# Proxy & IP Quality Checker (`bounceverify/ip-quality-checker`) Actor

Check IP quality for scraping: residential, mobile, datacenter or VPN detection, Tor and blocklist checks, geolocation, and block risk for Google, Amazon, Cloudflare and social media.

- **URL**: https://apify.com/bounceverify/ip-quality-checker.md
- **Developed by:** [Redify](https://apify.com/bounceverify) (community)
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 ip checks

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

![Proxy & IP Quality Checker: know which IPs will get you blocked before you scrape](https://bounceverify.com/ip-quality-checker-banner.png)

## Proxy & IP Quality Checker

**Know which IPs will get you blocked — before you scrape.**

Paste your proxy list and get, for every IP, a **quality score from 0 to 100**, its **real type** (residential, mobile, datacenter, VPN or Tor), its **block risk on Google, Amazon, Cloudflare and social media**, and a clear verdict: keep it or drop it.

Run it on 100,000 IPs in one batch, or call it in real time from your scraper. You only pay for the IPs you check.

***

### 🚫 The problem: bad proxies cost you money

You bought "residential" proxies. Some of them are actually datacenter ranges. Others are recycled addresses already on blocklists. Half your pool sits in the same subnet, so one ban takes them all down.

You only find out after the fact: captchas, 403 errors, empty pages, wasted compute and wasted proxy bandwidth.

**This Actor checks every IP before you use it**, so you send traffic only through the addresses that will actually get through.

### ✅ What you get for every IP

| | |
|---|---|
| 🎯 **Quality score and grade** | A 0–100 score and an A–F grade, plus a `riskScore` for teams used to fraud-score tools |
| 🏠 **Real IP type** | Residential, mobile, datacenter, business or anonymizer, with a confidence level |
| 🕵️ **VPN detection by name** | Private Internet Access, NordVPN and Mullvad exits identified from the providers' own server lists |
| 🧅 **Tor and blocklists** | Tor exits, Spamhaus DROP and ASN-DROP, botnet C2 servers, IPs recently reported for attacks or bot activity |
| ☁️ **Cloud provider details** | AWS, Google Cloud, Oracle, Cloudflare, Fastly, DigitalOcean and Linode, with service and region when available |
| 🚦 **Block risk per target** | Separate risk levels for general websites, Google Search, Amazon, Cloudflare/Akamai-protected sites and social media |
| 🌍 **Geolocation** | Country, region, city, coordinates and time zone |
| 🔌 **Network and connection** | ISP, ASN, organization, shared (CGNAT) or dedicated, dynamic or static, Googlebot/Bingbot detection |
| 💬 **Plain-English explanation** | Every score lists the exact reasons behind it, so you can trust and verify it |

### 📊 Plus a report on your whole pool

A single bad IP is a problem. A badly built pool is a bigger one. After each run you also get:

- **Pool grade and diversity score**: how well your IPs are spread across subnets and providers.
- **Distribution** by type, country, ASN and /24 subnet.
- **Automatic warnings**, for example: *"A single /24 subnet makes up 40% of the pool: one range ban can take out a large share of your IPs."*
- **Two ready-to-use lists**: `CLEAN_IPS` (keep these) and `FLAGGED_IPS` (remove these). Drop them straight into your scraper config.

### 💡 Who is it for?

- **Scraping teams** checking a new proxy provider before committing to a contract.
- **Developers** who want to filter dead-weight IPs out of their rotation automatically.
- **Proxy buyers** verifying that "residential" really means residential.
- **Anyone automating the web** who wants fewer captchas and fewer bans.

### ⚡ Why this Actor

- **Just send IPs.** No proxy credentials, no traffic through your proxies. Nothing leaves your control.
- **Paste proxy lists as they are.** `1.2.3.4:8080`, `user:pass@1.2.3.4:8080`, `http://user:pass@1.2.3.4:3128`, `1.2.3.4:8080:user:pass` and `[2001:db8::1]:80` all work. The IP is extracted for you.
- **Fast at scale.** All data is indexed in memory, so each lookup takes microseconds. 100,000 IPs in one run is routine.
- **Fair billing.** Duplicates, invalid lines and private or reserved IPs are never charged.
- **Respects your budget.** Set a maximum cost per run: the Actor stops cleanly and keeps every result already computed.
- **Always fresh data.** Blocklists refresh every 1 to 12 hours, geolocation weekly. No stale database.
- **Batch or real-time.** Use the Console, schedule runs, or call the built-in HTTP API from your code.

***

### 🚀 How to use it

#### Option 1: Batch run (no code)

1. Paste your IPs or your proxy list into **IP addresses**, one per line.
2. Click **Start**.
3. Download your results from the **Output** tab as JSON, CSV or Excel.
4. Open the **Storage** tab for the pool report, `CLEAN_IPS` and `FLAGGED_IPS`.

Input example:

```json
{
  "ips": ["8.8.8.8", "user:pass@73.158.42.17:8080", "52.94.236.248"]
}
```

| Option | Default | What it does |
|---|---|---|
| `ips` | — | Your IPs or proxy list, one per line |
| `reverseDns` | `false` | Adds the PTR hostname of each IP. Slightly better detection, slower runs |
| `minScore` | `0` | Saves only IPs at or above this score to the dataset. The pool report still covers every IP |
| `includeInvalid` | `false` | Also lists the input lines that are not valid IPs |

#### Option 2: Real-time API

The Actor runs as an always-on HTTP API. Open the **API → Endpoints** tab to get your URL and try it from your browser.

```bash
## One IP
curl "https://<your-standby-url>/check?ip=8.8.8.8" \
  -H "Authorization: Bearer <APIFY_TOKEN>"

## Several IPs (comma-separated)
curl "https://<your-standby-url>/check?ip=8.8.8.8,1.1.1.1" \
  -H "Authorization: Bearer <APIFY_TOKEN>"

## Up to 1,000 IPs per request
curl -X POST "https://<your-standby-url>/check" \
  -H "Authorization: Bearer <APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"ips": ["8.8.8.8", "user:pass@73.158.42.17:8080"]}'
```

Add `reverseDns=true` to the URL (or `"reverseDns": true` in the body) to include hostnames.

#### Option 3: From your code

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("<USERNAME>/ip-quality-checker").call(run_input={
    "ips": ["8.8.8.8", "user:pass@73.158.42.17:8080"],
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item["scraping"]["recommendedUse"]:
        print("keep", item["ip"], item["score"])
```

You can also connect the Actor to Make, Zapier, n8n, webhooks or Google Sheets through Apify integrations.

***

### 📦 Output example

A datacenter proxy sold as a "premium" IP, caught on an official AWS range:

```json
{
  "ip": "52.94.236.248",
  "score": 55,
  "riskScore": 45,
  "grade": "C",
  "verdict": "Average quality — datacenter IP",
  "type": "datacenter",
  "typeConfidence": "high",
  "asn": { "number": 16509, "organization": "Amazon.com, Inc." },
  "isp": "Amazon.com, Inc.",
  "organization": "Amazon AWS",
  "location": {
    "country": "US", "countryName": "United States", "continent": "NA",
    "region": "Virginia", "city": "Ashburn",
    "latitude": 39.0438, "longitude": -77.4874, "timezone": "America/New_York"
  },
  "connection": { "type": "datacenter", "shared": false, "dynamic": false, "abuseVelocity": "none" },
  "hosting": { "isHosting": true, "provider": "Amazon AWS", "service": "AMAZON", "region": "us-east-1", "source": "official-ranges" },
  "threats": {
    "isTor": false, "recentAbuse": false,
    "isVpn": false, "vpnProvider": null,
    "isProxyOrVpnLikely": true
  },
  "scraping": {
    "generalWeb": "medium",
    "googleSearch": "high",
    "amazon": "high",
    "antiBotProtected": "high",
    "socialMedia": "very_high",
    "recommendedUse": false,
    "recommendations": ["Fine for sites without anti-bot protection, public APIs and cheap high-volume jobs. For Google, Amazon, Cloudflare-protected sites or social media, use residential or mobile proxies."]
  },
  "reasons": ["Official Amazon AWS range: flagged as datacenter by every anti-bot system (-45)"]
}
```

For a commercial VPN exit, `threats.isVpn` is `true` and `threats.vpnProvider` names the provider (for example `"Private Internet Access VPN"`), with a lower score and a VPN-specific recommendation.

Shortened for readability. Each result also includes `network`, `hostname`, the full `threats` object and `checkedAt`. Risk levels are `low`, `medium`, `high` and `very_high`.

### 🧮 How the score works

No black box. Every IP starts at 100, and points are removed for each risk signal. Each deduction appears in `reasons`.

| Signal | Penalty |
|---|---|
| Botnet C2 server (abuse.ch Feodo Tracker) | −80 |
| Spamhaus DROP range | −70 |
| Tor exit node | −60 |
| Recently reported for attacks or bot activity (2+ feeds / 1 feed) | −55 / −40 |
| Spamhaus ASN-DROP network | −50 |
| Official cloud provider range | −45 |
| Other hosting / datacenter network | −35 |
| Unknown network owner | −35 |
| Commercial VPN exit (confirmed / likely) | −25 / −15 |
| Server-style hostname on a non-hosting network | −10 |
| Corporate or institutional network | −10 |
| No reverse DNS record (when `reverseDns` is on) | −5 |

**Grades:** A ≥ 85 · B ≥ 70 · C ≥ 50 · D ≥ 30 · F < 30.

`recommendedUse` is `true` only for clean residential, mobile or business IPs scoring 70 or more.

### 💰 Pricing

**$0.90 per 1,000 IPs checked.** That's it.

- Duplicates, invalid entries and private or reserved IPs are **free**.
- Set a maximum cost per run and you will never pay more.
- Real-time API calls also include standard Apify platform usage.

### ❓ FAQ

**How do I know if my proxy is residential or datacenter?**
Check the `type` field. `hosting.source` tells you how a datacenter was detected: an official cloud range, a known hosting network, or the network's name.

**Do I need to share my proxy credentials?**
No. Only the IP address is analyzed. Credentials in pasted proxy lines are ignored and never used.

**Can it detect VPNs?**
Yes. Private Internet Access, NordVPN and Mullvad exits are named in `threats.vpnProvider`: `confirmed` when the exact IP is a known server, `likely` when it shares its /24. For any other VPN or proxy, `isProxyOrVpnLikely` is `true` whenever the IP sits on a hosting network, a Tor exit or a proxy-style hostname.

**Does it test my proxies against Google or Amazon?**
No. The block risk is an estimate based on how anti-bot systems treat each IP type and reputation signal. Your actual success also depends on request rate, headers and browser fingerprint. In return, checks are instant and never burn your proxy bandwidth.

**Why do mobile IPs score so well?**
Mobile carriers share each IP between many real users (CGNAT). Websites avoid banning them because they would block real customers too.

**What do `shared` and `dynamic` mean?**
`shared: true` means many users exit through the same IP (mobile CGNAT, VPN, Tor). `dynamic: true` means the hostname points to a rotating consumer address. `null` means the signal could not be determined reliably. We never guess.

**How fresh is the data?**
Tor exits refresh every hour, attack feeds every 6 hours, Spamhaus and VPN server lists every 12 hours, cloud ranges daily and geolocation weekly.

### 📚 Data sources

Public, regularly refreshed sources only:

- ASN, country and city: [DB-IP Lite](https://db-ip.com) (CC BY 4.0). City-level location is approximate, as with any IP geolocation database.
- Official IP ranges from AWS, Google Cloud, Oracle Cloud, Cloudflare, Fastly, DigitalOcean and Akamai Linode
- Official Googlebot and Bingbot ranges from Google and Microsoft
- Server lists published by Private Internet Access, NordVPN and Mullvad
- Tor Project exit list
- Spamhaus DROP and ASN-DROP
- abuse.ch Feodo Tracker
- blocklist.de, CINS Army, Emerging Threats and GreenSnow attack feeds

### 🤝 Support

Found an IP that looks misclassified, or need a feature? Open an issue in the **Issues** tab. Include the IP and what you expected, and it will be looked into.

***

IP geolocation and ASN data by [DB-IP](https://db-ip.com), licensed under CC BY 4.0.

# Actor input Schema

## `ips` (type: `array`):

One IP per line (IPv4 or IPv6). You can paste your proxy list as is: formats like 1.2.3.4:8080, user:pass@1.2.3.4:8080 or http://user:pass@1.2.3.4:3128 are accepted and the IP is extracted automatically. Duplicates are removed and never billed.

## `reverseDns` (type: `boolean`):

Look up the PTR hostname of each IP. Slightly improves residential/mobile and proxy detection, but makes runs slower. Off by default.

## `minScore` (type: `integer`):

Only save IPs with a quality score at or above this value (0–100) to the dataset. The pool report still covers every IP. Use 0 to keep everything.

## `includeInvalid` (type: `boolean`):

Also add input lines that are not valid IP addresses to the dataset, flagged with valid=false. They are not billed.

## `concurrency` (type: `integer`):

Number of IPs analyzed in parallel. The default works well for most runs.

## `dnsTimeoutMs` (type: `integer`):

Maximum wait for a reverse DNS answer per IP.

## Actor input object example

```json
{
  "ips": [
    "8.8.8.8",
    "1.1.1.1",
    "52.94.236.248"
  ],
  "reverseDns": false,
  "minScore": 0,
  "includeInvalid": false,
  "concurrency": 200,
  "dnsTimeoutMs": 2500
}
```

# Actor output Schema

## `results` (type: `string`):

One record per IP with score, type, location, VPN/proxy and threat details.

## `poolReport` (type: `string`):

Summary of the whole list: average score, diversity, distribution by type, country, ASN and subnet, and insights.

## `cleanIps` (type: `string`):

IPs recommended for scraping, one per line.

## `flaggedIps` (type: `string`):

Low-quality IPs (grade D or F), one per line.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "ips": [
        "8.8.8.8",
        "1.1.1.1",
        "52.94.236.248"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("bounceverify/ip-quality-checker").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "ips": [
        "8.8.8.8",
        "1.1.1.1",
        "52.94.236.248",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("bounceverify/ip-quality-checker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "ips": [
    "8.8.8.8",
    "1.1.1.1",
    "52.94.236.248"
  ]
}' |
apify call bounceverify/ip-quality-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,bounceverify/ip-quality-checker"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/NlBl4NjFSl6j65VFP/builds/f0hJjWftjUaJelOk9/openapi.json