# F6S Scraper $1💰 Funding, Accelerators, Events & Jobs (`abotapi/f6s-directory-scraper`) Actor

Extract structured data from F6S.com. Scrape funding programs, startup accelerators, events, and jobs from a single tool. Supports both filter-based searches and F6S URLs, returns 25+ fields per record, and works on all Apify plans.

- **URL**: https://apify.com/abotapi/f6s-directory-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Categories:** Jobs, Developer tools, Automation
- **Features:** Limited permissions
- **Stats:** 14 total users, 2 monthly users, 93.9% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## F6S Scraper: Programs, Accelerators, Events & Jobs

F6S Scraper turns F6S into structured startup data. Pull funding programs, accelerators, startup events and startup jobs by filters or by pasting F6S list links, with an optional full-profile fetch for description, funding range, website, social links and team. Runs once, on a schedule, or in incremental mode for ongoing monitoring, then export to JSON, CSV or Excel, or read results through the API.

### Why This Scraper?

- **Four directories in one actor.** Programs, accelerators, startup events and startup jobs, all from the same input form.
- **Two ways to start.** Pick filters (list type, location, keyword, program type, sort, investment, equity) or paste any F6S list URL.
- **Rich records on demand.** Every record carries 19 core fields; turn on Fetch full details to add description, funding range, website, social links and team from the profile page.
- **A pagination walk that finishes cleanly.** It stops only at a natural end (a page that repeats or comes back empty) or at your own record and page caps, and de-duplicates by record ID.
- **Resume without re-paying.** Continue a capped or interrupted run from a previous run or dataset ID, and a long run checkpoints itself so a platform restart never re-scrapes what it already saved.
- **Incremental mode for schedules.** Recurring runs against the same search return only new and changed records by default, tracked in the actor's own memory, no need to paste a run ID every time.
- **A blocked run fails loudly.** If every request is rejected, the run stops with a clear error instead of quietly returning an empty dataset.

### Use Cases

- **Startup founders:** find funding programs, accelerators and grants that match your stage, location, investment size and equity terms.
- **Accelerator and VC scouts:** track new and updated programs across regions to spot funding trends and competing offers.
- **Job seekers and recruiters:** monitor startup job postings on F6S by keyword or location.
- **Event organizers and community managers:** catalog startup events for a region, topic or niche.
- **Market researchers:** build comparison datasets of investment amounts, equity terms and deadlines across programs.
- **Business development and outreach:** collect websites, social links and team names from accelerator and program profiles for lead lists.

### Data You Get

> Sample shape: values are illustrative placeholders, not from a live listing.

| Field | Example |
| --- | --- |
| `id` | `sample-accelerator-2026` |
| `listType` | `"accelerators"` (also `"programs"`, `"events"`, `"jobs"`) |
| `name` | `Sample Accelerator 2026` |
| `slug` | `sample-accelerator-2026` |
| `profileUrl` | `https://www.f6s.com/sample-accelerator-2026` |
| `aboutUrl` | `https://www.f6s.com/sample-accelerator-2026/about` |
| `applyUrl` | `https://www.f6s.com/sample-accelerator-2026/apply` |
| `image` | `https://www.f6s.com/content-resource/profiles/00000001_th3.jpg` |
| `location` | `London, United Kingdom` |
| `tags` | `Funds Startups in AI, Fintech, SaaS` |
| `verified` | `true` |
| `deadline` | `by Jan 1` |
| `investmentRaw` | `$100k per team` |
| `investmentAmount` | `100000` |
| `investmentCurrency` | `USD` |
| `equityRaw` | `6%` |
| `equityPercent` | `6` |
| `description` | full profile description (when Fetch full details is on) |
| `website` | `https://example.com/` (when Fetch full details is on) |
| `socialLinks` | `["https://www.linkedin.com/company/example/"]` (when Fetch full details is on) |
| `team` | `[{"name": "Jane Doe", "url": "https://www.f6s.com/jane-doe"}]` (when Fetch full details is on) |
| `sourceUrl` | `https://www.f6s.com/accelerators` |
| `scrapedAt` | `2026-01-01T00:00:00.000Z` |

