# Y Combinator Startups Scraper (`scrapers-hub/y-combinator-startups-scraper`) Actor

Y Combinator Startups Scraper extracts YC company profiles - name, website, one-liner, long description, team size, batch, status, industries, regions, locations, tags, badges and hiring flag. 🚀 For VC research and startup datasets.

- **URL**: https://apify.com/scrapers-hub/y-combinator-startups-scraper.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 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.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## 🚀 Y Combinator Startups Scraper – YC Companies, Batches & Hiring Data

The Y Combinator Startups Scraper extracts the full YC company directory into a structured dataset — company names, batches, one-liners, long descriptions, websites, team sizes, industries, regions, locations, status and hiring flags. Search by keyword, filter by company status, restrict to firms that are currently hiring or that YC has marked as a top company, and get back clean records ready for a CRM, a market map or an investment pipeline.

This YC startup scraper is aimed at venture investors, business development teams, recruiters and startup researchers who need the Y Combinator portfolio as data rather than as a browsable web page. Every record carries a stable numeric `id`, a URL-friendly `slug`, the canonical `ycUrl` and a `scrapedAt` timestamp, so datasets from different runs can be joined and compared without ambiguity.

***

### 📊 What Data Can You Extract with This Y Combinator Startups Scraper?

Each record is one YC company. The fields group into six categories that map onto how investors and researchers actually filter a portfolio.

| Category | Fields | What it tells you |
|---|---|---|
| 🏷️ Company identity | `id`, `name`, `slug`, `website`, `ycUrl`, `smallLogoUrl` | Stable identifiers, the company's own site, its YC directory page and its logo |
| 📝 Description | `oneLiner`, `longDescription` | The elevator pitch and the fuller narrative the company submitted to YC |
| 🎓 YC context | `batch`, `status`, `isTopCompany`, `badges` | Which cohort the company came from, whether it is still active, and any YC-assigned distinctions |
| 🏭 Classification | `industries`, `tags` | The sector labels YC applies, plus additional descriptive tags |
| 🌍 Geography | `regions`, `locations` | Broad regions and specific city-level locations for the company |
| 👥 Team & hiring | `teamSize`, `isHiring` | Headcount as reported to YC and whether the company is currently recruiting |
| ⏱️ Provenance | `scrapedAt` | The exact moment the record was captured, for building time series |

The combination worth building workflows around is `batch` with `teamSize` and `isHiring`. Batch tells you company age precisely — `F25` is a very different proposition from `W16` — and reading headcount growth and hiring status against that age is the fastest way to spot which cohorts and which companies are actually scaling.

***

### 🌟 Key Features of the Y Combinator Startups Scraper

| Feature | Description |
|---|---|
| 🔍 Free-text search | `searchQuery` matches against company name, one-liner and description at once, so a term like "fintech" catches companies that never use it in their name |
| 🚦 Status filtering | `status` narrows to Active, Inactive, Acquired or Public companies, or leaves all statuses in |
| 💼 Hiring filter | `isHiring` restricts results to companies currently recruiting — the single most useful filter for recruiters and job seekers |
| 🏆 Top company filter | `isTopCompany` returns only companies YC itself has flagged as top performers |
| 🧮 Volume control | `maxCompanies` caps the run at a predictable number of records, defaulting to 20 |
| 🏭 Rich classification | Every record carries `industries`, `tags` and `badges` arrays, giving several independent ways to segment the portfolio |
| 🌍 Geographic detail | `regions` and `locations` arrays support both broad market analysis and city-level targeting |
| 🔗 Stable join keys | `id`, `slug` and `ycUrl` are all persistent, so repeated runs deduplicate and merge cleanly |
| 🛡️ Automatic proxy rotation | Requests are routed through rotating proxies automatically, with no proxy configuration needed |

***

### 🚀 Why Choose This Y Combinator Startups Scraper?

**Search across descriptions, not just names.** `searchQuery` is matched against the company name, the one-liner and the long description together. That is how you find every YC company working on developer tooling or climate tech, including the many whose names give no clue about what they do.

**Hiring signal is a first-class filter.** `isHiring` is available both as an input filter and as an output field, so you can pull a live list of YC companies recruiting right now, or track how hiring intent moves across a cohort over successive runs.

**Records that merge cleanly across runs.** Company names change and websites get replaced, but the numeric `id` and the `slug` persist. Combined with `scrapedAt`, that makes it straightforward to build a longitudinal dataset showing which companies changed status, grew headcount or stopped hiring.

