# IPv4 & IPv6 Bulk IP Geolocation: ASN, Country, City (`transparent_meteorite/ip-geolocation-bulk-lookup`) Actor

From $1.90 per 1K IPs. Look up thousands of IPv4 and IPv6 addresses at once: country, region, city, latitude, longitude, ASN and organization from the bundled DB-IP Lite database. No API key, no rate limit.

- **URL**: https://apify.com/transparent_meteorite/ip-geolocation-bulk-lookup.md
- **Developed by:** [Detroit Web Agent - Open Data](https://apify.com/transparent_meteorite) (community)
- **Categories:** Developer tools, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.17 / 1,000 ip locateds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## IPv4 & IPv6 Bulk IP Geolocation: ASN, Country, City

Turn a list of IP addresses into locations and network owners in seconds. Paste IPv4 and IPv6 addresses, or paste a whole web server log, and get one row per address with country, region, city, latitude, longitude, ASN, organization and the announced network range. The lookup runs inside the Actor against the bundled DB-IP Lite databases, so there is no API key, no per-request rate limit and no third party that ever sees your addresses.

Typical jobs: enrich access logs, check where login attempts come from, flag traffic from unexpected countries, group a customer list by country, or add the ASN and hosting provider to a block list.

### Run in 30 seconds

1. Open the **Input** tab. The prefilled list of 30 public IPv4 and IPv6 addresses is a ready-to-run test.
2. Click **Start**. The first dataset is normally ready in about 5 seconds.
3. Open the **Locations** table in the Output tab, or download the dataset as JSON, CSV, Excel or HTML.
4. Replace the list with your own addresses, or paste raw log text into **Paste text**.

### What you get

For every address the Actor reads two offline databases that ship inside the Actor image: DB-IP Lite City (country, region, city, coordinates) and DB-IP Lite ASN (autonomous system number and organization). Lookups are in-memory, so a list of 100,000 addresses is processed in a few seconds and the run time is dominated by Apify startup.

| Feature | Detail |
|---|---|
| Address types | IPv4 and IPv6 |
| Input | A list, or any pasted text (logs, CSV cells, headers): addresses are extracted automatically |
| Cleaning | Ports, brackets and CIDR suffixes are stripped; duplicates are removed (optional) |
| Reserved ranges | Private, loopback, link-local, multicast and documentation addresses return status `reserved` and are free |
| Bad input | Invalid text returns status `invalid` and is free |
| Network keys | ASN number, organization and the announced CIDR range |
| Keys and limits | No account, no API key, no daily quota |

### Pricing

| | |
|---|---|
| Price per 1,000 located IPs (Free plan) | $1.90 |
| Start fee | $0.00005 per run |
| Plan discounts | Bronze $1.77, Silver $1.52, Gold and above $1.17 |
| Charged for | only addresses with status `ok` |
| Not charged | reserved, invalid, unknown and duplicate addresses |

### Input

- **IP addresses**: one IPv4 or IPv6 address per line. Ports and CIDR suffixes are stripped.
- **Paste text (optional)**: any text containing addresses, such as nginx or Apache logs, firewall exports or a CSV column.
- **Remove duplicate addresses**: on by default; each distinct address is looked up and billed once.
- **Max addresses**: cap for the run (default 1,000,000).

### Example input

```json
{
  "ips": ["8.8.8.8", "1.1.1.1", "2606:4700:4700::1111", "81.2.69.142"],
  "maxItems": 1000
}
```

### Output sample

```json
{
  "ip": "8.8.8.8",
  "ipVersion": 4,
  "status": "ok",
  "country": "United States",
  "countryCode": "US",
  "continent": "North America",
  "continentCode": "NA",
  "region": "California",
  "city": "Mountain View",
  "lat": 37.422,
  "lon": -122.085,
  "isEuMember": false,
  "asn": 15169,
  "asnLabel": "AS15169",
  "org": "Google LLC",
  "network": "8.8.8.0/24",
  "dataRelease": "2026-11",
  "attribution": "IP Geolocation by DB-IP (https://db-ip.com), CC BY 4.0",
  "lookupUrl": "https://db-ip.com/8.8.8.8",
  "checkedAt": "2026-11-10T20:00:00.000Z"
}
```

### Output fields

Every row has these fields. Rows that are not located keep the same keys with empty values and a `note`.

| Field | Type | Description |
|---|---|---|
| `ip` | string | The IP address that was looked up, normalized (ports, brackets and CIDR suffixes removed) |
| `ipVersion` | integer | IP version: 4 or 6 |
| `status` | string | ok when the address was located; reserved (private, loopback, documentation), invalid or not_found are returned free of charge |
| `country` | string | Country name in English |
| `countryCode` | string | ISO 3166-1 alpha-2 country code, for example US or DE |
| `continent` | string | Continent name in English |
| `continentCode` | string | Two-letter continent code: AF, AN, AS, EU, NA, OC or SA |
| `region` | string | State, province or first-level administrative region |
| `city` | string | City name in English. City level is approximate: it often points to the network operator location |
| `lat` | number | Latitude in decimal degrees (approximate, city level) |
| `lon` | number | Longitude in decimal degrees (approximate, city level) |
| `isEuMember` | boolean | true when the country is a European Union member state |
| `asn` | integer | Autonomous system number that announces the address, for example 15169 |
| `asnLabel` | string | Autonomous system number in AS15169 form |
| `org` | string | Organization that owns the autonomous system, for example Google LLC |
| `network` | string | Announced network range (CIDR) that contains the address |
| `dataRelease` | string | Month of the DB-IP Lite release used for the lookup, for example 2026-11 |
| `attribution` | string | Required attribution for the DB-IP Lite data (CC BY 4.0) |
| `lookupUrl` | string | Link to the DB-IP public page for this address, to spot-check a result by hand |
| `checkedAt` | string | ISO timestamp of the run that produced the row |
| `note` | string | Why a row is not ok (reserved, invalid or unknown address); absent on located rows |

### Use cases

- Enrich web server and application logs with country, city and network owner before loading them into a spreadsheet or warehouse.
- Fraud and security review: group sign-ins, checkouts or failed logins by country and ASN to spot proxies, hosting providers and unusual regions.
- Marketing and analytics: map a visitor or subscriber IP list to countries and cities without sending addresses to a paid API.
- Build country and ASN block lists or allow lists from a list of offending addresses.
- Add a location and ISP column to a CRM export or support-ticket dump.
- Data cleaning: validate a column of IPs and separate valid public, reserved and invalid values in one pass.

### Run it from code

**API (returns the rows directly):**

```bash
curl -X POST "https://api.apify.com/v2/acts/transparent_meteorite~ip-geolocation-bulk-lookup/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"ips":["8.8.8.8","1.1.1.1","2606:4700:4700::1111"]}'
```

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("transparent_meteorite/ip-geolocation-bulk-lookup").call(
    run_input={"ips": ["8.8.8.8", "1.1.1.1", "81.2.69.142"]}
)
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["ip"], row["countryCode"], row["city"], row["asnLabel"], row["org"])
```

**MCP (Claude, Cursor and other agents):** add the Apify MCP server and enable this Actor.

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=transparent_meteorite/ip-geolocation-bulk-lookup",
      "headers": { "Authorization": "Bearer YOUR_APIFY_TOKEN" }
    }
  }
}
```

