# IP Geolocation Scraper - Country, City & ISP (`benthepythondev/ip-geolocation-scraper`) Actor

Look up the geographic location and network owner for any IP address: country, region, city, zip, latitude/longitude, timezone, ISP, organization and AS number. Fast batch lookups via the public ip-api.com service, no key.

- **URL**: https://apify.com/benthepythondev/ip-geolocation-scraper.md
- **Developed by:** [ben](https://apify.com/benthepythondev) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## 🌐 IP Geolocation Scraper — Country, City, ISP & ASN

Look up the geographic location and network owner behind **any IP address** — country, region/state, city, ZIP, latitude/longitude, timezone, ISP, organization and AS (autonomous system) number — and get it all back as clean, structured rows. Feed it a single IP or a list of thousands: addresses are resolved in fast batches so bulk enrichment finishes in seconds. Both **IPv4 and IPv6** are supported.

The actor is powered by the public **ip-api.com** geolocation service, so it is fast and reliable with no browser, no login and no API key to manage. Export to JSON/CSV/Excel, run on a schedule, call via API, or connect to Make, Zapier or n8n.

### 🔎 What is the IP Geolocation Scraper?

Every request to your website, app or API arrives with an IP address — but on its own an IP is just a number. This actor turns each IP into human-readable intelligence: where in the world it resolves to, which internet service provider or hosting company owns it, and which autonomous system it belongs to. That context powers analytics dashboards, fraud and abuse detection, content personalization and log enrichment.

Pass a list of IP addresses and the actor looks them up in batches of up to 100 at a time, returning one tidy row per IP with location and network fields. Because it calls a purpose-built geolocation API rather than scraping pages, it is quick, consistent and never blocked — perfect for enriching server logs, sign-up records or lead lists at scale.

#### What data does it extract?

- **IP** — the address that was looked up
- **Status** — `success` or `fail` per lookup
- **Country** and **country_code** (ISO alpha-2)
- **Region** (state/province name) and **region_code**
- **City** and **ZIP / postal code**
- **Latitude (lat)** and **longitude (lon)**
- **Timezone** (IANA, e.g. `America/New_York`)
- **ISP** — internet service provider
- **Org** — the organization that owns the IP
- **AS name** — autonomous system number + name (e.g. `AS15169 Google LLC`)
- **Message** — reason string when a lookup fails (e.g. invalid or reserved range)

### ⬇️ Input

| Field | Type | Description |
|-------|------|-------------|
| `ips` | array | IP addresses to look up, e.g. `8.8.8.8`. IPv4 and IPv6 both supported. Add as many as you like — they are processed in batches. |

#### Example input

```json
{
  "ips": ["8.8.8.8", "1.1.1.1", "208.67.222.222", "2606:4700:4700::1111"]
}
````

### ⬆️ Output

One clean row per IP (view as a **table**, or export **JSON / CSV / Excel**):

```json
{
  "ip": "8.8.8.8",
  "status": "success",
  "country": "United States",
  "country_code": "US",
  "region": "Virginia",
  "region_code": "VA",
  "city": "Ashburn",
  "zip": "20149",
  "lat": 39.03,
  "lon": -77.5,
  "timezone": "America/New_York",
  "isp": "Google LLC",
  "org": "Google Public DNS",
  "as_name": "AS15169 Google LLC",
  "message": null
}
```

### 💡 Use cases

- 📊 **Analytics & reporting** — enrich visitor logs, sign-ups and events with country, city, timezone and ISP for geographic breakdowns.
- 🛡️ **Fraud & risk scoring** — flag logins from unexpected countries, spot hosting/VPN/datacenter networks and screen suspicious sign-ups.
- 🌍 **Personalization & compliance** — tailor content, currency and language by region, and support geo-based access or data-residency rules.
- 🤖 **Log enrichment & automation** — resolve raw IPs inside Make/Zapier/n8n workflows, SIEM pipelines or your own data warehouse.

### ❓ FAQ

**How do I look up an IP address location?** Add one or more IPs to the `ips` field and Run. Each returns country, region, city, ZIP, coordinates, timezone, ISP, org and AS number.

**Do I need an API key or login?** No. It uses the public ip-api.com service — just provide the IP addresses.

**Does it support IPv4 and IPv6?** Yes, both address families are supported in the same run.

**Can I look up many IPs at once?** Yes — bulk lookups are processed in batches of up to 100 IPs, so thousands of addresses enrich quickly.

**What network data do I get?** The ISP, the owning organization, and the AS (autonomous system) number and name — useful for identifying hosting, cloud and datacenter ranges.

**How accurate is the location?** Country-level accuracy is very high; city-level is approximate and can be off for mobile, corporate, VPN and cloud IPs, which is normal for all IP geolocation.

**What happens with an invalid or private IP?** The row's `status` is `fail` and the `message` field explains why (e.g. reserved or private range).

**Can I run it on a schedule or via API?** Yes — schedule recurring runs on Apify, call it via the API/SDK, or wire it into Make, Zapier or n8n.

**How does pricing work?** Pay per IP returned — no subscription, no fixed monthly fee.

**Is it legal?** It uses the public ip-api.com service and returns network-level, non-personal location data. Use it responsibly and in line with ip-api.com's terms and applicable privacy laws (including GDPR where an IP is treated as personal data).

### 🔗 You might also like

- **[Domain WHOIS / RDAP Lookup](https://apify.com/benthepythondev/rdap-domain-lookup)** — domain registration, registrar & dates.
- **[Geocoder (OpenStreetMap)](https://apify.com/benthepythondev/geocoder-openstreetmap)** — convert addresses ↔ coordinates.
- **[Website Contact Extractor](https://apify.com/benthepythondev/website-contact-extractor)** — emails, phones & socials from any site.
- **[Google Maps Scraper](https://apify.com/benthepythondev/google-maps-scraper)** — local business data & leads.

***

**Keywords:** ip geolocation, ip lookup, geoip, ip to location, ip api, isp lookup, asn lookup, ip address data, log enrichment, fraud detection, ip intelligence, geolocation api, bulk ip lookup, network owner, ipv4 ipv6 lookup, ip to country, ip to city, ip geolocation scraper, visitor geolocation, ip enrichment

# Actor input Schema

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

IP addresses to look up, e.g. '8.8.8.8'. IPv4 and IPv6 supported.

## Actor input object example

```json
{
  "ips": [
    "8.8.8.8"
  ]
}
```

# 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/ip-geolocation-scraper").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"] }

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/ip-geolocation-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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"
  ]
}' |
apify call benthepythondev/ip-geolocation-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=benthepythondev/ip-geolocation-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "IP Geolocation Scraper - Country, City & ISP",
        "description": "Look up the geographic location and network owner for any IP address: country, region, city, zip, latitude/longitude, timezone, ISP, organization and AS number. Fast batch lookups via the public ip-api.com service, no key.",
        "version": "1.0",
        "x-build-id": "vViPcJz9lx97fVyrz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~ip-geolocation-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-ip-geolocation-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/benthepythondev~ip-geolocation-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-ip-geolocation-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/benthepythondev~ip-geolocation-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-ip-geolocation-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "ips": {
                        "title": "IP addresses",
                        "type": "array",
                        "description": "IP addresses to look up, e.g. '8.8.8.8'. IPv4 and IPv6 supported.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```