**Three independent classification systems.** `industries` gives YC's own sector taxonomy, `tags` adds finer descriptive labels, and `badges` captures distinctions YC awards. Between them you can slice the portfolio at whatever granularity your analysis needs without building your own classifier.

***

### 📥 Input

```json
{
  "searchQuery": "AI",
  "status": "Active",
  "isHiring": true,
  "isTopCompany": false,
  "maxCompanies": 20
}
```

#### 🔧 Y Combinator Startups Scraper Input Fields

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `searchQuery` | string | No | `""` | Free-text query matched against company name, one-liner, and description (e.g. "AI", "fintech"). Leave empty to skip text filtering. |
| `status` | string | No | `""` | Filter by company status. One of `""` (Any), `Active`, `Inactive`, `Acquired`, `Public`. Leave empty for all statuses. |
| `isHiring` | boolean | No | `false` | Only return companies that are currently hiring. |
| `isTopCompany` | boolean | No | `false` | Only return companies YC has flagged as a "top company". |
| `maxCompanies` | integer | No | `20` | Maximum number of companies to scrape. |

#### 💡 Input Examples

**Fintech companies still operating**

```json
{
  "searchQuery": "fintech",
  "status": "Active",
  "maxCompanies": 100
}
```

**YC top companies, no keyword filter**

```json
{
  "isTopCompany": true,
  "maxCompanies": 200
}
```

**Companies hiring right now in developer tooling**

```json
{
  "searchQuery": "developer tools",
  "status": "Active",
  "isHiring": true,
  "maxCompanies": 50
}
```

***

### 📤 Output

```json
{
  "id": 30837,
  "name": "AirCaps",
  "slug": "aircaps",
  "website": "https://aircaps.com",
  "smallLogoUrl": "https://bookface-images.s3.amazonaws.com/small_logos/839111803eb4ccce6e6e411847617a96d8d7d880.png",
  "oneLiner": "The AI copilot for in-person conversations.",
  "longDescription": "\"AirCaps is bringing AI assistance to in-person conversations. \\r\\n\\r\\nOur AI-copilot provides live …",
  "teamSize": 5,
  "ycUrl": "https://www.ycombinator.com/companies/aircaps",
  "batch": "F25",
  "status": "Active",
  "industries": ["Consumer"],
  "regions": ["United States of America", "America / Canada"],
  "locations": ["San Francisco"],
  "tags": [],
  "badges": [],
  "isHiring": true,
  "isTopCompany": false,
  "scrapedAt": "2026-08-11T04:03:21.217069+00:00"
}
```

#### 🧾 Y Combinator Startups Output Fields

| Field | Type | Description |
|---|---|---|
| `id` | integer | null | Unique identifier of the item. |
| `name` | string | null | Name of the item. |
| `slug` | string | null | URL-friendly identifier. |
| `website` | string | null | Website address. |
| `smallLogoUrl` | string | null | URL of the item's small logo. |
| `oneLiner` | string | null | One liner of the item. |
| `longDescription` | string | null | Long description of the item. |
| `teamSize` | integer | null | Team size of the item. |
| `ycUrl` | string | null | URL of the item's yc. |
| `batch` | string | null | Batch of the item. |
| `status` | string | null | Status of the item. |
| `industries` | array | null | Industries values collected for the item. |
| `regions` | array | null | Regions values collected for the item. |
| `locations` | array | null | Locations values collected for the item. |
| `tags` | array | null | Tags attached to the item. |
| `badges` | array | null | Badges values collected for the item. |
| `isHiring` | boolean | null | Whether is hiring. |
| `isTopCompany` | boolean | null | Whether is top company. |
| `scrapedAt` | string | null | When this record was scraped. |

Array fields are frequently empty rather than null — `tags` and `badges` in particular are empty arrays for many companies, as the real sample above shows. Plan for both empty arrays and nulls when loading into a strict schema.

***

### 💻 How to Use the Y Combinator Startups Scraper (Step by Step)

#### Step 1: Decide what your search question actually is

Before touching the input, be clear about whether you are mapping a sector, building a recruiting list or tracking portfolio health. Sector mapping wants a `searchQuery` and a high `maxCompanies` with no status filter, so you see failures alongside successes. A recruiting list wants `isHiring` set to true and `status` set to Active. Portfolio health tracking wants no filters at all and a large cap, refreshed on a schedule. The same actor serves all three, but the input differs considerably.

