# iplogs.com API: free VPN and proxy detection

One POST returns a verdict, a score and the network behind an IP address. Free, with no key and no sign-up.

```sh
curl iplogs.com
```

```json
{
  "ip": "203.0.113.7",
  "verdict": "vpn_detected",
  "score": 0.85,
  "is_vpn": true,
  "is_proxy": false,
  "is_tor": false,
  "is_relay": false,
  "is_hosting": true,
  "vpn_provider": "Mullvad",
  "asn": "AS9009",
  "org": "M247 Europe SRL",
  "city": "Phoenix",
  "country": "United States",
  "country_code": "US",
  "signals": [
    "vpn_relay_list",
    "vpn_aggregator_cidr",
    "dc_ip"
  ],
  "details": "https://iplogs.com/ip/203.0.113.7"
}
```

POST https://iplogs.com/v1/check

### cURL (Nothing to install)

```sh
curl https://iplogs.com/v1/check \
  -H 'content-type: application/json' \
  -d '{"ip":"185.220.101.34"}'
```

### Node.js (Node 18+, no packages)

```js
const res = await fetch("https://iplogs.com/v1/check", {
  method: "POST",
  headers: { "content-type": "application/json" },
  body: JSON.stringify({ ip: "185.220.101.34" }),
  signal: AbortSignal.timeout(30_000),
});
if (!res.ok) throw new Error(`iplogs.com answered ${res.status}`);
const { verdict, score } = await res.json();
console.log(verdict, score); // vpn_detected 1
```

### Python (pip install requests)

```python
import requests

r = requests.post(
    "https://iplogs.com/v1/check",
    json={"ip": "185.220.101.34"},
    timeout=30,
)
r.raise_for_status()
data = r.json()
print(data["verdict"], data["score"])  # vpn_detected 1
```

### PHP (PHP 8 with the curl extension)

```php
<?php
$ch = curl_init("https://iplogs.com/v1/check");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => ["Content-Type: application/json"],
    CURLOPT_POSTFIELDS => json_encode(["ip" => "185.220.101.34"]),
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);
$data = json_decode(curl_exec($ch), true);
echo $data["verdict"], " ", $data["score"], "\n"; // vpn_detected 1
```

### Go (Standard library only)

```go
package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"strings"
	"time"
)

func main() {
	client := &http.Client{Timeout: 30 * time.Second}
	resp, err := client.Post("https://iplogs.com/v1/check", "application/json",
		strings.NewReader(`{"ip":"185.220.101.34"}`))
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	var r struct {
		Verdict string  `json:"verdict"`
		Score   float64 `json:"score"`
	}
	if err := json.NewDecoder(resp.Body).Decode(&r); err != nil {
		panic(err)
	}
	fmt.Println(r.Verdict, r.Score) // vpn_detected 1
}
```

### Java (Java 11+, no dependencies)

```java
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;

public class Check {
    public static void main(String[] args) throws Exception {
        var req = HttpRequest.newBuilder(URI.create("https://iplogs.com/v1/check"))
            .header("Content-Type", "application/json")
            .timeout(Duration.ofSeconds(30))
            .POST(HttpRequest.BodyPublishers.ofString("{\"ip\":\"185.220.101.34\"}"))
            .build();
        var res = HttpClient.newHttpClient().send(req, HttpResponse.BodyHandlers.ofString());
        System.out.println(res.body()); // {"score":1,"verdict":"vpn_detected",...}
    }
}
```

## Responses

### 200 OK

A real answer for a Tor exit, abridged to two of its signals.

```json
{
  "score": 1,
  "verdict": "vpn_detected",
  "is_vpn": true,
  "is_proxy": true,
  "reputation": "greylist",
  "signals": [
    {
      "type": "tor_exit",
      "weight": 0.95,
      "matched": true,
      "detail": "…"
    },
    {
      "type": "vpn_aggregator_cidr",
      "weight": 0.65,
      "matched": true,
      "detail": "…"
    }
  ],
  "ip_info": {
    "ip": "185.220.101.34",
    "asn": "AS60729",
    "org": "Stiftung Erneuerbare Freiheit",
    "country": "Germany",
    "country_code": "DE",
    "vpn_provider": "Tor"
  },
  "request_id": "req_6228befb-59f"
}
```

### 400 Bad request

Not an IP address, or a private one (10.x, 192.168.x, loopback, link-local).

```json
{
  "error": "invalid IP address"
}
```

### 429 Too many requests

Over 60 requests a minute. Wait Retry-After seconds, then retry.

Header: Retry-After: 1

```json
{
  "error": "rate limit exceeded, slow down and retry — see https://iplogs.com/docs#rate-limits"
}
```