Then ask your agent: "Where are these IP addresses located and which networks own them?" and paste the list.

### Integrations and scheduling

| Tool | How to use it |
|---|---|
| n8n | Add the **Apify** node, choose **Run Actor**, set the Actor to `transparent_meteorite/ip-geolocation-bulk-lookup`, pass `{"ips": ["={{ $json.ip }}"]}` (or an array built with a Code node), then add **Get Dataset Items** and route rows by `countryCode` or `asn` |
| Make and Zapier | Use the Apify app: Run Actor, then read the dataset items |
| Google Sheets | Run from the Apify integration and append the dataset rows |
| Webhooks | Call a URL when the run succeeds to push the results into your own system |

Every run's dataset can also be downloaded as JSON, CSV, Excel, XML or HTML.

### Search terms this Actor covers

bulk IP geolocation, IP to country lookup, IP address to city, IP to ASN lookup, bulk ASN lookup, IP location finder, geolocate a list of IP addresses, IPv6 geolocation, IP address lookup API alternative, enrich IP logs with country, offline IP geolocation database, IP to organization lookup, GeoIP batch lookup, find ISP of IP address, IP address CSV geolocation, DB-IP lite lookup.

### Limits

- IP geolocation is approximate. Country is usually right; region and city are a best estimate and often point to the network operator or an exit node, not the end user. Mobile, VPN, proxy and satellite traffic can be far from the stated place.
- The databases are the free DB-IP Lite editions, refreshed monthly with each Actor build. The release month is in every row (`dataRelease`).
- There are no hosting, VPN, proxy or threat flags and no timezone or postal code in the lite data.
- Reserved addresses (private, loopback, documentation) have no public location and are returned as `reserved`.