#### Step 2: Craft the search query

`searchQuery` runs against company name, `oneLiner` and `longDescription` together, which makes it far more effective than a name-only search. Short, category-level terms such as "AI", "fintech", "biotech" or "logistics" give good recall. Longer phrases narrow results sharply because every word must find a match somewhere in the text. Leave the field empty to skip text filtering entirely and pull the directory unfiltered.

#### Step 3: Apply the status filter

`status` accepts Active, Inactive, Acquired and Public, or an empty value meaning any. The choice matters more than it first appears. Filtering to Active gives you a working prospect list; including Inactive gives you survivorship data, which is what you need if you are studying cohort outcomes rather than selling to current companies. Acquired and Public together form the exit set — a small but analytically valuable slice of any batch.

#### Step 4: Add hiring and top-company filters

`isHiring` restricts results to companies currently recruiting. For recruiters and job seekers, this single flag turns the whole YC directory into a live opportunity list. `isTopCompany` returns only companies YC has flagged as top performers, which is a useful proxy for traction when you have no revenue data. Both filters are additive with the status filter and with the search query, so combining all four narrows results quickly.

#### Step 5: Set the record limit

`maxCompanies` defaults to 20, which is deliberately small — enough to check that your filters behave as expected without running a large job. Once you are satisfied with a sample, raise it to whatever your analysis needs. Because the YC directory contains thousands of companies, a broad query with no filters and a high limit will produce a substantial dataset, so increase the cap in steps rather than jumping straight to the maximum you can imagine wanting.

#### Step 6: Run the scraper and review the sample

Start the actor from the Console or through the API. When results appear, check a handful of records against what you expected: does `batch` cover the cohorts you wanted, are `industries` populated, does `teamSize` look plausible? If `isHiring` was enabled, confirm every row has it set to true. Catching a mis-set filter on a 20-record run is far cheaper than discovering it after a full directory crawl.

#### Step 7: Export, join and schedule

Export as CSV, JSON, XLSX or XML from the Console, or read the dataset over the API. Join against your existing CRM or portfolio records on `id` or `slug`, both of which are stable across runs. For ongoing tracking, create an Apify **Schedule** with the same input and append each run to a history table keyed on `id` and `scrapedAt` — that history is what lets you detect status changes, headcount growth and hiring shifts over time.

***

### 🔌 API Access & Integrations

Run the Y Combinator startups scraper and receive the dataset in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers-hub~y-combinator-startups-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQuery": "AI",
    "status": "Active",
    "isHiring": true,
    "maxCompanies": 50
  }'
```

The same run with the Python client:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("scrapers-hub/y-combinator-startups-scraper").call(run_input={
    "searchQuery": "fintech",
    "status": "Active",
    "isTopCompany": False,
    "maxCompanies": 200,
})

for company in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(company["name"], company["batch"], company["teamSize"], company["isHiring"])
```

Finished datasets connect to Zapier, Make, Google Sheets and Slack, and Apify webhooks can push each completed YC scraping run straight into your own systems.

***

### 💡 Best Use Cases for Y Combinator Startup Data

#### 💸 Venture deal sourcing

Pull recent batches by filtering on `status` set to Active and scanning `batch` values for the latest cohorts, then read `oneLiner` and `longDescription` to shortlist companies in your thesis. `teamSize` gives an immediate sense of stage, and `website` plus `ycUrl` provide the two links an analyst needs to start diligence.

#### 🎯 B2B sales prospecting

YC companies are early adopters of developer tools, infrastructure and back-office software. Filter to Active companies in your target `industries`, use `teamSize` to qualify by company size, and treat `isHiring` as a growth signal — companies recruiting are the ones with budget and expanding needs.

#### 🧑‍💼 Recruiting and job hunting

Setting `isHiring` to true produces a live list of YC companies actively recruiting. `locations` and `regions` let you narrow to a commutable market or a remote-friendly region, and `teamSize` tells candidates whether they would be employee number five or fifty.

#### 🗺️ Market and competitive mapping

Run a `searchQuery` for your category with no status filter and a high `maxCompanies`, then group by `batch` to see when the category started attracting funding and by `status` to see how many attempts survived. `industries` and `tags` add secondary axes for building a proper landscape chart.