### 504 Timed out

A full check ran past 30 seconds. Retry, or send "mode": "fast".

```json
{
  "error": "detection timed out, please retry"
}
```

## Endpoints

| Method | Path | What it does |
| --- | --- | --- |
| GET | https://iplogs.com/ | curl iplogs.com checks the caller and prints a short summary, pretty-printed for curl, wget, HTTPie, xh and PowerShell (add ?pretty from anywhere else). |
| GET | https://iplogs.com/{ip} | The same summary for another address, e.g. curl iplogs.com/8.8.8.8. |
| GET | https://iplogs.com/v1/summary | The summary as JSON for the caller. /v1/summary/{ip} takes an address. |
| GET | https://iplogs.com/v1/lookup/{ip} | IP check: owner name, owner domains, ASN, network range, location and list flags from stored data, in about a millisecond, no probing, no daily quota, 50 requests a second. /v1/lookup checks the caller. |
| GET | https://iplogs.com/v1/check | The full response for the caller, no body needed. /v1/check/{ip} takes an address. |
| POST | https://iplogs.com/v1/check | One address in full: verdict, score, every signal and the network. Same response as GET /v1/check/{ip}. |
| POST | https://iplogs.com/v1/bulk-check | Up to 100 addresses in one call. One compact row each, no live probes. |
| GET | https://iplogs.com/v1/ip | The caller's own address and its family. ipv4.iplogs.com and ipv6.iplogs.com each answer over one family. |
| GET | https://iplogs.com/v1/health | {"status": "ok"} while the API is up. |

## Request body

| Field | Type | Meaning |
| --- | --- | --- |
| ip | string, optional | The IPv4 or IPv6 address to check. Leave it out to check whoever sent the request. |
| mode | string, optional | "fast" answers from memory in microseconds: every list and network check, no live probes or lookups. |
| timezone | string, optional | Browser calls only (no ip): The browser's IANA time zone, e.g. America/New_York, compared with the IP's location. |
| language | string, optional | Browser calls only (no ip): The browser's language, e.g. en-US, compared with the IP's country. |
| webrtc_ip | string, optional | Browser calls only (no ip): An address the browser exposed over WebRTC; a different one is a leak. |
| user_agent | string, optional | Browser calls only (no ip): Read from the request header already. Send it only to override that. |

## Response fields