### Fair use and data

The lookup uses the free DB-IP Lite databases (CC BY 4.0). Attribution is required when you publish or redistribute results: **IP Geolocation by [DB-IP](https://db-ip.com)**. The Actor makes no network requests for the lookups, so your addresses stay inside the run. IP addresses can be personal data in some jurisdictions; check the rules that apply to your logs and your use before you store or share enriched results.

### FAQ

**Do I need an API key or a DB-IP account?** No. The database is bundled in the Actor.

**How fast is it?** Lookups are in memory. 100,000 addresses are located in seconds; a small list finishes in about 5 seconds including startup.

**Is IPv6 supported?** Yes, IPv4 and IPv6 are both located, and mixed lists work.

**How accurate is the city?** City level is approximate. Treat country as reliable, region as likely and city as a guide, as with any IP geolocation database.

**What happens with private or invalid addresses?** They come back as `reserved` or `invalid` with a note and are never charged.

**Can I paste a log file?** Yes. Paste it into Paste text and every IPv4 and IPv6 address is extracted and looked up once.

**How current is the data?** Each Actor build bundles the newest monthly DB-IP Lite release; `dataRelease` shows which one a row used.

### Related Actors

- [Domain Intelligence Lookup](https://apify.com/transparent_meteorite/domain-intelligence-lookup): registration, DNS and hosting facts for a list of domains. Pair it with IP locations of the servers.
- [SSL Certificate & Subdomain Finder](https://apify.com/transparent_meteorite/ssl-certificate-subdomain-finder): find subdomains, then locate the addresses they point to.
- [Newly Registered Domains Feed](https://apify.com/transparent_meteorite/newly-registered-domains-feed): fresh domains to enrich with hosting country and ASN.

### Support

Found a bug or need a field? Open an issue on the Issues tab with the run URL and we will reply there.

### Changelog

- 0.1: first release. Bulk IPv4 and IPv6 lookup with country, region, city, coordinates, ASN, organization and network range from DB-IP Lite.

# Actor input Schema

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

IPv4 or IPv6 addresses, one per line. Ports (\[::1]:443, 1.2.3.4:80) and CIDR suffixes are stripped. Leave empty and use Paste text to extract addresses from logs.

## `ipsText` (type: `string`):

Paste any text such as web server logs, a CSV column or an email header block. Every IPv4 and IPv6 address in it is extracted and looked up.

## `removeDuplicates` (type: `boolean`):

Look up each distinct address once. Turn off to return one row per input line.

## `maxItems` (type: `integer`):

Upper limit of addresses processed in this run. You are charged only for addresses that resolve (status ok).

## Actor input object example

```json
{
  "ips": [
    "8.8.8.8",
    "1.1.1.1",
    "9.9.9.9",
    "208.67.222.222",
    "4.2.2.2",
    "151.101.1.69",
    "104.16.132.229",
    "13.107.42.14",
    "17.253.144.10",
    "140.82.112.3",
    "31.13.71.36",
    "52.95.110.1",
    "142.250.80.46",
    "93.184.216.34",
    "81.2.69.142",
    "193.0.14.129",
    "199.7.83.42",
    "200.160.2.3",
    "202.12.27.33",
    "185.199.108.153",
    "45.33.32.156",
    "23.220.75.245",
    "69.171.250.35",
    "2001:4860:4860::8888",
    "2606:4700:4700::1111",
    "2620:fe::fe",
    "2a00:1450:4001:81b::200e",
    "2a03:2880:f12f:83:face:b00c:0:25de",
    "2001:500:2f::f",
    "195.20.0.1"
  ],
  "removeDuplicates": true,
  "maxItems": 1000
}
```

# Actor output Schema

## `locations` (type: `string`):

No description

# 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",
        "9.9.9.9",
        "208.67.222.222",
        "4.2.2.2",
        "151.101.1.69",
        "104.16.132.229",
        "13.107.42.14",
        "17.253.144.10",
        "140.82.112.3",
        "31.13.71.36",
        "52.95.110.1",
        "142.250.80.46",
        "93.184.216.34",
        "81.2.69.142",
        "193.0.14.129",
        "199.7.83.42",
        "200.160.2.3",
        "202.12.27.33",
        "185.199.108.153",
        "45.33.32.156",
        "23.220.75.245",
        "69.171.250.35",
        "2001:4860:4860::8888",
        "2606:4700:4700::1111",
        "2620:fe::fe",
        "2a00:1450:4001:81b::200e",
        "2a03:2880:f12f:83:face:b00c:0:25de",
        "2001:500:2f::f",
        "195.20.0.1"
    ],
    "maxItems": 1000
};

// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/ip-geolocation-bulk-lookup").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",
        "9.9.9.9",
        "208.67.222.222",
        "4.2.2.2",
        "151.101.1.69",
        "104.16.132.229",
        "13.107.42.14",
        "17.253.144.10",
        "140.82.112.3",
        "31.13.71.36",
        "52.95.110.1",
        "142.250.80.46",
        "93.184.216.34",
        "81.2.69.142",
        "193.0.14.129",
        "199.7.83.42",
        "200.160.2.3",
        "202.12.27.33",
        "185.199.108.153",
        "45.33.32.156",
        "23.220.75.245",
        "69.171.250.35",
        "2001:4860:4860::8888",
        "2606:4700:4700::1111",
        "2620:fe::fe",
        "2a00:1450:4001:81b::200e",
        "2a03:2880:f12f:83:face:b00c:0:25de",
        "2001:500:2f::f",
        "195.20.0.1",
    ],
    "maxItems": 1000,
}

# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/ip-geolocation-bulk-lookup").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",
    "9.9.9.9",
    "208.67.222.222",
    "4.2.2.2",
    "151.101.1.69",
    "104.16.132.229",
    "13.107.42.14",
    "17.253.144.10",
    "140.82.112.3",
    "31.13.71.36",
    "52.95.110.1",
    "142.250.80.46",
    "93.184.216.34",
    "81.2.69.142",
    "193.0.14.129",
    "199.7.83.42",
    "200.160.2.3",
    "202.12.27.33",
    "185.199.108.153",
    "45.33.32.156",
    "23.220.75.245",
    "69.171.250.35",
    "2001:4860:4860::8888",
    "2606:4700:4700::1111",
    "2620:fe::fe",
    "2a00:1450:4001:81b::200e",
    "2a03:2880:f12f:83:face:b00c:0:25de",
    "2001:500:2f::f",
    "195.20.0.1"
  ],
  "maxItems": 1000
}' |
apify call transparent_meteorite/ip-geolocation-bulk-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,transparent_meteorite/ip-geolocation-bulk-lookup"
        }
    }
}
```

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/WslPckclyhgWIbDVu/builds/jb1yiHTV0GI4ndI1V/openapi.json
