# Open Collective Scraper (`crawlerbros/opencollective-scraper`) Actor

Scrape Open Collective â€" an open-source funding platform for communities. Search collectives, projects, funds and organizations by keyword or category. Returns funding stats, backer counts, budget information, tags, and website links.

- **URL**: https://apify.com/crawlerbros/opencollective-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Integrations
- **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

## Open Collective Scraper

Scrape [Open Collective](https://opencollective.com) — the leading transparent funding platform for open-source projects, communities, and non-profit initiatives. Search collectives by keyword, browse by tag, or look up specific organizations by slug to extract funding data, contributor counts, and metadata.

### Features

- **Three search modes**: keyword search, tag-based browsing, or direct slug lookup
- **All account types**: collectives, funds, organizations, and projects
- **Financial transparency data**: total raised, total spent, contributor counts, backer counts
- **Rich metadata**: description, long description, social handles (Twitter, GitHub), website, tags, currency, and creation date
- **No authentication required**: uses the public Open Collective GraphQL API

### Use Cases

- Track funding trends across open-source ecosystems
- Research the financial health of communities and open-source projects
- Build dashboards comparing contributor counts and funding levels
- Monitor new collectives in specific domains (JavaScript, Python, climate, etc.)
- Discover well-funded projects by tag (react, webpack, linux, etc.)

### Input

| Field | Type | Description | Default |
|-------|------|-------------|---------|
| `mode` | Select | Search mode: `search`, `byTag`, or `bySlug` | `search` |
| `searchTerm` | Text | Keyword to search for (mode=search) | `open source` |
| `tag` | Text | Tag to filter by (mode=byTag): e.g. `javascript`, `react`, `python` | `javascript` |
| `slugs` | Array | List of collective slugs to fetch (mode=bySlug): e.g. `["webpack","babel"]` | — |
| `accountType` | Select | Account type filter: `COLLECTIVE`, `FUND`, `ORGANIZATION`, `PROJECT` | `COLLECTIVE` |
| `maxItems` | Integer | Maximum number of records to return (1–500) | `20` |

### Output

Each record contains:

| Field | Type | Description |
|-------|------|-------------|
| `slug` | String | URL-friendly collective slug |
| `name` | String | Display name |
| `legalName` | String | Legal entity name (if different from name) |
| `description` | String | Short one-line description |
| `longDescription` | String | Full description (up to 2,000 characters) |
| `type` | String | Account type: COLLECTIVE, FUND, ORGANIZATION, or PROJECT |
| `currency` | String | Operating currency (e.g., USD, EUR) |
| `imageUrl` | String | Logo/avatar image URL |
| `website` | String | Official website URL |
| `twitterHandle` | String | Twitter username (without @) |
| `githubHandle` | String | GitHub org or repo path |
| `createdAt` | String | ISO 8601 creation timestamp |
| `tags` | Array | Topic/category tags |
| `totalRaisedUsd` | Number | Cumulative amount raised (in USD) |
| `totalSpentUsd` | Number | Cumulative amount spent (in USD) |
| `contributorsCount` | Integer | Number of contributors |
| `backerCount` | Integer | Number of financial backers |
| `profileUrl` | String | Direct link to the Open Collective profile page |
| `scrapedAt` | String | ISO 8601 scrape timestamp |

### Example Output

```json
{
  "slug": "babel",
  "name": "Babel",
  "legalName": "Babel Open Source Project",
  "description": "The JavaScript compiler",
  "longDescription": "Babel is a toolchain that is mainly used to convert ECMAScript 2015+ code into a backwards compatible version of JavaScript.",
  "type": "COLLECTIVE",
  "currency": "USD",
  "imageUrl": "https://images.opencollective.com/babel/logo.png",
  "website": "https://babeljs.io",
  "twitterHandle": "babeljs",
  "githubHandle": "babel/babel",
  "createdAt": "2016-10-20T12:00:00Z",
  "tags": ["javascript", "open-source", "compiler"],
  "totalRaisedUsd": 150000.0,
  "totalSpentUsd": 120000.0,
  "contributorsCount": 250,
  "backerCount": 1200,
  "profileUrl": "https://opencollective.com/babel",
  "scrapedAt": "2026-06-04T15:30:00.000000+00:00"
}
````

### FAQs

**Does this require an API key?**
No. The Open Collective GraphQL API (`api.opencollective.com/graphql/v2`) is fully public and requires no authentication.

**What is the difference between contributors and backers?**
Contributors are anyone who has contributed code, design, or other non-financial help. Backers are financial supporters (people or organizations who have donated money).

**What account types are available?**

- `COLLECTIVE` — open-source projects and communities (most common)
- `FUND` — fiscal host funds that distribute to multiple collectives
- `ORGANIZATION` — companies that sponsor open-source work
- `PROJECT` — sub-projects under a parent collective

**Can I search for collectives in a specific programming language?**
Yes. Use `mode=byTag` with tags like `javascript`, `python`, `rust`, `golang`, `react`, `webpack`, etc.

**How are financial amounts reported?**
All financial figures (`totalRaisedUsd`, `totalSpentUsd`) are reported in USD equivalents, regardless of the collective's native currency.

**What is the maximum number of results I can fetch?**
Up to 500 records per run. For larger datasets, run the actor multiple times with different search terms or tags.

# Actor input Schema

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

What to fetch.

## `searchTerm` (type: `string`):

Keyword to search for collectives (mode=search).

## `tag` (type: `string`):

Tag to filter collectives. Examples: javascript, python, react, open-source, climate, education.

## `slugs` (type: `array`):

List of collective slugs to fetch. Example: babel, webpack, vue.

## `accountType` (type: `string`):

Type of accounts to return.

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

Maximum number of collectives to return.

## Actor input object example

```json
{
  "mode": "search",
  "searchTerm": "open source",
  "tag": "javascript",
  "slugs": [],
  "accountType": "COLLECTIVE",
  "maxItems": 20
}
```

# Actor output Schema

## `items` (type: `string`):

Open source projects and collectives from opencollective.com — budget, contributors, goals.

# 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": "search",
    "searchTerm": "open source",
    "tag": "javascript",
    "slugs": [],
    "accountType": "COLLECTIVE",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/opencollective-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": "search",
    "searchTerm": "open source",
    "tag": "javascript",
    "slugs": [],
    "accountType": "COLLECTIVE",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/opencollective-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": "search",
  "searchTerm": "open source",
  "tag": "javascript",
  "slugs": [],
  "accountType": "COLLECTIVE",
  "maxItems": 20
}' |
apify call crawlerbros/opencollective-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Open Collective Scraper",
        "description": "Scrape Open Collective â€\" an open-source funding platform for communities. Search collectives, projects, funds and organizations by keyword or category. Returns funding stats, backer counts, budget information, tags, and website links.",
        "version": "0.1",
        "x-build-id": "8aIhJYm1xeEYHAgQa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~opencollective-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-opencollective-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~opencollective-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-opencollective-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~opencollective-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-opencollective-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": "Mode",
                        "enum": [
                            "search",
                            "byTag",
                            "bySlug"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "search"
                    },
                    "searchTerm": {
                        "title": "Search term",
                        "type": "string",
                        "description": "Keyword to search for collectives (mode=search).",
                        "default": "open source"
                    },
                    "tag": {
                        "title": "Tag (mode=byTag)",
                        "type": "string",
                        "description": "Tag to filter collectives. Examples: javascript, python, react, open-source, climate, education.",
                        "default": "javascript"
                    },
                    "slugs": {
                        "title": "Collective slugs (mode=bySlug)",
                        "type": "array",
                        "description": "List of collective slugs to fetch. Example: babel, webpack, vue.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "accountType": {
                        "title": "Account type",
                        "enum": [
                            "COLLECTIVE",
                            "FUND",
                            "ORGANIZATION",
                            "PROJECT"
                        ],
                        "type": "string",
                        "description": "Type of accounts to return.",
                        "default": "COLLECTIVE"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of collectives to return.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```