Batch IP Lookup API: Look Up 1,000 IP Addresses in One Request

{"ips": ["8.8.8.8", "80.110.0.1", "2001:4860:4860::8888"]}

{
  "data": {
    "8.8.8.8": {
      "ip": "8.8.8.8",
      "location": {
        "country": {
          "alpha2": "US"
        }
      }
    }
  },
  "errors": {
    "not-an-ip": "Not a valid IP address."
  }
}

curl -X POST "https://api.iplookupapi.com/v1/batch?fields=ip,location.country.alpha2,timezone.id" \
  -H "apikey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"ips": ["8.8.8.8", "80.110.0.1", "2001:4860:4860::8888"]}'

curl "https://api.iplookupapi.com/v1/batch?ips=8.8.8.8,80.110.0.1&fields=ip,location.country.alpha2" \
  -H "apikey: YOUR_API_KEY"

const API_KEY = process.env.IPLOOKUPAPI_KEY;
const ENDPOINT = "https://api.iplookupapi.com/v1/batch?fields=ip,location.country.alpha2,timezone.id";

async function batchLookup(ips) {
  const res = await fetch(ENDPOINT, {
    method: "POST",
    headers: { apikey: API_KEY, "Content-Type": "application/json" },
    body: JSON.stringify({ ips }),
  });
  if (!res.ok) {
    throw new Error(`HTTP ${res.status}: ${await res.text()}`);
  }
  return res.json();
}

batchLookup(["8.8.8.8", "80.110.0.1", "2001:4860:4860::8888"])
  .then((body) => {
    for (const [ip, info] of Object.entries(body.data)) {
      console.log(ip, info.location?.country?.alpha2 ?? "-", info.timezone?.id ?? "-");
    }
    if (body.errors) console.log("Not looked up:", body.errors);
  })
  .catch((err) => console.error(err.message));

import os

import requests

resp = requests.post(
    "https://api.iplookupapi.com/v1/batch",
    params={"fields": "ip,location.country.alpha2,connection.asn"},
    headers={"apikey": os.environ["IPLOOKUPAPI_KEY"]},
    json={"ips": ["8.8.8.8", "80.110.0.1", "2001:4860:4860::8888"]},
    timeout=60,
)
resp.raise_for_status()
body = resp.json()

for ip, info in body["data"].items():
    country = ((info.get("location") or {}).get("country") or {}).get("alpha2")
    asn = (info.get("connection") or {}).get("asn")
    print(ip, country, asn)

print("Billed requests:", resp.headers.get("X-Cost"))

<?php
$apiKey = getenv('IPLOOKUPAPI_KEY');
$payload = json_encode(['ips' => ['8.8.8.8', '80.110.0.1', '2001:4860:4860::8888']]);

$ch = curl_init('https://api.iplookupapi.com/v1/batch?fields=ip,location.country.alpha2');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_POSTFIELDS => $payload,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 60,
    CURLOPT_HTTPHEADER => [
        'apikey: ' . $apiKey,
        'Content-Type: application/json',
    ],
]);

$response = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);

if ($response === false || $status !== 200) {
    fwrite(STDERR, "Request failed (HTTP $status): " . curl_error($ch) . PHP_EOL);
    exit(1);
}

$body = json_decode($response, true);
foreach ($body['data'] as $ip => $info) {
    echo $ip . ' ' . ($info['location']['country']['alpha2'] ?? '-') . PHP_EOL;
}

import csv
import ipaddress
import os
import random
import sys
import time

import requests

API_URL = "https://api.iplookupapi.com/v1/batch"
API_KEY = os.environ["IPLOOKUPAPI_KEY"]
CHUNK_SIZE = 1000
MAX_RETRIES = 6
FIELDS = ",".join([
    "ip", "type", "range_type.type",
    "location.country.alpha2", "location.region.name", "location.city.name",
    "location.latitude", "location.longitude",
    "timezone.id", "connection.asn", "connection.isp",
])
COLUMNS = ["ip", "status", "type", "range_type", "country", "region", "city",
           "latitude", "longitude", "timezone", "asn", "isp"]


def read_ips(path):
    """Return (valid, invalid): valid IPs deduped in input order, invalid lines."""
    valid, invalid = {}, []
    with open(path, newline="", encoding="utf-8") as f:
        for row in csv.reader(f):
            if not row or not row[0].strip():
                continue
            raw = row[0].strip()
            if raw.lower() == "ip":  # skip a header row
                continue
            try:
                valid[str(ipaddress.ip_address(raw))] = None
            except ValueError:
                invalid.append(raw)
    return list(valid), invalid


def lookup_chunk(ips):
    """POST one chunk; retry on rate limits and server errors."""
    for attempt in range(MAX_RETRIES):
        resp = requests.post(
            API_URL,
            params={"fields": FIELDS},
            headers={"apikey": API_KEY},
            json={"ips": ips},
            timeout=120,
        )
        if resp.status_code == 200:
            return resp.json()
        if resp.status_code == 429:
            try:
                body = resp.json()
            except ValueError:
                body = {}
            if "quota" in body:  # monthly quota too small: retrying will not help
                needed = body["quota"].get("required", len(ips))
                sys.exit(f"Quota exceeded: this chunk needs {needed} requests. "
                         "Upgrade your plan or wait for the quota reset.")
        elif resp.status_code < 500:
            sys.exit(f"HTTP {resp.status_code}: {resp.text}")
        wait = min(60, 2 ** attempt) + random.uniform(0, 1)
        print(f"HTTP {resp.status_code}, retrying in {wait:.1f}s", file=sys.stderr)
        time.sleep(wait)
    sys.exit("Giving up after repeated errors.")


def get(obj, path):
    for key in path.split("."):
        if not isinstance(obj, dict):
            return None
        obj = obj.get(key)
    return obj


def to_row(ip, info):
    return {
        "ip": ip, "status": "ok", "type": info.get("type"),
        "range_type": get(info, "range_type.type"),
        "country": get(info, "location.country.alpha2"),
        "region": get(info, "location.region.name"),
        "city": get(info, "location.city.name"),
        "latitude": get(info, "location.latitude"),
        "longitude": get(info, "location.longitude"),
        "timezone": get(info, "timezone.id"),
        "asn": get(info, "connection.asn"),
        "isp": get(info, "connection.isp"),
    }


def main(src, dst):
    ips, invalid = read_ips(src)
    print(f"{len(ips)} unique valid IPs, {len(invalid)} invalid lines", file=sys.stderr)
    with open(dst, "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=COLUMNS)
        writer.writeheader()
        for raw in invalid:
            writer.writerow({"ip": raw, "status": "invalid"})
        for start in range(0, len(ips), CHUNK_SIZE):
            chunk = ips[start:start + CHUNK_SIZE]
            body = lookup_chunk(chunk)
            data = body.get("data") or {}
            errors = body.get("errors") or {}
            for ip in chunk:
                if ip in data:
                    writer.writerow(to_row(ip, data[ip]))
                elif ip in errors:
                    writer.writerow({"ip": ip, "status": f"error: {errors[ip]}"})
                else:
                    writer.writerow({"ip": ip, "status": "no data"})
            print(f"Done {start + len(chunk)} of {len(ips)}", file=sys.stderr)


if __name__ == "__main__":
    if len(sys.argv) != 3:
        sys.exit("Usage: python batch_lookup.py <input.txt|csv> <output.csv>")
    main(sys.argv[1], sys.argv[2])