# PeeringDB Network Scraper — ASN & ISP Data (`compute-edge/peeringdb-network-scraper`) Actor

Extract network and ISP data from PeeringDB — the authoritative interconnection registry. Scrape ASN, peering policy, prefix counts, traffic volume, and contact details for thousands of networks worldwide.

- **URL**: https://apify.com/compute-edge/peeringdb-network-scraper.md
- **Developed by:** [Compute Edge](https://apify.com/compute-edge) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 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

## PeeringDB Network Scraper — ASN, ISP & Peering Data

Extract structured network data from **PeeringDB**, the world's authoritative internet interconnection registry. This Actor scrapes the public PeeringDB API to deliver clean, structured records on ISPs, content networks, NSPs, enterprise networks, and more — with no authentication required.

### What is PeeringDB?

[PeeringDB](https://www.peeringdb.com/) is the canonical global registry of networks that participate in internet peering and interconnection. It is maintained voluntarily by the networking community and lists over **35,000 registered Autonomous Systems (ASNs)** — from global hyperscalers like Google (AS15169) and Meta (AS32934), to regional ISPs, cable operators, universities, and enterprise networks.

Unlike commercial databases, PeeringDB data is **freely accessible** via its public API, is updated in near-real-time as networks update their own profiles, and represents the ground truth for network-level B2B intelligence.

#### Why scrape PeeringDB?

**Telecom and datacenter sales teams** use PeeringDB to build lead lists of ISPs and content networks — the exact organizations that buy transit bandwidth, rack space, and colocation services. A single deal in this vertical is worth tens of thousands of dollars.

**Network engineers** use PeeringDB to identify prospective peering partners — networks with open peering policies, matching traffic ratios, and presence at the same Internet Exchange Points (IXPs).

**B2B lead generation** targeting network operators, ISPs, CDN providers, and enterprise IT departments. PeeringDB provides verified ASN ownership, contact URLs, traffic profiles, and routing policy data that no generic directory offers.

**Research and intelligence** on the structure of the internet — which networks are growing (rising prefix counts), which have open vs. restrictive peering policies, which support IPv6.

#### Data you can extract

| Field | Description |
|---|---|
| `asn` | Autonomous System Number — globally unique network identifier |
| `name` | Network's registered name |
| `aka` | Common alternative name or abbreviation |
| `nameLong` | Full legal name of the network |
| `website` | Official website URL |
| `infoType` | Network category: NSP, Content, Cable/DSL/ISP, Enterprise, etc. |
| `infoScope` | Geographic scope: Global, Regional, Domestic, International |
| `infoTraffic` | Traffic volume tier (e.g., "100-1000Gbps") |
| `infoRatio` | Traffic ratio (Mostly Inbound, Balanced, Mostly Outbound) |
| `ipv4PrefixCount` | Number of IPv4 routes announced |
| `ipv6PrefixCount` | Number of IPv6 routes announced |
| `supportsIpv6` | Whether the network supports IPv6 |
| `policyGeneral` | Peering policy (Open, Selective, Restrictive, No) |
| `policyUrl` | Link to the network's peering policy page |
| `irrAsSet` | IRR AS-SET used for routing policy |
| `lookingGlass` | URL to the network's Looking Glass tool |
| `routeServer` | Route server contact info |
| `peeringdbUrl` | Direct link to the network's PeeringDB profile |
| `created` | Date the network was registered on PeeringDB |
| `updated` | Date the network profile was last updated |

### How to scrape PeeringDB network data

1. **Find this Actor** in the Apify Store — search "PeeringDB" or click the link above.
2. **Click "Try for free"** to open the Actor in your Apify Console.
3. **Configure your input** (all fields are optional for a full scrape):
   - Leave all fields empty to scrape all registered networks (35,000+).
   - Enter a specific **ASN** to look up a single network (e.g., `15169` for Google).
   - Use **Network Name Contains** to filter by name substring (e.g., `Comcast`).
   - Use **Network Type Filter** to restrict to a category (e.g., `Cable/DSL/ISP`).
   - Set **Maximum Results** to control how many records you want.
4. **Click "Start"** to begin the run.
5. **Download your results** as JSON, CSV, or XML from the Dataset tab when the run completes.

### Input example

```json
{
  "infoType": "Cable/DSL/ISP",
  "infoScope": "Regional",
  "maxResults": 500
}
````

### Output example

```json
{
  "asn": 7922,
  "name": "Comcast Cable Communications, LLC",
  "aka": "Comcast",
  "nameLong": "Comcast Cable Communications, LLC",
  "website": "https://www.comcast.com",
  "infoType": "Cable/DSL/ISP",
  "infoScope": "Domestic",
  "infoTraffic": ">100Gbps",
  "infoRatio": "Mostly Outbound",
  "ipv4PrefixCount": 6500,
  "ipv6PrefixCount": 400,
  "supportsIpv6": true,
  "policyGeneral": "Selective",
  "policyUrl": "https://www.comcast.com/peering",
  "irrAsSet": "AS-COMCAST",
  "lookingGlass": "https://lg.comcast.net",
  "routeServer": "",
  "peeringdbUrl": "https://www.peeringdb.com/net/3",
  "created": "2010-07-09T09:02:44Z",
  "updated": "2025-03-15T12:44:02Z"
}
```

### FAQ

**Q: Does scraping PeeringDB require authentication or API keys?**
A: No. PeeringDB's network listing API (`/api/net`) is publicly accessible without any credentials. This Actor makes no authenticated requests.

**Q: How many networks are on PeeringDB?**
A: As of mid-2026, PeeringDB has over 35,000 registered networks. A full scrape with no filters takes a few minutes and produces a comprehensive dataset of the global internet's routing participants.

**Q: How fresh is the data?**
A: PeeringDB is updated continuously by the network operators themselves. The `updated` field on each record shows when it was last modified. Most active networks update their profiles at least annually.

**Q: What is an ASN and why does it matter for B2B sales?**
A: An Autonomous System Number (ASN) is a globally unique identifier assigned to a network by a Regional Internet Registry (ARIN, RIPE, APNIC, etc.). Every ISP, CDN, cloud provider, and large enterprise operates at least one ASN. ASN ownership is publicly registered and legally tied to an organization, making it one of the most reliable B2B identifiers in the telecom and datacenter industries.

### Other Actors

Looking for more telecom and infrastructure data?

- **[FCC Broadband Scraper](https://apify.com/store)** — Scrape FCC broadband availability data by geography and provider.
- **[Hurricane Electric BGP Toolkit Scraper](https://apify.com/store)** — Extract BGP routing data and network topology information.
- Browse all [network and telecom scrapers on Apify Store](https://apify.com/store).

### Legal disclaimer

This Actor uses the publicly accessible PeeringDB REST API, which is designed for programmatic access. PeeringDB data is made available under the [PeeringDB Terms of Use](https://www.peeringdb.com/tos). All data extracted is publicly available without authentication. Use this Actor responsibly and in compliance with applicable laws and PeeringDB's terms of service. Do not use extracted data for spam, harassment, or any unlawful purpose. For questions, contact the Actor author.

# Actor input Schema

## `asn` (type: `string`):

Filter by a specific ASN number. Example: '15169' for Google, '32934' for Meta. Leave empty to fetch all networks.

## `nameContains` (type: `string`):

Filter networks whose name contains this string (case-insensitive partial match). Example: 'Comcast', 'Deutsche Telekom', 'Amazon'.

## `infoType` (type: `string`):

Filter by network type/category. Leave empty to fetch all types.

## `infoScope` (type: `string`):

Filter by geographic scope. Examples: 'Global', 'Regional', 'Domestic', 'International'. Leave empty for all.

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

Maximum number of network records to return. PeeringDB has ~35,000+ registered networks. Set to 0 for unlimited.

## Actor input object example

```json
{
  "asn": "",
  "nameContains": "",
  "infoType": "",
  "infoScope": "",
  "maxResults": 1000
}
```

# Actor output Schema

## `dataset` (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 = {
    "maxResults": 1000
};

// Run the Actor and wait for it to finish
const run = await client.actor("compute-edge/peeringdb-network-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 = { "maxResults": 1000 }

# Run the Actor and wait for it to finish
run = client.actor("compute-edge/peeringdb-network-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 '{
  "maxResults": 1000
}' |
apify call compute-edge/peeringdb-network-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "PeeringDB Network Scraper — ASN & ISP Data",
        "description": "Extract network and ISP data from PeeringDB — the authoritative interconnection registry. Scrape ASN, peering policy, prefix counts, traffic volume, and contact details for thousands of networks worldwide.",
        "version": "0.1",
        "x-build-id": "vBOkuFklCfYSgjveG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/compute-edge~peeringdb-network-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-compute-edge-peeringdb-network-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/compute-edge~peeringdb-network-scraper/runs": {
            "post": {
                "operationId": "runs-sync-compute-edge-peeringdb-network-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/compute-edge~peeringdb-network-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-compute-edge-peeringdb-network-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": {
                    "asn": {
                        "title": "ASN (Autonomous System Number)",
                        "type": "string",
                        "description": "Filter by a specific ASN number. Example: '15169' for Google, '32934' for Meta. Leave empty to fetch all networks.",
                        "default": ""
                    },
                    "nameContains": {
                        "title": "Network Name Contains",
                        "type": "string",
                        "description": "Filter networks whose name contains this string (case-insensitive partial match). Example: 'Comcast', 'Deutsche Telekom', 'Amazon'.",
                        "default": ""
                    },
                    "infoType": {
                        "title": "Network Type Filter",
                        "enum": [
                            "",
                            "NSP",
                            "Content",
                            "Cable/DSL/ISP",
                            "Enterprise",
                            "Educational/Research",
                            "Non-Profit",
                            "Route Server",
                            "Network Services",
                            "Route Collector",
                            "Government"
                        ],
                        "type": "string",
                        "description": "Filter by network type/category. Leave empty to fetch all types.",
                        "default": ""
                    },
                    "infoScope": {
                        "title": "Network Scope Filter",
                        "type": "string",
                        "description": "Filter by geographic scope. Examples: 'Global', 'Regional', 'Domestic', 'International'. Leave empty for all.",
                        "default": ""
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of network records to return. PeeringDB has ~35,000+ registered networks. Set to 0 for unlimited.",
                        "default": 1000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```