# Forbes Lists Scraper (`crawlerbros/forbes-lists-scraper`) Actor

Scrape Forbes lists - Billionaires, Forbes 400, Global 2000, Self-Made Women, Best Employers and more. Returns ranked person/company records with full metadata.

- **URL**: https://apify.com/crawlerbros/forbes-lists-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Lead generation, News
- **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 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 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

## Forbes Lists Scraper

Scrape the Forbes ranked lists — **World Billionaires**, **Forbes 400**, **Global 2000**, **Self-Made Women**, **Best Employers for Diversity/Women**, and more — with full metadata including rank, net worth, industry, country, CEO, and financial metrics.

---

### What it does

- Fetches Forbes list data from the official Forbes public JSON API (`forbes.com/ajax/list/data`)
- Supports 8 pre-configured lists plus a custom slug mode for any Forbes list URI
- Returns flat, omit-empty records with rank, profile URL, image URL, and all available metadata
- No browser required — pure HTTP, Tier 1

---

### Input

| Field | Type | Description |
|-------|------|-------------|
| `mode` | Select | Which Forbes list to scrape (default: `billionaires`) |
| `listYear` | Integer | Year of the list (2010–2026, default: 2025) |
| `listSlug` | String | Forbes list slug for `byListSlug` mode (e.g. `billionaires`) |
| `listType` | Select | `person` or `organization` for `byListSlug` mode |
| `minNetWorth` | Number | Filter: min net worth in $ billions (person lists only) |
| `country` | String | Filter: keep only records from this country |
| `industry` | String | Filter: keep only records where industry contains this text |
| `maxItems` | Integer | Max records to emit (1–5000, default: 100) |

#### Available Modes

| Mode | List |
|------|------|
| `billionaires` | World Billionaires (Real-Time) |
| `forbes400` | Forbes 400 — America's Richest People |
| `global2000` | Forbes Global 2000 — World's Largest Public Companies |
| `selfMadeWomen` | America's Richest Self-Made Women |
| `bestEmployersDiversity` | Best Employers for Diversity |
| `bestEmployersWomen` | Best Employers for Women |
| `bestLargeEmployers` | Best Large Employers |
| `bestMidsizeEmployers` | Best Midsize Employers |
| `byListSlug` | Any Forbes list by its URL slug |

---

### Output

#### Person records (`billionaires`, `forbes400`, `selfMadeWomen`)

| Field | Description |
|-------|-------------|
| `rank` | List rank |
| `name` | Full name |
| `firstName` | First name |
| `lastName` | Last name |
| `profileUrl` | Forbes profile URL |
| `imageUrl` | Profile image URL |
| `netWorth` | Net worth (numeric) |
| `netWorthUnit` | `B` (billions) or `M` (millions) |
| `netWorthChangeToday` | Today's net worth change in millions USD (real-time lists only: `billionaires`, `forbes400`) |
| `asOf` | Date the real-time figures were last updated (real-time lists only) |
| `source` | Source of wealth |
| `industry` | Industry category |
| `citizenship` | Country of citizenship |
| `state` | US state (for US-based individuals) |
| `age` | Age |
| `gender` | `M` or `F` |
| `title` | Professional title |
| `listName` | Forbes list identifier |
| `listYear` | Year of the list |
| `sourceUrl` | Forbes list URL |
| `scrapedAt` | ISO timestamp |
| `recordType` | `person` |

#### Company records (`global2000`, `bestEmployers*`)

| Field | Description |
|-------|-------------|
| `rank` | List rank |
| `name` | Company name |
| `url` | Forbes company URL |
| `logoUrl` | Company logo URL |
| `revenue` / `revenueUnit` | Revenue in B or M USD |
| `profit` / `profitUnit` | Net profit in B or M USD |
| `assets` / `assetsUnit` | Total assets in B or M USD |
| `marketValue` / `marketValueUnit` | Market capitalization in B or M USD |
| `country` | Country of headquarters |
| `industry` | Industry category |
| `employees` | Employee count |
| `ceo` | CEO name |
| `ceoTitle` | CEO title |
| `websiteUrl` | Company website |
| `headquarters` | Headquarters location |
| `state` | US state |
| `listName` | Forbes list identifier |
| `listYear` | Year of the list |
| `sourceUrl` | Forbes list URL |
| `scrapedAt` | ISO timestamp |
| `recordType` | `company` |

---

### Example: Top 20 Billionaires