When Fetch full details is on, the profile page also adds `category`, `country`, `city`, `fundingCurrency`, `fundingAmountMin`, `fundingAmountMax` and `detailImage`; these are left out of the record entirely (not set to null) whenever full details are off or a profile's About page fails to load. Startup job records use a numeric job ID instead of a profile slug and typically carry no `investmentRaw`, `investmentAmount` or `equityRaw`, since those are program-specific terms. When Incremental mode is on, every record also gets `changeType`, `changedFields`, `firstSeenAt` and `lastSeenAt`, described below.

### How to Use

1. Pick a **mode**: `search` (use filters) or `url` (paste F6S list links).
2. In search mode, choose a **list type** (programs, accelerators, events or jobs) and any filters (location, keyword, program type, sort, investment, equity). In URL mode, paste one or more F6S list URLs instead; list type, location, keyword, program type and sort are ignored, but Min/Max investment and Max equity still filter the scraped records.
3. Turn on **Fetch full details** if you want description, funding range, website, social links and team, and set **Max records** and **Max pages per list** to control run size and cost.
4. Click **Start**. Download the dataset as JSON, CSV or Excel, or read it through the API.

**Basic search (programs worldwide):**

```json
{
  "mode": "search",
  "listType": "programs",
  "maxListings": 100
}
```

**Supported URL shapes (URL mode):**

| Shape | Example |
|---|---|
| Accelerators / programs / events / jobs list | `https://www.f6s.com/accelerators`, `/programs`, `/events`, `/jobs` |
| List by location | `https://www.f6s.com/programs/london`, `/accelerators/london`, `/events/london`, `/jobs/london` |
| Country / city / category path | `https://www.f6s.com/programs/united-kingdom/london`, `.../london/software` |
| Paginated list (walks forward from the page given) | `https://www.f6s.com/accelerators?page=2` |
| Filtered / sorted search | `https://www.f6s.com/programs?keywords[]=ai&type[]=grant&sort=popular` |
| Single program or organisation page (one record) | `https://www.f6s.com/blacknight-space-labs-w27-cohort`, `.../about`, `https://www.f6s.com/startupbootcamp` |

`https://f6s.com/...` (no `www`) is accepted and read as `www.f6s.com`. A URL that is not an F6S list or program/organisation page is skipped with a warning in the log; the run fails loudly if none of the pasted URLs is usable.

**New default:** in URL mode, if you leave the URLs field untouched (or omit it from an API call) the run now scrapes one example of each shape above instead of failing. Pass your own list (or an empty one) to override. With the default **Max records** of 20, every list URL gets at least one record and the single pages are reserved their own slots (the budget is split across the URLs, and a short list hands its unused slots to the next). The two default URLs for the same program (its page and its /about page) are one record. With **Max records** at 0 the run walks the whole catalogue of every list URL. Single-page URLs produce one record each and are billed as one result, with no extra detail charge.

**Accelerators in a location, with full details:**

```json
{
  "mode": "search",
  "listType": "accelerators",
  "location": "london",
  "fetchDetails": true,
  "maxListings": 50
}
```

**Programs filtered by keyword, type, sort and investment:**

```json
{
  "mode": "search",
  "listType": "programs",
  "keyword": "ai",
  "programType": "accelerator",
  "sortBy": "popular",
  "minInvestment": 25000,
  "maxEquity": 8,
  "maxListings": 200
}
```

**URL mode (paste F6S list links):**

```json
{
  "mode": "url",
  "urls": [
    "https://www.f6s.com/programs/new-york",
    "https://www.f6s.com/events"
  ],
  "maxListings": 100
}
```