| Field | Type | Meaning |
| --- | --- | --- |
| score | number | 0 to 1. Higher means more evidence of a VPN, proxy, relay or Tor exit. Not a probability. |
| verdict | string | clean below 0.30, suspicious below 0.60, vpn_likely below 0.85, then vpn_detected. Tor exits and relays use the same levels; vpn_provider says which. |
| is_vpn | boolean | True when the score is 0.60 or more. |
| is_proxy | boolean | The same test, counting only proxy-type evidence. |
| proxy_type | string | Set when is_proxy is true and the evidence says which kind: residential (exit of a residential proxy network), isp (static ISP proxy), public (open proxy anyone can use) or datacenter (a proxy company's own servers). Omitted for Tor and relays, which have their own flags. |
| is_tor | boolean | A current Tor exit. |
| is_relay | boolean | An iCloud Private Relay or Cloudflare WARP exit, or a corporate secure web gateway: relays many sites choose to allow. |
| is_crawler | boolean | Inside a crawler's or uptime monitor's published address ranges (Googlebot, Bingbot, Applebot, OpenAI, Perplexity, DuckDuckGo, Common Crawl, Anthropic, Ahrefs, Pingdom, UptimeRobot and others). Verified by address, not by User-Agent. |
| crawler | object | Present only when is_crawler is true: name (e.g. GPTBot), operator (e.g. OpenAI) and purpose: search, ai_training, ai_search, user_fetch (a person asked an assistant to open the page), seo, monitor, archive, crawler or ai. Lets you allow ChatGPT-User while blocking GPTBot. |
| is_satellite | boolean | The network serves users over satellite (Starlink, Viasat, HughesNet, OneWeb, inflight and maritime Wi-Fi). Location can be far from the user, and round-trip checks are skipped there, since satellite links split connections the way proxies do. |
| is_hosting | boolean | A datacenter, cloud or CDN network rather than a home or mobile connection. |
| reputation | string | allowlist (no abuse, nothing hidden), greylist (no abuse, but hidden or hosted) or blocklist (recent attacks or abuse). Separate from the verdict. |
| mode | string | "fast" when the answer came from the in-memory path. Absent on a full check. |
| signals | array | Each check run: type, weight, matched, and a short detail. Server lists, Tor exits and our own sightings also carry last_seen (UTC): when our data last confirmed the address. Only matched signals add to the score. |
| ip_info | object | ip, asn, org, country, country_code, city, reverse_dns, prefix, and vpn_provider: the operator (Mullvad, Tor, Apple) when one is known. |
| request_id | string | Quote it when you report a wrong result. |

## Many addresses

POST https://iplogs.com/v1/bulk-check: up to 100 addresses, a compact row for each, no live probes.

```json
{"ips": ["185.220.101.34", "146.70.116.130",
         "8.8.8.8", "10.0.0.1"]}
```

```json
{
  "total": 4,
  "duration_ms": 3001,
  "results": [
    { "ip": "185.220.101.34", "verdict": "vpn_detected", "score": 1,
      "is_vpn": true, "reputation": "greylist", "vpn_provider": "Tor",
      "country_code": "DE", "asn": "AS60729",
      "org": "Stiftung Erneuerbare Freiheit" },
    { "ip": "146.70.116.130", "verdict": "vpn_detected", "score": 1,
      "is_vpn": true, "reputation": "greylist", "vpn_provider": "Mullvad",
      "country_code": "AT", "asn": "AS9009", "org": "M247 Europe SRL" },
    { "ip": "8.8.8.8", "verdict": "clean", "score": 0, "is_vpn": false,
      "reputation": "allowlist", "country_code": "US", "asn": "AS15169",
      "org": "Google LLC" },
    { "ip": "10.0.0.1", "score": 0, "is_vpn": false,
      "error": "IP must be a public address" }
  ]
}
```

## Before you ship

- **Send the visitor's IP from your server.** Leave ip out and the API checks whoever made the request. Called from your backend, that is your own server.
- **Browser fields only count in the browser.** timezone, language, webrtc_ip and user_agent are read only when the visitor's browser calls the API itself, with no ip. Sent alongside an ip they are ignored. The visitor can edit a browser-side result, so use it for soft decisions.
- **Over the daily quota is still a 200.** Past 2,000 full checks a day, answers come from the fast path with "mode": "fast". No live probes run, so a server only a VPN handshake gives away can score lower. Read mode if depth matters.
- **Privacy relays are not VPN users.** iCloud Private Relay and Cloudflare WARP score like a VPN, but most people behind them are ordinary customers with the setting switched on. Corporate web gateways such as Zscaler are proxies by design, used by a company's staff. To let them through while blocking VPNs, check is_relay before acting on the verdict.
- **Search engines come from hosting networks.** Googlebot, Bingbot and AI crawlers run in datacenters, so their verdict can read suspicious. Check is_crawler before blocking: it is set only for addresses in the operator's published ranges, so a scraper faking a Googlebot User-Agent does not get it.
- **A missing vpn_provider is not a clean result.** Many detections come from ranges with no operator named. Decide on verdict or is_vpn; treat vpn_provider as a label.
- **Bulk rows skip live probes.** A /v1/bulk-check row can score lower than /v1/check for the same address. Re-check the borderline ones one at a time.
- **An answer can be 30 minutes old.** Full checks are cached per address for 30 minutes. A VPN server that went live a minute ago may not show yet.
- **Private addresses are refused.** 10.x, 192.168.x, loopback and link-local addresses get a 400. In a bulk call each one comes back as a row with error set, and the rest still run.
- **Give it 30 seconds, or ask for fast.** A first look at an unseen hosting address takes 5–7 s; the API stops at 30 s with a 504. With a hard budget, such as a login, send "mode": "fast".

## Limits and errors

Per IP address; IPv6 counted per /64.

| Limit | Free tier | Past the limit |
| --- | --- | --- |
| Requests | 60 a minute | 429 with Retry-After |
| Full checks | 2,000 a UTC day | Still 200, answered from the fast path with "mode": "fast"; no daily cap there |
| GET routes | Share the /v1/check limits | As above |
| Bulk | 100 IPs per call; 3 calls in a burst, then 1 every 5 s | 429 with Retry-After |
| Bad address | – | 400 with {"error": "invalid IP address"} |
| Time | 30 s per full check | 504 with {"error": "detection timed out, please retry"} |

Every charged response carries X-RateLimit-Limit, X-RateLimit-Remaining and X-RateLimit-Reset.

## What to do with a score

| Score | Verdict | Suggested action |
| --- | --- | --- |
| 0–29 | clean | Allow. |
| 30–59 | suspicious | Allow; add friction only on sensitive actions. |
| 60–84 | vpn_likely | Challenge: verify an email or phone, or require a login. Privacy relays: prefer a light challenge. |
| 85–100 | vpn_detected | Challenge or block, per your policy on VPNs and Tor. |

## How the score works

- Seven layers look at an address: IP intelligence, TCP/IP fingerprint, TLS fingerprint, round-trip timing, active probing, browser signals, and port and network sanity.
- Strong evidence: a VPN server, a Tor exit, a VPN or proxy range, an open proxy, a Private Relay or WARP exit, a live VPN handshake.
- Weaker evidence: a datacenter or cloud network, unusual routing, a browser time zone or language that doesn't fit the IP.
- The score adds the weights of every matched signal, up to 1. Statements about the network alone (hosting, a VPN-friendly hoster, abuse lists, routing) add at most 0.55 together, so they never reach vpn_likely by themselves; a VPN handshake answered on a home line counts for at most 0.55, since routers run VPN servers for their owners. Two agreeing tunnel measurements (MTU, TTL, round trips) add 0.15, and a live handshake on a datacenter address adds 0.10.
- Measured on 2,831 known addresses (3 November 2026): all 1,722 commercial VPN servers detected, 0.3% false positives on 951 homes, mobile lines, universities, offices, clouds and CDNs. Details on the accuracy page.
- Weak spot: a residential proxy exit is close to undetectable from the IP alone.

## Signal types

| Type | Meaning |
| --- | --- |
| tor_exit | A current Tor exit relay. |
| vpn_relay_list | A server a VPN provider publishes. |
| vpn_server_seen | A hosting address answered a VPN or proxy handshake in one of our full checks within 30 days; lets fast and bulk checks, which never probe, carry it. Strong for a week, weaker after. |
| vpn_relay_recent | Was on a provider's published list in the last 30 days but not in the latest copy. Strong on hosting networks, weak and short-lived on home lines. |
| known_vpn_ip / known_vpn_cidr | On a curated list of VPN addresses or ranges. |
| vpn_aggregator_cidr | Inside a range shared by VPN and proxy services. |
| vpn_dense_block | Not itself on a server list, but its /24 holds 40 or more addresses that are (the detail names the main provider): almost always another server of the same fleet. Suspicious alone; with hosting evidence, vpn_likely. |
| cloudflare_warp / apple_private_relay | A WARP or iCloud Private Relay exit. |
| known_crawler | A search or AI crawler's published address (the detail names the bot). Weight 0; sets is_crawler. Crawlers run on hosting networks, so the verdict can still read suspicious. |
| hosting_stack_mismatch | Self-check only: on a datacenter network, the TCP connection was opened by a different operating system than the browser's, so a proxy server re-opened it. Sets is_proxy. |
| hosting_tunnel_mss | Self-check only: on a datacenter network, the browser's own device opened the connection with a tunnel's packet size (MSS 1400 or less), so it is inside a VPN tunnel that exits there. |
| dns_leak | Self-check only: on a datacenter connection, the browser's DNS lookup came from a consumer ISP in another country, so the visitor's own network shows through a VPN or proxy that does not carry DNS. Public resolvers never count. |
| dual_stack_leak | Self-check only: on a datacenter connection, the visitor's other address family (IPv6 for an IPv4 check, or the reverse) arrives from a consumer ISP in another country, so one family is relayed and the other leaks around it. Hosting networks never count. |
| satellite_network | The network is a satellite internet operator's. Weight 0; sets is_satellite. |
| secure_web_gateway | Egress of a corporate secure web gateway (Zscaler), from the operator's published ranges. Weight 0; proxy observations on the address are kept but weighted 0. |
| public_proxy_list | An open proxy seen recently. |
| residential_proxy_exit | Seen as the exit of a residential proxy network. |
| leased_isp_block | Inside an address block an IP lessor holds and a home ISP announces, the way ISP (static residential) proxies are set up. Suspicious on its own. |
| proxy_operator_network | The network is registered to a proxy company, so the address is one of its datacenter or ISP proxies (the detail names the company). Sets is_proxy. |
| active_probe_* | Answered a VPN or proxy handshake: OpenVPN, WireGuard, IKEv2, IKEv1/L2TP, SoftEther, SOCKS5, HTTP CONNECT or REALITY. The weight scales with how certain the handshake is. |
| vpn_asn / vpn_org_keyword | The network belongs to, or is named like, a VPN provider. |
| threat_intel_listed | Reported for attacks or abuse recently. |
| dc_ip / asn_cloud_provider | A datacenter, hosting or cloud network. |
| tz_mismatch / lang_mismatch | The browser's time zone or language doesn't fit the IP. Browser calls only. |

Other types can appear; treat an unknown type as information.

Support: admin@iplogs.com. Include the IP and the request_id.
