# 500 Global Portfolio Scraper (`automation-lab/500-global-portfolio-scraper`) Actor

Extract public 500 Global portfolio companies with websites, industries, locations, stages, batches, and investment metadata.

- **URL**: https://apify.com/automation-lab/500-global-portfolio-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## 500 Global Portfolio Scraper

Extract structured company data from the public 500 Global portfolio directory.

### What does 500 Global Portfolio Scraper do?

500 Global Portfolio Scraper collects public startup records from 500 Global's portfolio.
It reads the same public data source used by the 500 Global companies page.
It returns clean dataset rows for portfolio companies, industries, stages, locations, websites, LinkedIn URLs, batches, and investment metadata when available.

### Who is it for?

- Venture capital analysts building startup market maps.
- Startup scouts tracking 500 Global-backed companies.
- Recruiters sourcing venture-backed companies by country or industry.
- Agencies building prospect lists for sales or partnerships.
- Researchers comparing accelerator and seed-stage ecosystems.
- Data teams enriching CRM or warehouse records.

### Why use this actor?

- HTTP-only collection keeps runs fast and cost-efficient.
- The output is already normalized for exports and APIs.
- Filters let you narrow records by tenant, keyword, country, industry, and stage.
- Every row includes a `sourceUrl` and `scrapedAt` timestamp for traceability.

### What data can you extract?

| Field | Description |
| --- | --- |
| `companyName` | Best available company display name |
| `description` | Public one-line company description |
| `websiteUrl` | Company website |
| `linkedinUrl` | Company LinkedIn page when available |
| `logoUrl` | Company logo image URL |
| `country` | Country of operation |
| `region` | Region of operation |
| `stage` | Investment stage |
| `businessModel` | Business model tag |
| `industries` | Industry tags |
| `tenants` | 500 Global tenant/program tags |
| `batches` | Batch names |
| `initialInvestmentDates` | Initial investment dates |
| `companyId` | Source company ID |
| `organizationId` | Source organization ID |
| `alternativeNames` | Alternative names from the source |
| `sourceUrl` | API URL used for the scrape |
| `scrapedAt` | Collection timestamp |

### How much does it cost to scrape 500 Global portfolio companies?

This actor uses pay-per-event pricing.
You pay a $0.005 start fee for each run and a per-result fee for each saved company record.
Formula-derived per-result pricing starts at $0.000024241 for BRONZE users, with canonical tier discounts for higher Apify plans.
A 1,000-company export costs about $0.029 before any plan-tier discount, plus the $0.005 run start fee.
For small tests, keep `maxItems` low.
For production exports, increase `maxItems` to the number of rows you need.

### Quick start

1. Open the actor on Apify.
2. Keep the default `tenant` value or leave it empty for all public records.
3. Add an optional keyword like `fintech`, `ai`, or `Brazil`.
4. Set `maxItems` to the number of companies you want.
5. Click **Start**.
6. Export the dataset as JSON, CSV, Excel, or via API.

### Input options

#### tenant

Optional 500 Global tenant or program filter.
Examples include `global`, `latam`, `sea`, `mena`, `thailand`, `korea`, `taiwan`, and `istambul`.
Leave it empty to request all public portfolio records.

#### search

Optional case-insensitive keyword.
The actor searches company name, alternative names, description, website, LinkedIn URL, country, region, stage, business model, industries, tenants, and batches.

#### maxItems

Maximum number of records to save.
Use a low value for testing.
Use a larger value when you need a full export.

#### countries

Optional list of country names.
If provided, the actor saves only companies whose country exactly matches one of the names.

#### industries

Optional list of industry names.
If provided, the actor saves companies with at least one matching industry.

#### stages

Optional list of stage names.
If provided, the actor saves only matching stages.

### Example input

```json
{
  "tenant": "global",
  "search": "fintech",
  "maxItems": 25,
  "countries": [],
  "industries": [],
  "stages": []
}
````

### Example output

```json
{
  "companyName": "AA Audience",
  "description": "Developer of a mobile application designed to generate customers for the finance industry via mobile devices.",
  "websiteUrl": "https://aaaudi.com/",
  "linkedinUrl": null,
  "logoUrl": "https://founder-hub-public.s3.us-west-1.amazonaws.com/example.png",
  "country": "United States",
  "region": "North America",
  "stage": "Seed",
  "businessModel": "B2B",
  "industries": ["FinTech"],
  "tenants": ["taiwan", "global"],
  "batches": ["GA 21"],
  "initialInvestmentDates": ["2017-05-16T00:00:00.000Z"],
  "companyId": 4502,
  "organizationId": 1810,
  "businessName": "AA Audience",
  "alternativeNames": ["AA Audience"],
  "sourceUrl": "https://500.co/api/startups?tenant=global",
  "scrapedAt": "2026-05-23T08:49:09.741Z"
}
```

### Tips for best results

- Start with `maxItems` set to 25 or less.
- Use `search` to narrow broad portfolio exports.
- Use country filters only after checking the exact source spelling.
- Leave optional filters empty when you want the broadest dataset.
- Combine `tenant` and `search` for focused lists, such as `latam` plus `fintech`.

### Integrations

Use this actor with CRM imports, spreadsheet enrichment, BI dashboards, lead generation workflows, or startup intelligence pipelines.
Common workflows include:

- Export CSV into Google Sheets.
- Sync dataset items into Airtable.
- Feed company domains into enrichment actors.
- Monitor new records over time by comparing dataset exports.
- Build market maps by country, industry, or stage.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/500-global-portfolio-scraper').call({
  tenant: 'global',
  search: 'fintech',
  maxItems: 25,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/500-global-portfolio-scraper').call(run_input={
    'tenant': 'global',
    'search': 'fintech',
    'maxItems': 25,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~500-global-portfolio-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"tenant":"global","search":"fintech","maxItems":25}'
```

