# Internet Infrastructure Data: Networks, IP Ranges, Peering (`scrapemint/internet-infrastructure-data`) Actor

Keyless global routing data. Give a network number, an IP address or a country code and get the holder, every IP range they announce with its size, the networks they peer with marked upstream or downstream, and how long they have been visible in the global routing table.

- **URL**: https://apify.com/scrapemint/internet-infrastructure-data.md
- **Developed by:** [Ken M](https://apify.com/scrapemint) (community)
- **Categories:** Developer tools, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 network rows

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Internet Infrastructure Data: Networks, IP Ranges, Peering

Who actually owns and routes a piece of the internet. Give a network number, an IP address or a country code, and get the holder, the address space they announce, the networks they connect to, and how long they have been visible in the global routing table. No key, no login, no proxy.

### Four modes

**Network** returns one row per network: holder, registry block, IPv4 prefixes and addresses announced, IPv6 prefixes, observed neighbours, first and last seen in routing, and routing visibility. An IP address is resolved to the network announcing it, and the covering prefix is reported.

**Prefixes** returns every IP range a network announces, with its address count and the dates it has been seen.

**Peers** returns each neighbouring network, marked `upstream`, `downstream` or `uncertain`, with the number of peering sessions observed over IPv4 and IPv6.

**Country** returns every network registered to a two letter country code, with the country's total networks and address blocks.

### Example input

```json
{
  "mode": "network",
  "resources": ["AS15169", "8.8.8.8"]
}
```

Who buys transit from a network:

```json
{
  "mode": "peers",
  "resources": ["AS15169"],
  "peerType": "downstream"
}
```

### Three things worth knowing

**Address counts are IPv4 only, deliberately.** A v4 prefix covers a countable number of addresses, so a /24 is 256 and a network's total is a meaningful figure. A v6 /32 covers about 79 octillion addresses, so adding the two together produces a number that means nothing at all. IPv6 is therefore reported as a count of prefixes, which is what the source publishes and what engineers actually compare.

**Upstream and downstream are inferred, and often uncertain.** The source labels relationships left and right, which this actor translates to upstream, meaning they provide transit, and downstream, meaning they buy it. For Google's network, 140 neighbours read as upstream, 20 as downstream and 174 as uncertain, and that last group is honestly labelled rather than guessed at.

**A withdrawn IP range keeps its record.** Ranges that stopped being announced still appear in the source with a timeline showing when they ended. They are excluded by default and, when included, marked with `currentlyAnnounced` false rather than silently mixed in with live routes.

### Speed and cost

Holder names cost one extra request per network, so a large country run is much faster with `includeHolderNames` off. Lookups are cached within a run, so a network that appears repeatedly is only resolved once.

Pay per row, `$0.004`. The first 2 rows of every run are free. Unreadable inputs, networks with no routing data and empty countries return a free note and are never charged.

### Attribution

Routing data from RIPE NCC.

### Related actors

- **DNS Records Checker** and **Domain Intelligence** for the naming and registry layers
- **SSL Subdomain Finder** for certificate transparency records
- **Business Locations Worldwide** and **Company Data Worldwide** for the organisations behind the networks

# Actor input Schema

## `mode` (type: `string`):

network = holder, announced space and peer counts. prefixes = every IP range announced. peers = neighbouring networks marked upstream or downstream. country = every network registered to a country.

## `resources` (type: `array`):

Network numbers such as AS15169 or 15169, or IP addresses such as 8.8.8.8, which are resolved to the network announcing them.

## `country` (type: `string`):

Two letter code such as KE, DE, BR or IN.

## `peerType` (type: `string`):

Upstream means they provide transit, downstream means they buy it. Uncertain is where the direction cannot be inferred.

## `onlyCurrentPrefixes` (type: `boolean`):

Prefixes mode. Ranges that have stopped being announced are kept out by default, and marked rather than dropped when included.

## `includeHolderNames` (type: `boolean`):

Adds the organisation behind each network. Costs one extra request per network, so turning it off makes large country runs much faster.

## `maxResults` (type: `integer`):

Cap on rows returned. Controls total cost and run time.

## Actor input object example

```json
{
  "mode": "network",
  "resources": [
    "AS15169",
    "8.8.8.8"
  ],
  "country": "",
  "peerType": "all",
  "onlyCurrentPrefixes": true,
  "includeHolderNames": true,
  "maxResults": 100
}
```

# 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 = {
    "resources": [
        "AS15169",
        "8.8.8.8"
    ],
    "onlyCurrentPrefixes": true,
    "includeHolderNames": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemint/internet-infrastructure-data").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 = {
    "resources": [
        "AS15169",
        "8.8.8.8",
    ],
    "onlyCurrentPrefixes": True,
    "includeHolderNames": True,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapemint/internet-infrastructure-data").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 '{
  "resources": [
    "AS15169",
    "8.8.8.8"
  ],
  "onlyCurrentPrefixes": true,
  "includeHolderNames": true
}' |
apify call scrapemint/internet-infrastructure-data --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapemint/internet-infrastructure-data"
        }
    }
}

```

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/m0Jf9bsW1N3FH2rks/builds/dbjarN6tdGbVlyOSz/openapi.json