#### 📉 Cohort and survivorship analysis

Because `status` distinguishes Active, Inactive, Acquired and Public, and `batch` identifies the cohort precisely, you can calculate survival and exit rates per batch across the whole directory. Repeating the run on a schedule and diffing on `id` reveals status transitions as they happen.

#### 🤝 Partnership and ecosystem research

`industries`, `tags` and `badges` together describe what a company does and what YC recognises it for. Filtering on complementary rather than competing industries surfaces partnership candidates, and `regions` and `locations` show where an ecosystem is concentrated geographically.

#### 📚 Academic and journalistic research

The YC directory is one of the best-documented startup cohorts available. `batch`, `teamSize`, `status`, `industries` and `regions`, combined with `scrapedAt` for reproducibility, support quantitative work on accelerator outcomes, sector cycles and geographic concentration in venture-backed entrepreneurship.

***

### ⚙️ Tips for Better Y Combinator Startup Scraping Results

- **Start with `maxCompanies` at the default 20.** Confirm your filters produce the shape of result you expect before scaling to hundreds of records. It takes seconds and avoids wasted runs.
- **Prefer short search queries.** `searchQuery` matches text across three fields, so single category words give strong recall. Long phrases require every word to match somewhere and often return almost nothing.
- **Do not filter on status when studying outcomes.** Excluding Inactive companies introduces survivorship bias into any cohort analysis. Pull all statuses and filter afterwards so you keep the denominator.
- **Join on `id`, never on `name`.** Companies rebrand, and names collide across batches. The numeric `id` and the `slug` are the stable keys for deduplication and for merging successive runs.
- **Keep `scrapedAt` in your stored dataset.** It is what turns repeated runs into a time series and lets you prove when a status change or headcount shift was first observed.
- **Handle empty arrays explicitly.** `tags` and `badges` are commonly empty, and `industries`, `regions` and `locations` can hold multiple values. Flatten them deliberately rather than assuming a single value per field.

***

### 🛠️ Troubleshooting

**Why did my Y Combinator startups scraper run return no companies?**
The most likely cause is an over-restrictive filter combination. A narrow `searchQuery` together with `isTopCompany`, `isHiring` and a specific `status` can eliminate every company in the directory. Remove filters one at a time until results appear, then reintroduce them selectively.

**Why did I get exactly 20 records?**
That is the default value of `maxCompanies`. Raise it to collect more. The cap applies regardless of how many companies match your filters.

**`tags` and `badges` are empty on most rows.**
This reflects the source data. Many YC companies carry no tags or badges at all, as the real sample record shows. Use `industries` as your primary classification field and treat `tags` and `badges` as optional enrichment.

**Why does `teamSize` look wrong for a company I know?**
Team size is self-reported by the company to YC and is not always kept current, particularly for older batches. Treat it as an indication of scale rather than an authoritative headcount, and cross-check against the company's own site via the `website` field where accuracy matters.

**Results differ between two runs with the same input.**
The YC directory changes as companies update their profiles, change status or start and stop hiring. `scrapedAt` on every record is there precisely so you can treat each run as a dated snapshot rather than a fixed truth.

***

### ❓ Frequently Asked Questions About Y Combinator Startups Scraping

**What does the Y Combinator Startups Scraper collect?**
One record per YC company containing the identifiers, name, slug, website, logo URL, one-liner, long description, team size, YC directory URL, batch, status, industries, regions, locations, tags, badges, hiring flag, top-company flag and a scrape timestamp.

**Can I search YC companies by keyword?**
Yes. `searchQuery` is matched against the company name, the one-liner and the long description simultaneously, so a term like "AI" or "fintech" finds companies working in that space regardless of what they are called.

**How do I find YC companies that are hiring?**
Set `isHiring` to `true`. Every returned record will also carry `isHiring` in the output so you can verify the filter, and `locations` and `regions` let you narrow by geography afterwards.

**Can I filter YC startups by batch?**
There is no batch input filter, but `batch` is returned on every record — values look like `F25`, `W16` or `S21`. Pull a broad result set and filter on `batch` in your own tooling to isolate specific cohorts.

**What company statuses are available?**
`Active`, `Inactive`, `Acquired` and `Public`, plus an empty value meaning any status. The same values appear in the `status` output field.

**What does `isTopCompany` mean?**
It indicates that Y Combinator has flagged the company as a top company. Using it as an input filter returns only those companies; the field is also present on every output record.

