# Colocation & Data Center Scraper (`crawlerbros/colocation-data-center-scraper`) Actor

Scrape colocation and data center facilities from datacenters.com. Browse by country, state, city, or provider, or fetch specific facilities by URL. Get address, coordinates, certifications, power/space specs, provider contact info, and media.

- **URL**: https://apify.com/crawlerbros/colocation-data-center-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Lead generation, MCP servers
- **Stats:** 0 total users, 0 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 and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Colocation & Data Center Scraper

Scrape colocation and data center facility listings from [datacenters.com](https://www.datacenters.com) — a global directory of 11,000+ data centers across 45+ countries. Browse facilities by country, state/region, city, or provider, or pull full details for specific facilities by URL. No login, API key, or cookies required.

### What this actor does

- **Five browse modes:** by country, by state/region, by city, by provider/operator, or by direct facility URL
- **Rich facility details:** address, GPS coordinates, provider contact info, certifications, power capacity, colocation space, nearby airport distance, features, images, videos, and brochures
- **Provider company profile:** founding year, employee-count range, and headquarters address for the facility's operator
- **Global coverage:** 45+ countries including the United States, Germany, United Kingdom, China, India, Japan, Australia, Brazil, and more
- **Filter by facility type, certification, or minimum power capacity**
- **Empty fields are always omitted** — every record only contains data that was actually found

### Output per facility

- `facilityName`, `facilityId`, `facilitySlug`
- `providerName`, `providerSlug`, `providerLogoUrl`, `providerPhone`
- `providerYearFounded`, `providerEmployeeRange`, `providerHeadquartersAddress` — provider-company profile info (fetched once per provider, not per facility)
- `fullAddress`, `streetAddress`, `city`, `state`, `country`, `zip`, `continent`
- `latitude`, `longitude`
- `summary`, `description`
- `totalBuildingSqft`, `colocationSqft` — facility size
- `powerDensityKwPerRack`, `totalPowerMw` — power capacity
- `nearestAirportMiles`
- `certifications[]` / `certificationAbbreviations[]` — e.g. SOC 2 Type 2, ISO 27001, PCI DSS, HIPAA
- `facilityTypes[]` — e.g. Colocation, IaaS, Internet Exchange
- `features[]` — named facility highlights with descriptions
- `imageUrls[]`, `videoUrls[]`, `brochures[]`
- `sourceUrl` — canonical facility page
- `recordType`, `scrapedAt`

Grid-summary-only records (when `fetchFullDetails` is disabled) include `facilityName`, `providerName`, `fullAddress`, `imageUrl`, and `sourceUrl`.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `byCountry` | `byCountry` / `byState` / `byCity` / `byProvider` / `byFacilityUrl` |
| `country` | select | `united-states` | Country to browse (mode=byCountry/byState/byCity) |
| `state` | string | – | State/region name, e.g. `Texas` (mode=byState/byCity) |
| `city` | string | – | City name, e.g. `Dallas` (mode=byCity) |
| `provider` | select | `equinix` | Well-known provider (mode=byProvider) |
| `providerOther` | string | – | Any provider name not in the dropdown; overrides `provider` |
| `facilityUrls` | array | – | Direct facility URLs or slugs (mode=byFacilityUrl) |
| `maxItems` | integer | `30` | Hard cap on emitted records (1–500) |
| `fetchFullDetails` | boolean | `true` | Visit each facility's page for full specs; disable for a faster summary-only run |
| `facilityType` | select | – | Filter by service type (requires `fetchFullDetails=true`) |
| `certification` | select | – | Filter by certification (requires `fetchFullDetails=true`) |
| `minTotalPowerMw` | number | – | Minimum total power capacity in MW (requires `fetchFullDetails=true`) |

#### Example: all data centers in a US state

```json
{
  "mode": "byState",
  "country": "united-states",
  "state": "Texas",
  "maxItems": 50
}
```

#### Example: facilities in a specific city, filtered by certification

```json
{
  "mode": "byCity",
  "country": "united-states",
  "state": "Virginia",
  "city": "Ashburn",
  "certification": "SOC 2 Type 2",
  "maxItems": 40
}
```

#### Example: all locations for a provider

```json
{
  "mode": "byProvider",
  "provider": "digital-realty",
  "maxItems": 100
}
```

#### Example: specific facilities by URL

```json
{
  "mode": "byFacilityUrl",
  "facilityUrls": [
    "https://www.datacenters.com/equinix-da1-dallas",
    "amazon-aws-iad23-ashburn"
  ]
}
```

### Use cases

- **Site selection** — compare colocation facilities across markets by power capacity, certifications, and space
- **Market research** — map data center density by country, state, or provider
- **Sales & lead generation** — build prospect lists of facility operators in a target region
- **Compliance sourcing** — filter facilities by certification (SOC 2, ISO 27001, PCI DSS, HIPAA)
- **Competitive intelligence** — track a provider's footprint across markets
- **Real estate & infrastructure analysis** — geolocate facilities for logistics planning

### FAQ

**Do I need a login, API key, or proxy?** No. The actor works out of the box on the free Apify plan.

**What countries are covered?** 45+ countries are available as a dropdown, including the US, Canada, UK, Germany, France, China, India, Japan, Australia, Brazil, and more. State/city browsing works globally as long as datacenters.com lists facilities there.

**Why do some facilities have fewer fields than others?** Not every operator discloses power capacity, colocation space, or certifications publicly. The actor only includes fields that datacenters.com actually reports — it never fabricates placeholder values.

**What's the difference between `facilityType` values?** `Colocation` (rentable rack/cage space), `IaaS` (infrastructure-as-a-service), `Internet Exchange`, `Cloud`, `Bare Metal`, `Network`, and `Wholesale` reflect the services a facility offers, as published by the operator.

**Can I look up a facility I already have a URL for?** Yes — use `mode: byFacilityUrl` with a list of datacenters.com facility URLs or slugs.

**How fast is a run?** Summary-only runs (`fetchFullDetails: false`) are fastest. Full-detail runs visit each facility's page individually for the richer field set, so larger `maxItems` values take proportionally longer.

**Why is a run with `facilityType`/`certification`/`minTotalPowerMw` slow when it finds few or no matches?** datacenters.com doesn't expose these as server-side search filters, so the actor must open every candidate facility's detail page to evaluate them. Combining a restrictive filter with a broad scope (a large city, state, or country) can mean visiting hundreds of facility pages before concluding there are no matches. Narrow the scope (a specific city/provider) or allow a generous run timeout when using these filters over a large area.

**Does city browsing handle non-English spellings (e.g. `München`, `Köln`)?** Yes. If the direct city-page guess comes back empty, the actor automatically checks the state's real city list and matches by accent-insensitive name before giving up.

**Does state/region browsing handle local naming conventions (e.g. Swedish counties like `Skåne`)?** Yes. If a state/region name doesn't produce a direct match (some countries use administrative suffixes in their URLs that don't match how the name is commonly typed), the actor automatically checks the country's real state list and matches by accent-insensitive, suffix-tolerant name before giving up. This applies to both `byState` and `byCity` modes.