### MCP usage

Use this actor through Apify MCP with Claude Code or Claude Desktop.
Configure the MCP URL with the actor tool parameter:

```text
https://mcp.apify.com/?tools=automation-lab/500-global-portfolio-scraper
```

Claude Code setup:

```bash
claude mcp add apify https://mcp.apify.com/?tools=automation-lab/500-global-portfolio-scraper
```

Claude Desktop JSON setup:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/500-global-portfolio-scraper"
    }
  }
}
```

Example prompts:

- "Run 500 Global Portfolio Scraper for fintech companies and summarize the top countries."
- "Collect 50 global 500 Global portfolio companies and make a table of websites and industries."
- "Find 500 Global companies in Brazil and group them by industry."

### Data freshness

The actor retrieves the public 500 Global API during each run.
Rows reflect the source data available at run time.
The `scrapedAt` field records when the run collected the data.

### Limitations

The actor extracts public portfolio fields exposed by 500 Global.
It does not log in, bypass access controls, or infer hidden fields.
Founder-level details are not included because they are not present in the public API response used by the MVP.

### FAQ and troubleshooting

#### Why did my run return fewer rows than maxItems?

Your filters may be too narrow, or the selected tenant may contain fewer matching companies.
Remove `search`, `countries`, `industries`, or `stages` to broaden the result set.

#### Why are some website or LinkedIn fields null?

Some portfolio records do not include those URLs in the public source data.
The actor keeps null values rather than inventing or guessing data.

### Legality and ethics

This actor collects publicly available business information from 500 Global.
Use the data responsibly and comply with applicable laws, platform terms, and privacy rules.
Do not use scraped data for spam, harassment, or unlawful profiling.

### Related scrapers

You may also find these Apify actors useful:

- https://apify.com/automation-lab/y-combinator-scraper
- https://apify.com/automation-lab/company-website-scraper
- https://apify.com/automation-lab/linkedin-company-scraper
- https://apify.com/automation-lab/startup-jobs-scraper

### Support

If the source page changes or you need additional fields, open an issue on Apify.
Include your run ID, input, and a short description of the expected output.

### Changelog

Initial version extracts public portfolio company records from 500 Global's API.

# Actor input Schema

## `tenant` (type: `string`):

Optional 500 Global tenant filter. Leave empty for all public portfolio companies, or use values like global, latam, sea, mena, thailand, korea, taiwan, istambul.

## `search` (type: `string`):

Optional keyword matched against company names, descriptions, URLs, industries, countries, stages, and batches.

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

Maximum number of portfolio company records to save.

## `countries` (type: `array`):

Only include companies from these country names. Leave empty to include all countries.

## `industries` (type: `array`):

Only include companies with any of these industry names. Leave empty to include all industries.

## `stages` (type: `array`):

Only include companies at these investment stages, such as Seed or Pre-Seed. Leave empty to include all stages.

## Actor input object example

```json
{
  "tenant": "global",
  "search": "fintech",
  "maxItems": 20,
  "countries": [],
  "industries": [],
  "stages": []
}
```

# Actor output Schema

## `overview` (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 = {
    "tenant": "global",
    "search": "fintech",
    "maxItems": 20,
    "countries": [],
    "industries": [],
    "stages": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/500-global-portfolio-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 = {
    "tenant": "global",
    "search": "fintech",
    "maxItems": 20,
    "countries": [],
    "industries": [],
    "stages": [],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/500-global-portfolio-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 '{
  "tenant": "global",
  "search": "fintech",
  "maxItems": 20,
  "countries": [],
  "industries": [],
  "stages": []
}' |
apify call automation-lab/500-global-portfolio-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/500-global-portfolio-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "500 Global Portfolio Scraper",
        "description": "Extract public 500 Global portfolio companies with websites, industries, locations, stages, batches, and investment metadata.",
        "version": "0.1",
        "x-build-id": "iwROHQSVmIX9DZOXD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~500-global-portfolio-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-500-global-portfolio-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/automation-lab~500-global-portfolio-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-500-global-portfolio-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/automation-lab~500-global-portfolio-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-500-global-portfolio-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": {
                    "tenant": {
                        "title": "Tenant / program",
                        "type": "string",
                        "description": "Optional 500 Global tenant filter. Leave empty for all public portfolio companies, or use values like global, latam, sea, mena, thailand, korea, taiwan, istambul."
                    },
                    "search": {
                        "title": "Keyword search",
                        "type": "string",
                        "description": "Optional keyword matched against company names, descriptions, URLs, industries, countries, stages, and batches."
                    },
                    "maxItems": {
                        "title": "Maximum companies",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of portfolio company records to save.",
                        "default": 20
                    },
                    "countries": {
                        "title": "Countries",
                        "type": "array",
                        "description": "Only include companies from these country names. Leave empty to include all countries.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "industries": {
                        "title": "Industries",
                        "type": "array",
                        "description": "Only include companies with any of these industry names. Leave empty to include all industries.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "stages": {
                        "title": "Stages",
                        "type": "array",
                        "description": "Only include companies at these investment stages, such as Seed or Pre-Seed. Leave empty to include all stages.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