**How many YC companies can I scrape at once?**
As many as `maxCompanies` allows. It defaults to 20, and you can raise it to cover a much larger portion of the directory. Increase it in steps so you can gauge dataset size as you go.

**Do I need a Y Combinator account or API key?**
No. The actor reads the public YC company directory, so there is no account, no API key and no developer quota involved.

**Is scraping Y Combinator company data legal?**
The scraper collects only publicly published company directory information. Public data collection is broadly permissible in many jurisdictions, but you remain responsible for complying with Y Combinator's Terms of Service and any laws or contractual obligations that apply to you.

**What is the difference between `regions` and `locations`?**
`regions` holds broad geographic groupings — the sample record shows "United States of America" and "America / Canada" — while `locations` holds specific places such as "San Francisco". Both are arrays and a company can appear in several of each.

**Can I export YC startup data to Excel or Google Sheets?**
Yes. Apify datasets export to CSV, XLSX, JSON and XML from the Console, and the dataset API endpoint can be read directly into Google Sheets or any BI tool that consumes CSV or JSON over HTTP.

**How do I track changes to the YC portfolio over time?**
Create an Apify Schedule with a fixed input and append each run's records to a history table keyed on `id` and `scrapedAt`. Diffing consecutive snapshots reveals status changes, headcount movement and hiring starts and stops.

**Which field should I use as a primary key?**
`id`, the numeric identifier. `slug` is a good secondary key and is human-readable. Avoid `name`, which changes when companies rebrand.

**Are proxies configurable?**
Proxy rotation is handled automatically by the actor, so there is nothing for you to configure.

**Does the scraper return founder names or contact details?**
No. The output covers company-level attributes — identity, description, classification, geography, team size, status and hiring flag. Founder identities and contact details are not part of the field set.

***

### 🆘 Support & Feedback

If the Y Combinator startups scraper stops behaving as documented — a field goes empty, a filter stops applying, or the directory layout changes — report it on the actor's **Issues** tab so it can be tracked and fixed.

Need something bespoke? Additional fields, founder-level detail, batch-specific crawling, or an output schema that maps onto your CRM — email **scraperhubapi@gmail.com** and describe the workflow you are building.

If this YC startup scraper is useful in your sourcing or research work, please leave a rating and a short review on the actor page. It helps other investors, recruiters and researchers find it, and it guides what gets improved next.

***

### ⚖️ Disclaimer

This Y Combinator startups scraper collects only publicly available company information published in the YC company directory. It does not access private accounts, internal YC systems, or any data behind authentication.

You are responsible for how the extracted data is used, including compliance with Y Combinator's Terms of Service, applicable copyright in the descriptive text companies publish, and any contractual restrictions that apply to your organisation.

The fields returned describe companies rather than individuals. Where a record nonetheless relates to an identifiable person — a solo-founder company whose name is a personal name, for instance — you act as the data controller for that record and must comply with the GDPR, the UK GDPR, the CCPA or the equivalent regime that applies to you, including establishing a lawful basis, limiting retention and honouring data subject requests. If you use this data for outreach, follow the marketing rules that apply in your recipients' jurisdictions.

This actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Y Combinator. To request removal of data collected through this actor, contact **scraperhubapi@gmail.com** with the relevant details and the request will be handled promptly.

# Actor input Schema

## `searchQuery` (type: `string`):

Free-text query matched against company name, one-liner, and description (e.g. "AI", "fintech"). Leave empty to skip text filtering.

## `status` (type: `string`):

Filter by company status. Leave empty for all statuses.

## `isHiring` (type: `boolean`):

Only return companies that are currently hiring.

## `isTopCompany` (type: `boolean`):

Only return companies YC has flagged as a "top company".

## `maxCompanies` (type: `integer`):

Maximum number of companies to scrape.

## Actor input object example

```json
{
  "searchQuery": "",
  "status": "",
  "isHiring": false,
  "isTopCompany": false,
  "maxCompanies": 20
}
```

# Actor output Schema

## `results` (type: `string`):

Records scraped by Y Combinator Startups Scraper, stored in the run's default dataset.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/y-combinator-startups-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/y-combinator-startups-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call scrapers-hub/y-combinator-startups-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapers-hub/y-combinator-startups-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Vvz002O1hHes2jugc/builds/uDUgugloYktVjzWA6/openapi.json