**How fresh is the data?** Facility pages are scraped live on every run, reflecting whatever datacenters.com currently publishes.

# Actor input Schema

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

What to fetch.

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

Country to browse. Required for byCountry, byState, and byCity modes.

## `state` (type: `string`):

State, province, or region name, e.g. `Texas`, `Virginia`, `California`, `England`, `Ontario`. Required for byState and byCity modes.

## `city` (type: `string`):

City name, e.g. `Dallas`, `Ashburn`, `Frankfurt am Main`. Required for byCity mode.

## `provider` (type: `string`):

A well-known data center provider / operator. Required for byProvider mode unless `providerOther` is set.

## `providerOther` (type: `string`):

Any other provider/operator name not in the dropdown above (e.g. `Vantage Data Centers`, `Iron Mountain`). Overrides `provider` when set.

## `facilityUrls` (type: `array`):

Direct datacenters.com facility URLs or slugs, e.g. `https://www.datacenters.com/equinix-da1-dallas` or `equinix-da1-dallas`. Required for byFacilityUrl mode.

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

Hard cap on emitted facility records.

## `fetchFullDetails` (type: `boolean`):

Visit each facility's detail page to extract address components, coordinates, certifications, power/space specs, provider contact info, images, and videos. Disable for faster runs that only need name/provider/address.

## `facilityType` (type: `string`):

Only include facilities offering this service type. Requires `fetchFullDetails=true`.

## `certification` (type: `string`):

Only include facilities holding this certification. Requires `fetchFullDetails=true`.

## `minTotalPowerMw` (type: `number`):

Only include facilities reporting at least this much total power capacity, in megawatts. Requires `fetchFullDetails=true`.

## Actor input object example

```json
{
  "mode": "byCountry",
  "country": "united-states",
  "state": "Texas",
  "city": "Dallas",
  "provider": "equinix",
  "facilityUrls": [],
  "maxItems": 30,
  "fetchFullDetails": true,
  "facilityType": "",
  "certification": ""
}
```

# Actor output Schema

## `facilities` (type: `string`):

Dataset containing all scraped data center facility records.

# 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 = {
    "mode": "byCountry",
    "country": "united-states",
    "state": "Texas",
    "city": "Dallas",
    "provider": "equinix",
    "facilityUrls": [],
    "maxItems": 30,
    "fetchFullDetails": true,
    "facilityType": "",
    "certification": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/colocation-data-center-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 = {
    "mode": "byCountry",
    "country": "united-states",
    "state": "Texas",
    "city": "Dallas",
    "provider": "equinix",
    "facilityUrls": [],
    "maxItems": 30,
    "fetchFullDetails": True,
    "facilityType": "",
    "certification": "",
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/colocation-data-center-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 '{
  "mode": "byCountry",
  "country": "united-states",
  "state": "Texas",
  "city": "Dallas",
  "provider": "equinix",
  "facilityUrls": [],
  "maxItems": 30,
  "fetchFullDetails": true,
  "facilityType": "",
  "certification": ""
}' |
apify call crawlerbros/colocation-data-center-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/ZxLzkIzbGn51WogcM/builds/dMQWLmHIG6bHngLaI/openapi.json