#### Run it from your code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("abotapi/f6s-directory-scraper").call(run_input={"mode": "search", "listType": "accelerators", "maxListings": 50})
for record in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(record["name"], record["deadline"])
```

JavaScript:

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('abotapi/f6s-directory-scraper').call({ mode: 'search', listType: 'accelerators', maxListings: 50 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

Or connect it to Make, Zapier, n8n, Google Sheets or webhooks from the **Integrations** tab.

#### Limits and resuming a run

- **Max pages per list** (`maxPages`, default `0` = unlimited) leaves a list to walk end to end; there is no artificial page cap. The walk stops naturally once a page adds no new records (only ones already seen), a page comes back empty, or Max records is reached.
- **Max records** (`maxListings`, default `20`) is the main limit on a run: it stops the scrape after this many records are pushed. Set it to `0` to remove it and walk the whole catalogue, bounded only by the natural stop above.
- **Resume from run/dataset ID** (`resumeFromRunId`) continues a previous run instead of starting over: paste in its run or dataset ID and already-saved records are skipped, so the new run only fetches what's missing.
- A long run also checkpoints itself automatically: if the platform migrates or restarts the run, it picks back up without re-scraping or re-billing records it already saved.

#### Incremental mode (recurring monitoring)

For a search or URL list you run on a schedule, turn on **Incremental mode** instead of pasting a run ID every time. The actor remembers the records it saw last time, keyed by a hash of your search or URL filters (or your own **State key**), and classifies every record it scrapes against that memory:

| `changeType` | When it appears |
| --- | --- |
| `NEW` | Not seen in any previous run for this search. |
| `UPDATED` | Seen before, and at least one field genuinely changed; `changedFields` lists which. |
| `UNCHANGED` | Seen before, nothing changed. Not returned by default; turn on **Also return unchanged records** to get it anyway. |
| `REAPPEARED` | Was previously marked expired by this actor (see below) and has now been scraped again. This can only happen to a record that a prior run already tombstoned as `EXPIRED`; a record that is simply skipped on one run without ever being marked expired is not affected and keeps its earlier state. |
| `EXPIRED` | Seen before, not found in this run, **and** this run reached the natural end of the search with no record or page cap hit and no Resume in use. Only produced when **Also return records no longer found** is on. |

By default a recurring run therefore returns only what changed; a quiet run where nothing changed can legitimately push zero records, and that is not an error.

- `EXPIRED` and `REAPPEARED` are linked: because `EXPIRED` only fires after `emitExpired` is on and a run completes a full, uncapped scan, `REAPPEARED` can likewise only occur for a record that went through that exact path before coming back. If you never turn on **Also return records no longer found**, a record that temporarily disappears from the results is never tombstoned, so it cannot later classify as `REAPPEARED`; it simply keeps comparing as `UNCHANGED` or `UPDATED` once seen again.
- **State key** is an optional human-readable label for the tracked search; leave it empty for an automatic key derived from your filters.
- `scrapedAt` (the fetch time) and `sourceUrl` (the search-results page a record happened to appear on) never trigger a false `UPDATED`; F6S's default sort re-ranks the list as deadlines shift, so the same record can land on a different page with nothing about the record itself changing. Image URLs are compared by path only (the CDN host and query string rotate), and the order of `tags`, `team` and `socialLinks` is ignored. Every other field, including `deadline` and `investmentRaw`, participates in the comparison.
- **Ignore fields when detecting changes** (`ignoreFieldsForChanges`) lists extra fields that must never cause `UPDATED` or show up in `changedFields`, for example `deadline`. Use a dotted path such as `team.image` for a nested field. Ignored fields are still returned in the output. Changing this list never re-flags records: unchanged-ness is decided by re-comparing the stored record with the current ignore list.
- A pasted URL that starts at `?page=N` with N above 1 is a partial scan, so it never produces `EXPIRED` rows.
- When Fetch full details is off, or a profile's About page fails to load, the detail-only fields are excluded from that record's comparison rather than being read as the site having removed them.
- Incremental mode and Resume are different features: Resume continues one specific run from a pasted ID; Incremental mode tracks a search across separate scheduled runs on its own. Combining them (to bootstrap a monitoring baseline from a one-off crawl) only works when Incremental mode has no saved state yet for that search; otherwise the run fails fast rather than mixing baselines.

### Send results into your apps (MCP connectors)

Optionally pipe the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. This is an extra delivery step **after** the scrape: the Apify dataset is never changed.

**What gets written to the connector:** a condensed, human-readable **summary** of each record, not the full JSON. Each item becomes one entry with a **title** and its key fields flattened to plain text. The **complete record always stays in the Apify dataset**.

1. Authorize a connector once under **Apify → Settings → Integrations** (Notion, Linear, Airtable, or Apify).
2. Select it in the **"Pipe results into your apps"** input field. (If the picker is empty, you haven't authorized a connector yet.)
3. For **Notion**, also set `notionParentPageUrl` to the page where items should be created.

The connection is mediated by Apify's MCP proxy, so this actor never sees your third-party credentials. Leave the field empty to skip.

### Input Parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | string | `search` | `search` builds a list URL from the filters below; `url` uses the F6S list links you paste. |
| `listType` | string | `programs` | `programs`, `accelerators`, `events`, or `jobs`. Applies only in search mode. |
| `location` | string | none (prefill: empty) | City or country name, for example `London`, `New York` or `London, United Kingdom` (a slug such as `new-york` also works). Missing or empty is treated as worldwide. A place F6S does not recognise stops the run with a clear message. |
| `keyword` | string | none (prefill: empty) | Free-text keyword, for example `ai`. |
| `programType` | string | `any` | `accelerator`, `incubator`, `grant`, `competition`, or `fellowship`. Applies only to programs and accelerators. |
| `country` | string | none | Country name, for example `United Kingdom`. Narrows search mode to the site's country list (Location wins when both are set) and keeps only matching records in both modes. |
| `stage` | string | none | `Pre-Seed`, `Seed`, `Series A`, `Series B`, `Series C` or `Growth`. F6S has no stage filter, so this keeps records whose description, tags or name mention the stage (best with Fetch details on). |
| `sector` | string | none | Sector keyword such as `fintech`, sent to the site as a keyword filter (Keyword wins if both are set). |
| `deadlineOnly` | boolean | `false` | Keep only records that show an application deadline. |
| `sortBy` | string | `open` | `open`, `popular`, or `closest` (closing soon). |
| `minInvestment` | integer | none | Keep records offering at least this much per team. |
| `maxInvestment` | integer | none | Keep records offering at most this much per team. |
| `maxEquity` | integer | none | Keep records taking at most this much equity. |
| `urls` | array | one example of every supported URL shape | F6S list, program or organisation URLs for URL mode. If you explicitly pass an empty list in URL mode, the run fails with a clear message rather than scraping nothing silently. |
| `fetchDetails` | boolean | `false` | Open each profile's About page to add description, funding amount, website, social links and team. Adds one request per record. |
| `maxPages` | integer | `0` | Result pages to walk per list. `0` = unlimited; the walk stops naturally once a page repeats results already seen. |
| `maxListings` | integer | `20` | Stop after this many records are pushed. `0` = unlimited (walk the whole catalogue). |
| `resumeFromRunId` | string | none | Optional: a previous run ID (or its dataset ID) to continue. Records already saved there are skipped. |
| `incrementalMode` | boolean | `false` | Recurring monitoring: return only NEW/UPDATED/REAPPEARED records against the actor's own memory of the last run for this search. |
| `stateKey` | string | none | Optional label for the tracked search in Incremental mode. Auto-derived from filters when empty. |
| `ignoreFieldsForChanges` | string\[] | `[]` | Incremental mode only: field names (or dotted paths like `team.image`) excluded from change detection and `changedFields`. |
| `emitUnchanged` | boolean | `false` | Incremental mode only: also return UNCHANGED records (the full current snapshot every run). |
| `emitExpired` | boolean | `false` | Incremental mode only: also return EXPIRED records, and only when this run reached the natural end of the search with no cap or Resume in use. |
| `proxy` | object | Residential (`{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}`) | Connection settings. Residential is preselected and the most reliable choice; other connection types can work intermittently. |
| `mcpConnectors` | array | none | Optional: send a summary of each record to apps you authorized under Integrations. |
| `notionParentPageUrl` | string | none | Notion connector only: page under which records are created. |
| `maxNotifyListings` | integer | `50` | Cap on items written to each connector per run. Does not affect the dataset. |

#### Program attributes

Every record also carries program-style fields (always present, null when F6S does not show them): `entity_type`, `program_name`, `program_slug`, `program_url`, `program_type`, `program_classification`, `program_description`, `program_country`, `program_city`, `program_sector`, `program_benefits`, `program_investment_amount`, `program_equity_taken`, `program_duration`, `program_application_deadline`, `program_application_deadline_iso`, `program_application_url`, `program_website`. Description and website need Fetch details. The Output tab has four views: Overview, Details & contact, Program attributes (these fields) and Changes (Incremental mode), plus a run summary. F6S does not publish startup or investor lists without signing in, so only programs, accelerators, events and jobs are returned.

### Output Example

> Sample shape: values are illustrative placeholders, not from a live listing.

```json
{
  "id": "sample-accelerator-2026",
  "listType": "accelerators",
  "name": "Sample Accelerator 2026",
  "slug": "sample-accelerator-2026",
  "profileUrl": "https://www.f6s.com/sample-accelerator-2026",
  "aboutUrl": "https://www.f6s.com/sample-accelerator-2026/about",
  "applyUrl": "https://www.f6s.com/sample-accelerator-2026/apply",
  "image": "https://www.f6s.com/content-resource/profiles/00000001_th3.jpg",
  "location": "London, United Kingdom",
  "tags": "Funds Startups in AI, Fintech, SaaS",
  "verified": true,
  "deadline": "by Jan 1",
  "investmentRaw": "$100k per team",
  "investmentAmount": 100000,
  "investmentCurrency": "USD",
  "equityRaw": "6%",
  "equityPercent": 6,
  "description": "Full program description appears here when Fetch full details is on.",
  "category": "Accelerators",
  "country": "United Kingdom",
  "city": "London",
  "fundingCurrency": "USD",
  "fundingAmountMin": 100000,
  "fundingAmountMax": 100000,
  "website": "https://example.com/",
  "socialLinks": ["https://www.linkedin.com/company/example/"],
  "team": [{ "name": "Jane Doe", "url": "https://www.f6s.com/jane-doe", "image": null }],
  "sourceUrl": "https://www.f6s.com/accelerators",
  "scrapedAt": "2026-01-01T00:00:00.000Z"
}
```

### Plan Requirement

A Residential connection is preselected under **Proxy & connection** and is the most reliable choice for F6S. It is not strictly required: datacenter connections also work intermittently, because the actor clears the site's browser check before reading pages, but a given datacenter exit can be refused, so expect more retries and the odd failed run on them.

If your plan has no access to the selected connection (Apify free plans do not include residential proxies), the actor logs this warning and continues on a backup connection:

- "The selected connection is unavailable to this run."
- "Apify free plans do not include residential proxies."
- "Continuing on a backup connection; some pages may still be unavailable."
- "For residential access, upgrade at https://apify.com/pricing or supply your own proxy URLs."

When a backup connection actually serves pages, the log says "Served over the backup connection (the default connection was unavailable)." If no page can be loaded at all, the run fails with one of three messages: your account has no proxy access (check your plan or the credentials of your own proxy URLs); residential proxies are unavailable and the backup connection could not load the requested pages (upgrade or supply your own proxy URLs); or "Could not load any results page ... This is a connection problem, not an empty search." Try again later.

**Pricing.** Pay-per-event, as currently listed on the **Pricing** tab: a one-time start fee of $0.08 per run, $0.002 per record returned, and $0.0008 per record only when **Fetch full details** is on. That is about $2.08 per 1,000 records, or $2.88 per 1,000 with full details. Records are billed only when delivered; a run that finds nothing, or fails before reading any page, bills no records. Use **Max records** to cap the cost of any run.

### FAQ

#### How much does it cost?

About $2.08 per 1,000 records ($0.08 per run plus $0.002 per record), plus $0.0008 per record only when you turn on Fetch full details. The **Pricing** tab shows the current rates. Use **Max records** to cap the cost of any run.

#### Is it legal to scrape F6S?

This actor collects only publicly available directory data. You are responsible for how you use it: follow F6S's terms and the laws that apply to you, and get legal advice if you plan commercial redistribution.

#### Can I get only new or changed listings on a schedule?

Yes. Schedule the actor from the **Schedules** tab and turn on **Incremental mode**. Each run then returns only new and updated records by default. Note that `REAPPEARED` only shows up for a record that a previous run already tombstoned as `EXPIRED`, which itself requires **Also return records no longer found** to have been on for that earlier run. If you never use that setting, a temporarily missing record simply keeps its last state and is never classified `REAPPEARED`.

#### What's the difference between Resume and Incremental mode?

**Resume from run/dataset ID** continues one specific interrupted or capped run: you paste in that run's ID and the new run skips records it already saved. **Incremental mode** is for a search you run repeatedly on a schedule: the actor remembers it on its own, across separate runs, without you pasting any ID.

#### Why did my run fail instead of returning an empty dataset?

If every request to F6S is rejected, the run fails with a clear connection-problem message instead of silently returning nothing, so "no listings match" is never confused with "nothing could be read." A run also fails fast if URL mode is used with no URLs, if a pasted **Resume** ID cannot be read, or if Incremental mode is combined with Resume while saved state already exists for that search. If some pages are rejected partway through, the run keeps what it already collected and logs a warning; when that leaves zero records, the status message says the scan may be incomplete rather than a confirmed empty search.

#### Can I use it with AI agents or MCP?

Yes. Call it from any Apify integration or MCP client, and use the connector field to push results into Notion, Linear or Airtable.

### 🔗 Want more jobs data?

Pair this actor with these related scrapers from the same team:

<table>
<tr><td>📇 <a href="https://apify.com/abotapi/betalist-com-scraper"><b>BetaList Scraper</b></a><br>Scrape BetaList.com startup profiles with founder and contact enrichment. Extract startup...</td><td>💼 <a href="https://apify.com/abotapi/wellfound-jobs-scraper"><b>Wellfound Jobs Scraper</b></a><br>Scrape startup jobs from Wellfound.com by keyword, location, role, or remote status...</td></tr>
<tr><td>🛒 <a href="https://apify.com/abotapi/dealroom-co-scraper"><b>Dealroom.net Scraper</b></a><br>Scrape Dealroom.net market maps, company lookup results, live signals, and newly founded...</td><td>📇 <a href="https://apify.com/abotapi/ycombinator-com-scraper"><b>Ycombinator</b></a><br>Pull every ycombinator.com company across every batch, with founders, social URLs...</td></tr>
<tr><td>💼 <a href="https://apify.com/abotapi/hiring-cafe-scraper"><b>Hiring.Cafe Jobs</b></a><br>From $1/1K. Unlock powerful Hiring.Cafe job data extraction. Use advanced filters or URLs...</td><td>💼 <a href="https://apify.com/abotapi/gupy-io-scraper"><b>Gupy Jobs Scraper</b></a><br>Scrape public jobs from Gupy.io by keyword, state, city, workplace type, job type...</td></tr>
</table>

👉 [Browse all abotapi scrapers](https://apify.com/abotapi)

### 💬 Support

- 🐞 **Found a bug or a missing field?** Open a ticket on the [Issues tab](https://apify.com/abotapi/f6s-directory-scraper/issues/open). We usually reply within hours.
- 🛠️ **Need another site, extra fields or a private build?** Email <contact@abotapi.com>.
- ⭐ **Enjoying it?** A quick review on the actor page helps other users find it.

# Actor input Schema

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

How to start the scrape. 'search' builds list URLs from the filters below. 'url' takes the exact F6S list URLs you paste.

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

Which F6S directory to scrape in search mode.

## `location` (type: `string`):

Optional place to narrow results: a city or country name such as 'London', 'New York', 'Europe', or 'London, United Kingdom' (a URL slug like 'new-york' also works). Leave empty for worldwide. An unrecognised place stops the run with a clear message.

## `keyword` (type: `string`):

Optional free-text keyword, for example 'ai', 'fintech', 'climate'.

## `programType` (type: `string`):

Narrow programs to a subtype. Only applies when list type is Programs or Accelerators.

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

Optional country name, for example 'United Kingdom'. In search mode it narrows to that country (the site's own country list; Location wins when both are set) and results are also checked client-side. Applies in URL mode as a client-side filter.

## `stage` (type: `string`):

Optional startup stage the program targets. The site has no stage filter, so this keeps records whose description, tags or name mention the stage (best with Fetch details on).

## `sector` (type: `string`):

Optional sector or industry keyword such as 'fintech'. Sent to the site as a keyword filter (the Keyword field wins if both are set).

## `deadlineOnly` (type: `boolean`):

Keep only records that show an application deadline.

## `sortBy` (type: `string`):

Result ordering.

## `minInvestment` (type: `integer`):

Only keep programs offering at least this much per team.

## `maxInvestment` (type: `integer`):

Only keep programs offering at most this much per team.

## `maxEquity` (type: `integer`):

Only keep programs that take at most this much equity.

## `urls` (type: `array`):

Paste F6S URLs: list pages (programs, accelerators, events, jobs; any location, filter or ?page=N) or a single program/organisation page (https://www.f6s.com/<slug> or .../about, returned as one record). Left untouched, with the default Max records this scrapes at least one record from every supported shape. Filter fields above are ignored. Pagination starts at the page in the URL and walks forward.

## `fetchDetails` (type: `boolean`):

Open each profile's About page to add full description, funding amount, website, social links and team. Adds one HTTP request per record.

## `maxPages` (type: `integer`):

How many result pages to walk per list URL. 0 = unlimited (walk the whole list until it naturally runs out of new results). Max records is the setting that bounds a run by default.

## `maxListings` (type: `integer`):

Stop after this many records. This is the main limit on a run (0 = unlimited, walks the whole catalogue).

## `proxy` (type: `object`):

Network connection. This site requires a Residential connection, which is preselected. Datacenter and other connection types are blocked by the site and will not work.

## `resumeFromRunId` (type: `string`):

Paste a previous run ID (or its dataset ID) to continue that run: records already saved there are skipped, so this run only returns new records (a delta). Leave empty for a normal run. For a recurring/scheduled search, use Incremental mode below instead, it remembers the previous run itself, without pasting an id every time.

## `incrementalMode` (type: `boolean`):

For a search/list you run on a schedule (daily, weekly): the actor remembers the records it saw last time (in a dedicated key-value store, keyed by this search) and, by default, only returns records that are NEW, UPDATED or REAPPEARED. Compared: every returned field (name, location, tags, deadline, investment, description, team, ...). Excluded: scrapedAt, sourceUrl, image host/query and the order of tags/team/social links, plus any field you list in 'Ignore fields' below. Unlike Resume above, you never need to paste a run or dataset id, it tracks itself. Off by default: a normal run always returns every matching record.

## `stateKey` (type: `string`):

Optional label for the tracked search when Incremental mode is on, e.g. 'ai-accelerators-london'. Leave empty to let the actor derive one automatically from your search/URL filters, two different searches never share a baseline either way. Set this if you want a stable, human-readable name, or want to run the exact same search twice as two separate monitoring campaigns.

## `emitUnchanged` (type: `boolean`):

When Incremental mode is on, also return records with no changes since last time (changeType 'UNCHANGED'), not just NEW/UPDATED/REAPPEARED. Off by default. Returning unchanged rows bills like any other record, turn this on only if you need the full current snapshot every run, not just what changed.

## `emitExpired` (type: `boolean`):

When Incremental mode is on AND this run scans the search to its natural end (no Max records/Max pages cap reached, no Resume from a previous run), also return one row per previously-seen record no longer found (changeType 'EXPIRED'), using its last-known data. Off by default. Returning expired rows bills like any other record.

## `ignoreFieldsForChanges` (type: `array`):

Incremental mode only: field names that must NOT make a record UPDATED or appear in changedFields, e.g. 'deadline' or 'investmentRaw'. Use a dotted path for a nested field, e.g. 'team.image'. The fields are still returned in the output. Already ignored automatically: scrapedAt, sourceUrl, and the image host/query (only the image path is compared). Leave empty to compare every other field.

## `mcpConnectors` (type: `array`):

Optionally send the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize a connector once under Apify → Settings → Integrations, then select it here. The connector receives a condensed, human-readable summary per item (title + key fields), not the full JSON, the complete record stays in the dataset. Leave empty to skip. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

## `notionParentPageUrl` (type: `string`):

URL (or id) of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "listType": "programs",
  "location": "",
  "keyword": "",
  "programType": "any",
  "country": "",
  "stage": "",
  "sector": "",
  "deadlineOnly": false,
  "sortBy": "open",
  "urls": [
    "https://www.f6s.com/accelerators",
    "https://www.f6s.com/programs",
    "https://www.f6s.com/programs/london",
    "https://www.f6s.com/programs/united-kingdom/london",
    "https://www.f6s.com/programs/united-kingdom/london/software",
    "https://www.f6s.com/accelerators/london",
    "https://www.f6s.com/events",
    "https://www.f6s.com/events/london",
    "https://www.f6s.com/jobs",
    "https://www.f6s.com/jobs/london",
    "https://www.f6s.com/accelerators?page=2",
    "https://www.f6s.com/programs/london?page=2",
    "https://www.f6s.com/programs?keywords[]=ai&type[]=grant&sort=popular",
    "https://www.f6s.com/programs?type[]=grant",
    "https://www.f6s.com/blacknight-space-labs-w27-cohort",
    "https://www.f6s.com/blacknight-space-labs-w27-cohort/about",
    "https://www.f6s.com/startupbootcamp"
  ],
  "fetchDetails": false,
  "maxPages": 0,
  "maxListings": 20,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "ignoreFieldsForChanges": [],
  "maxNotifyListings": 50
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `programs` (type: `string`):

No description

## `details` (type: `string`):

No description

## `changes` (type: `string`):

No description

## `summary` (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 = {
    "mode": "search",
    "listType": "programs",
    "location": "",
    "keyword": "",
    "programType": "any",
    "country": "",
    "stage": "",
    "sector": "",
    "sortBy": "open",
    "urls": [
        "https://www.f6s.com/accelerators",
        "https://www.f6s.com/programs",
        "https://www.f6s.com/programs/london",
        "https://www.f6s.com/programs/united-kingdom/london",
        "https://www.f6s.com/programs/united-kingdom/london/software",
        "https://www.f6s.com/accelerators/london",
        "https://www.f6s.com/events",
        "https://www.f6s.com/events/london",
        "https://www.f6s.com/jobs",
        "https://www.f6s.com/jobs/london",
        "https://www.f6s.com/accelerators?page=2",
        "https://www.f6s.com/programs/london?page=2",
        "https://www.f6s.com/programs?keywords[]=ai&type[]=grant&sort=popular",
        "https://www.f6s.com/programs?type[]=grant",
        "https://www.f6s.com/blacknight-space-labs-w27-cohort",
        "https://www.f6s.com/blacknight-space-labs-w27-cohort/about",
        "https://www.f6s.com/startupbootcamp"
    ],
    "fetchDetails": false,
    "maxPages": 0,
    "maxListings": 20,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    },
    "ignoreFieldsForChanges": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/f6s-directory-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",
    "listType": "programs",
    "location": "",
    "keyword": "",
    "programType": "any",
    "country": "",
    "stage": "",
    "sector": "",
    "sortBy": "open",
    "urls": [
        "https://www.f6s.com/accelerators",
        "https://www.f6s.com/programs",
        "https://www.f6s.com/programs/london",
        "https://www.f6s.com/programs/united-kingdom/london",
        "https://www.f6s.com/programs/united-kingdom/london/software",
        "https://www.f6s.com/accelerators/london",
        "https://www.f6s.com/events",
        "https://www.f6s.com/events/london",
        "https://www.f6s.com/jobs",
        "https://www.f6s.com/jobs/london",
        "https://www.f6s.com/accelerators?page=2",
        "https://www.f6s.com/programs/london?page=2",
        "https://www.f6s.com/programs?keywords[]=ai&type[]=grant&sort=popular",
        "https://www.f6s.com/programs?type[]=grant",
        "https://www.f6s.com/blacknight-space-labs-w27-cohort",
        "https://www.f6s.com/blacknight-space-labs-w27-cohort/about",
        "https://www.f6s.com/startupbootcamp",
    ],
    "fetchDetails": False,
    "maxPages": 0,
    "maxListings": 20,
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
    "ignoreFieldsForChanges": [],
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/f6s-directory-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 '{
  "mode": "search",
  "listType": "programs",
  "location": "",
  "keyword": "",
  "programType": "any",
  "country": "",
  "stage": "",
  "sector": "",
  "sortBy": "open",
  "urls": [
    "https://www.f6s.com/accelerators",
    "https://www.f6s.com/programs",
    "https://www.f6s.com/programs/london",
    "https://www.f6s.com/programs/united-kingdom/london",
    "https://www.f6s.com/programs/united-kingdom/london/software",
    "https://www.f6s.com/accelerators/london",
    "https://www.f6s.com/events",
    "https://www.f6s.com/events/london",
    "https://www.f6s.com/jobs",
    "https://www.f6s.com/jobs/london",
    "https://www.f6s.com/accelerators?page=2",
    "https://www.f6s.com/programs/london?page=2",
    "https://www.f6s.com/programs?keywords[]=ai&type[]=grant&sort=popular",
    "https://www.f6s.com/programs?type[]=grant",
    "https://www.f6s.com/blacknight-space-labs-w27-cohort",
    "https://www.f6s.com/blacknight-space-labs-w27-cohort/about",
    "https://www.f6s.com/startupbootcamp"
  ],
  "fetchDetails": false,
  "maxPages": 0,
  "maxListings": 20,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "ignoreFieldsForChanges": []
}' |
apify call abotapi/f6s-directory-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/f6s-directory-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/HAwCLgsdsnv4Dn6pH/builds/zvwmqSFLXzcGyHSqv/openapi.json