```json
{
  "mode": "billionaires",
  "listYear": 2025,
  "maxItems": 20
}
````

**Sample output:**

```json
{
  "rank": 1,
  "name": "Elon Musk",
  "firstName": "Elon",
  "lastName": "Musk",
  "profileUrl": "https://www.forbes.com/profile/elon-musk/",
  "imageUrl": "https://specials-images.forbesimg.com/...",
  "netWorth": 311.0,
  "netWorthUnit": "B",
  "source": "Tesla, SpaceX",
  "industry": "Automotive",
  "citizenship": "United States",
  "age": 53,
  "gender": "M",
  "listName": "billionaires",
  "listYear": 2025,
  "sourceUrl": "https://www.forbes.com/lists/billionaires/?year=2025",
  "scrapedAt": "2025-01-15T10:30:00+00:00",
  "recordType": "person"
}
```

***

### FAQs

**Q: Does it require an API key or login?**
A: No. Forbes list data is publicly accessible via their JSON API.

**Q: How many records can I get?**
A: The Billionaires list has 3000+ entries. Global 2000 has 2000 entries. Set `maxItems` up to 5000.

**Q: Can I filter by country or industry?**
A: Yes — use the `country` (exact match) and `industry` (substring) input fields.

**Q: What years are supported?**
A: 2010 through 2026. Note that not all lists have data for all years.

**Q: Can I scrape any Forbes list?**
A: Yes — use `mode=byListSlug` and set `listSlug` to the Forbes URI slug, i.e. the part of the list's URL after `forbes.com/lists/` (e.g. `self-made-women` for `forbes.com/lists/self-made-women/`). Set `listType` to `person` or `organization` to match the list's record type.

**Q: Why is net worth in billions vs millions?**
A: Records with net worth ≥ $1B show `netWorthUnit=B` with a billions value. Smaller values show `netWorthUnit=M` with a millions value.

# Actor input Schema

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

Which Forbes list to scrape.

## `listYear` (type: `integer`):

Year of the Forbes list (e.g. 2024). Defaults to 2025. Note: Billionaires and Forbes 400 are tracked by Forbes in real time, so those two always return today's live rankings regardless of the year requested.

## `listSlug` (type: `string`):

Forbes list URI slug for mode=byListSlug, e.g. `billionaires`, `global2000`, `self-made-women`.

## `listType` (type: `string`):

Record type for byListSlug mode: `person` for individual rankings, `organization` for company rankings.

## `minNetWorth` (type: `number`):

Filter — only include person records with net worth above this value (in $ billions). Applies to billionaires and forbes400 modes.

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

Filter — only include person records from this country. Enter the country name as it appears on Forbes (e.g. United States, Germany, China).

## `industry` (type: `string`):

Filter — only include records where industry matches (case-insensitive substring). E.g. `Technology`, `Finance`, `Real Estate`.

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

Maximum number of records to emit.

## Actor input object example

```json
{
  "mode": "billionaires",
  "listYear": 2025,
  "listType": "person",
  "maxItems": 100
}
```

# Actor output Schema

## `forbesRecords` (type: `string`):

Dataset containing all scraped Forbes list 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": "billionaires",
    "listYear": 2025,
    "listType": "person",
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/forbes-lists-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": "billionaires",
    "listYear": 2025,
    "listType": "person",
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/forbes-lists-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": "billionaires",
  "listYear": 2025,
  "listType": "person",
  "maxItems": 100
}' |
apify call crawlerbros/forbes-lists-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Forbes Lists Scraper",
        "description": "Scrape Forbes lists - Billionaires, Forbes 400, Global 2000, Self-Made Women, Best Employers and more. Returns ranked person/company records with full metadata.",
        "version": "1.0",
        "x-build-id": "1x4IKaB5ql6kMj87r"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~forbes-lists-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-forbes-lists-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/crawlerbros~forbes-lists-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-forbes-lists-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/crawlerbros~forbes-lists-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-forbes-lists-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "List",
                        "enum": [
                            "billionaires",
                            "forbes400",
                            "global2000",
                            "selfMadeWomen",
                            "bestEmployersDiversity",
                            "bestEmployersWomen",
                            "bestLargeEmployers",
                            "bestMidsizeEmployers",
                            "byListSlug"
                        ],
                        "type": "string",
                        "description": "Which Forbes list to scrape.",
                        "default": "billionaires"
                    },
                    "listYear": {
                        "title": "List Year",
                        "minimum": 2010,
                        "maximum": 2026,
                        "type": "integer",
                        "description": "Year of the Forbes list (e.g. 2024). Defaults to 2025. Note: Billionaires and Forbes 400 are tracked by Forbes in real time, so those two always return today's live rankings regardless of the year requested.",
                        "default": 2025
                    },
                    "listSlug": {
                        "title": "Custom List Slug (mode=byListSlug)",
                        "type": "string",
                        "description": "Forbes list URI slug for mode=byListSlug, e.g. `billionaires`, `global2000`, `self-made-women`."
                    },
                    "listType": {
                        "title": "Record Type (mode=byListSlug)",
                        "enum": [
                            "person",
                            "organization"
                        ],
                        "type": "string",
                        "description": "Record type for byListSlug mode: `person` for individual rankings, `organization` for company rankings.",
                        "default": "person"
                    },
                    "minNetWorth": {
                        "title": "Min Net Worth ($ billions)",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "number",
                        "description": "Filter — only include person records with net worth above this value (in $ billions). Applies to billionaires and forbes400 modes."
                    },
                    "country": {
                        "title": "Filter by Country",
                        "type": "string",
                        "description": "Filter — only include person records from this country. Enter the country name as it appears on Forbes (e.g. United States, Germany, China)."
                    },
                    "industry": {
                        "title": "Filter by Industry",
                        "type": "string",
                        "description": "Filter — only include records where industry matches (case-insensitive substring). E.g. `Technology`, `Finance`, `Real Estate`."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of records to emit.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
