# Startup Funding News & Founders: Crunchbase Alternative (`moggedhq/recently-funded-startups`) Actor

Find startups that just raised a seed or Series A round, with founders and emails, e.g. AI, fintech or SaaS startups funded this week. $0.05 per funded startup, $0.03 per founder email. Round, amount, investors, founders, phone, website, like Crunchbase funding rounds, from SEC Form D and news.

- **URL**: https://apify.com/moggedhq/recently-funded-startups.md
- **Developed by:** [mogged](https://apify.com/moggedhq) (community)
- **Categories:** Lead generation, AI
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $40.00 / 1,000 funded startups

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

## Startup Funding News & Founders: Crunchbase Alternative

**Find startups that just raised a seed or Series A round, with their founders and emails: for example AI, fintech or SaaS startups funded this week.**

**For sales teams, lead-gen agencies, recruiters and investors who want to reach startups the week they raise money.** Each row is one startup that just raised a round: company, location, round stage, amount and date, investors where announced, founders and executives with titles, phone, website, company emails, founder emails where they can be found (each labelled with a confidence level), and links to the sources.

**Price: $0.05 per funded startup, plus $0.03 per founder email with medium or high confidence.** Failed lookups, duplicates and filtered-out filings are free. No Crunchbase, PitchBook, Apollo or LinkedIn account needed.

**What to expect, measured on test runs of 40 startups:**

| You get | Share of startups |
|---|---|
| Founders or executives with titles | about 90% |
| Company phone | about 80% |
| Company website | about 2 in 3 |
| A company email (info@, hello@ and similar) | about 45% |
| A confirmed founder email (medium or high confidence, charged) | about 5 to 15% |
| An unconfirmed founder email guess (low confidence, free) | about half |

Many startups that file with the SEC are still in stealth, and most publish only role addresses, so confirmed founder emails are the exception, not the rule. You only pay for the ones we can confirm.

![Recently funded startups: share of 40 startups in a real test run with founders, phone, website, company email, LinkedIn page, investors and confirmed founder emails](https://api.apify.com/v2/key-value-stores/gsiO0QFIivl0QTUgA/records/funded-startups-coverage-v2.png)

### Real results from a test run

Seven of the 40 startups returned by a test run on 12 October 2026 (funded since: 7 days). Your results also include the founders' names and emails, which are left out of this picture.

![Recently funded startups table: startup, round, amount, date, location, website, people found, phone, founder email confidence and source, from a real run](https://api.apify.com/v2/key-value-stores/gsiO0QFIivl0QTUgA/records/funded-startups-table-v2.png)

### What one row looks like

Illustrative example (made-up company, real format):

| Field | Example |
|---|---|
| companyName | Northwind Robotics |
| website | https://northwind.example/ |
| roundStage | Seed (estimated from amount raised) |
| amountRaisedUsd | 3,200,000 |
| roundDate | 2026-10-02 |
| industry | Manufacturing & hardware |
| city, state, country | Austin, TX, United States |
| companyPhone | +1 512-555-0142 |
| founders | Dana Reyes, Chief Executive Officer, dana@northwind.example (medium: built from the {first}@ pattern seen in sam@northwind.example) |
| bestFounderEmail | dana@northwind.example |
| leadInvestors | Example Ventures (from the funding announcement) |
| sources | SEC Form D filing link, announcement link |

Three ready-made table views: **Funded startups** (one line per lead), **Contacts** (all founders, emails, phones, LinkedIn company page) and **Funding rounds** (stage, amount, investors, sources). Export to CSV, Excel, JSON or Google Sheets.

### Output fields

| Field | What it is |
|---|---|
| `companyName`, `description`, `industry`, `foundedYear` | The startup and what it does |
| `website`, `websiteConfidence`, `websiteFoundBy` | Company website, how sure the match is (high or medium) and how it was found |
| `city`, `state`, `country`, `address` | Where the company is based |
| `companyPhone`, `otherPhones`, `companyEmails` | Phone numbers and published company addresses (info@, hello@ and similar) |
| `companyLinkedinUrl`, `companyTwitterUrl` | Company social pages, when the company links them |
| `roundStage`, `roundStageSource` | Seed, Series A and so on, and whether it was stated in an announcement or estimated from the amount |
| `amountRaisedUsd`, `amountRaised`, `currency`, `amountIsApproximate` | Amount raised, in US dollars and in the original currency |
| `securityType`, `offeringAmountUsd` | Equity, SAFE, convertible note or debt, and the total offering size where filed |
| `roundDate`, `announcedDate` | Date of first sale or announcement, and the filing or announcement date |
| `leadInvestors`, `investors`, `investorsCount` | Investors named in the announcement, and the number of investors in the filing |
| `founders` | Each founder, executive or director: name, title, role, email, `emailConfidence`, `emailSource` and source |
| `bestFounderName`, `bestFounderEmail`, `bestFounderEmailConfidence` | The best person to contact first |
| `emailPattern`, `domainAcceptsMail` | The company's email format when it can be learned, and whether the domain has mail servers |
| `previousFundingFilings`, `previousFundingFilingDates` | Earlier SEC funding filings by the same company |
| `dataSources`, `sources`, `secFilingUrl`, `secCik` | Where every fact came from, with links |
| `founderEmailsCharged`, `collectedAt` | How many emails were charged for this row, and when it was collected |

### Who uses it

- **Sales and SDR teams**: startups that just raised are buying software, services, offices and hires. Reach the founder in the first weeks after the round.
- **Lead-gen and outbound agencies**: a fresh list every day for clients selling to startups, with a confidence label on every email so you know what to verify.
- **Recruiters**: new funding means new hiring plans.
- **Investors and analysts**: track seed and Series A activity by state, industry and size, straight from SEC filings.
- **Automation builders and AI agents**: run it from n8n, Make, Zapier, Clay or the Apify API and push leads into your CRM.

### How to use it

1. **Open the Actor and fill in the form.** Click **Try for free** on this page (or open the Actor in Apify Console). Set **Funded since** (for example `7 days`) and **Maximum number of startups**. Optional filters: **Funding stage**, **Industry**, **Minimum amount raised**, **Countries**, **US states** and **Keywords**.
2. **Press Start.** A run of 25 startups usually takes two to three minutes; 100 startups take about ten minutes. You can close the page; the run carries on in the cloud.
3. **Download the results.** When the run finishes, open the **Output** tab and click **Export** to download **Excel** or **CSV** (JSON, XML and Google Sheets work too). Pick the view you need first: **Funded startups** (one line per lead), **Contacts** or **Funding rounds**.

All input fields:

| Input | What it does | Default |
|---|---|---|
| `since` | How far back to look: `7 days`, `1 day`, `yesterday` or a date | `7 days` |
| `maxLeads` | Maximum startups to return (caps your cost) | 25 |
| `fundingStages` | Pre-seed, Seed, Series A, Series B, Series C+, Other or unknown | all |
| `industries` | Technology & software, Health care & biotech, Fintech, Energy & climate, Manufacturing & hardware, Consumer, and more | all except real estate |
| `minAmountUsd` / `maxAmountUsd` | Round size in US dollars | from 100,000 |
| `countries` / `usStates` | For example `United States`, or `CA`, `NY` | all |
| `keywords` | Match in name, description or industry, for example `AI` | none |
| `includeFounderEmails` | Find founder and executive emails | on |
| `includeGuessedEmails` | Add a free, clearly labelled low-confidence guess when nothing is confirmed | on |
| `excludePublicCompanies` | Skip listed companies | on |
| `onlyYoungCompanies` | Only companies incorporated in the last five years | off |
| `skipPreviouslyDelivered` | Never return a startup an earlier run already returned | off |
| `sources` | SEC Form D filings and/or funding news | both |

API example:

```json
{
  "since": "7 days",
  "maxLeads": 100,
  "fundingStages": ["Seed", "Series A"],
  "industries": ["Technology & software"],
  "usStates": ["CA", "NY"],
  "minAmountUsd": 1000000
}
```

### Schedule it: a daily feed of newly funded startups

1. Save your filters as a task (or use one of the ready-made tasks on this page).
2. Set **Funded since** to `2 days` and turn on **Only startups not delivered before**.
3. Add a schedule (Schedules, Create new, every day at 07:00).
4. Connect the output to Google Sheets, Slack, your CRM, Clay, n8n or Make with an integration.

Every morning you get only the startups that are new since yesterday, and you never pay twice for the same company.

### Where the data comes from

![How Recently Funded Startups works: you choose filters, it reads SEC Form D filings and funding news, finds the company website and people, and returns one row per startup](https://api.apify.com/v2/key-value-stores/gsiO0QFIivl0QTUgA/records/funded-startups-how-it-works-v2.png)

- **SEC Form D filings (United States).** A startup that sells shares, SAFEs or convertible notes to investors files a Form D with the SEC within 15 days of the first sale. Filings are public and appear on EDGAR the day they are filed. They give the legal name, address, phone, industry, amount raised, date of first sale, number of investors and the executives and directors. Investment funds, SPVs, real-estate vehicles, REITs and public companies are filtered out so you get operating startups.
- **Funding news and press releases.** Announced rounds from public press release and startup news sources, read the day they appear. They give the round name (Seed, Series A, and so on), lead and other investors, the founders quoted, and companies outside the US (Europe, Israel, Asia). When a news round also has a Form D, both are merged into one row.
- **The company's own website.** The homepage and the contact, about and team pages give company emails, phone numbers, the LinkedIn company page and email addresses of staff.

Every row lists its sources with links, so you can check any fact in one click.

### How websites are matched

Form D filings do not include a website, so the Actor finds it: first from links in the company's own funding announcement, then by web search, then by checking the obvious domains. Each row says how sure it is in `websiteConfidence`:

- **high**: the company's announcement links to the site, or the site names a founder or matches the filing's city, phone number or postcode.
- **medium**: the domain and page title match the company name, but nothing else on the site confirms it. Check these before outreach; different companies often share a name.
- Sites that show an address in a different US state from the filing are rejected, and the row is returned without a website rather than with the wrong one.

### How founder emails are found

Each email comes with `emailConfidence` and `emailSource` that say exactly how it was found:

| Confidence | How | Charged |
|---|---|---|
| **high** | The address itself is published on the company website or in the funding announcement | yes, $0.03 |
| **medium** | Seen on a third-party page in public search results, or built from the address pattern the company really uses, learned from another published address at the same domain (for example `sam@` means `{first}@`), on a website we matched with high confidence; the domain accepts mail | yes, $0.03 |
| **low** | Most common startup pattern (`firstname@domain`) when nothing could be confirmed; the domain accepts mail | no, free |

Guesses are never passed off as verified. We check that the domain has mail servers, but we do not send test emails, so run medium and low addresses through your email verifier before a large campaign. Board directors named in a filing are usually investors, so they are listed without a company email.

### Pricing

Pay per result, no subscription:

- **$0.05 per funded startup** returned with its round and people.
- **$0.03 per founder email** with medium or high confidence.
- Free: low-confidence guesses, filtered-out filings, duplicates and failed lookups.

Example: 100 startups with 10 confirmed founder emails cost about $5.30. Set **Maximum cost per run** in the run options and the Actor stops cleanly when it is reached.

#### Pricing examples

Measured on test runs, about 5 to 15 in every 100 startups get a confirmed founder email.

| Run | Startups | Confirmed founder emails | You pay |
|---|---|---|---|
| Quick test | 10 | about 1 | about $0.53 |
| Default run | 25 | about 2 | about $1.31 |
| Weekly list | 100 | about 10 | about $5.30 |
| Large pull | 500 | about 50 | about $26.50 |

Apify's Bronze, Silver and Gold plans pay 5%, 10% and 20% less per startup and per email. Apify platform usage is included.

### Compared with Crunchbase, PitchBook and Apollo

| | This Actor | Crunchbase / PitchBook | Apollo and similar contact tools |
|---|---|---|---|
| Price | $0.05 per startup, pay as you go | Annual seat subscriptions (PitchBook runs to thousands of dollars a year) | Monthly seats plus credits |
| Freshness | SEC filings and news read the day they appear | Depends on their research and user edits | Not focused on new rounds |
| Founders and contacts | Founders and executives for about 90% of startups; founder emails where they can be confirmed, each with a confidence label | Limited or extra cost | Yes, but you need the company list first |
| Automation | API, schedules, webhooks, CRM and Sheets integrations, AI agents | API on higher plans | API on higher plans |

### Use it from code (API)

Every example below starts a run, waits for it to finish and reads the results. Replace `YOUR_APIFY_TOKEN` with your token from Apify Console (**Settings**, **API & Integrations**). Each item is one startup; the fields are listed under **Output fields** above.

**Python** (`pip install apify-client`, version 3 or later)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("moggedhq/recently-funded-startups").call(run_input={
    "since": "7 days",
    "maxLeads": 5,
    "fundingStages": ["Seed", "Series A"],
})

for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item["companyName"], item["roundStage"], item["amountRaisedUsd"], item["website"])
```

**JavaScript / Node.js** (`npm install apify-client`, save as `main.mjs`)

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('moggedhq/recently-funded-startups').call({
    since: '7 days',
    maxLeads: 5,
    fundingStages: ['Seed', 'Series A'],
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((s) => console.log(s.companyName, s.roundStage, s.amountRaisedUsd, s.website));
```

**cURL** (waits for the run and saves the results as a CSV file; use `format=json` or `format=xlsx` for other formats)

```bash
curl -X POST "https://api.apify.com/v2/acts/moggedhq~recently-funded-startups/run-sync-get-dataset-items?format=csv" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"since": "7 days", "maxLeads": 5, "fundingStages": ["Seed", "Series A"]}' \
  -o results.csv
```

#### No-code: n8n, Make and Zapier

- **n8n:** add the Apify node, choose the **Run Actor** operation and pick `moggedhq/recently-funded-startups`, or call the cURL address above from an **HTTP Request** node.
- **Make:** use the Apify app's **Run an Actor** module, then **Get Dataset Items** to pass each row to Google Sheets, a CRM or email.
- **Zapier:** use the Apify app's **Run Actor** action, or the **Finished Actor Run** trigger to send every new result set to Sheets, Slack or your CRM.

### Use with AI agents (MCP)

The Apify MCP server (`https://mcp.apify.com`) lets Claude, ChatGPT, Cursor, VS Code and other MCP clients call this Actor as a tool, fill in the input from a plain request, and read the rows back. Input fields use plain names (`since`, `fundingStages`, `industries`, `minAmountUsd`, `usStates`), so an agent can fill them from a sentence like "seed rounds in California this week".

**Claude Code:**

```bash
claude mcp add apify "https://mcp.apify.com/?tools=moggedhq/recently-funded-startups" -t http
```

**Cursor, VS Code and other clients that take a server URL** (`mcp.json`):

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=moggedhq/recently-funded-startups"
    }
  }
}
```

**Clients that only run local servers:**

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server", "--tools", "moggedhq/recently-funded-startups"],
      "env": { "APIFY_TOKEN": "YOUR_APIFY_TOKEN" }
    }
  }
}
```

Example prompt:

> Find seed and Series A startups in California that raised money in the last 7 days, at most 20. Give me a table with company, amount, founder, website and any confirmed founder email.

The agent reads `companyName`, `roundStage`, `amountRaisedUsd`, `website`, `bestFounderName` and `bestFounderEmail` with its `bestFounderEmailConfidence`, so it can say which emails are confirmed and which are guesses. The same Actor also works from Clay, Google Sheets and webhooks through Apify integrations.

### FAQ

**Is it legal to use this data?**
The Actor only reads public sources: SEC filings published by the U.S. government, public press releases and news, and companies' own websites. It does not log in anywhere and does not scrape LinkedIn. Your results contain personal data (names, job titles and business emails of executives), which is protected by laws such as GDPR in the European Union and CAN-SPAM in the United States. You should only collect and use personal data when you have a legitimate reason, and you are responsible for your outreach complying with privacy and anti-spam laws (for example, identify yourself and honour opt-outs). If you are unsure, consult your lawyer.

**Do I need a Crunchbase, PitchBook, Apollo or LinkedIn account?**
No. Everything comes from public sources. This Actor is independent and is not affiliated with or endorsed by the SEC, Crunchbase, PitchBook, Apollo or Y Combinator; their names are used only to describe data sources and alternatives.

**How fresh is the data?**
SEC filings are read from EDGAR the same day they are filed, and news is read as it is published. Startups file Form D within 15 days of their first sale, so a Form D row usually describes a round that closed in the last few weeks; `roundDate` shows the date of first sale and `announcedDate` the filing or announcement date.

**Why is the stage "estimated" for some rows?**
Form D does not name the round. For those rows the stage is estimated from the amount raised (under $1.5M pre-seed, under $5M seed, under $20M Series A, under $60M Series B, above that Series C+) and `roundStageSource` says so. Rows from funding news use the stage named in the announcement.

**Why do some startups have no website or email?**
Many startups that file a Form D are still in stealth with no public website. You still get the company, address, phone from the filing and the names and titles of the founders. These rows are charged as a funded startup only; no email is charged unless it has medium or high confidence.

**Which countries are covered?**
SEC Form D covers US companies and foreign companies raising from US investors. Funding news adds rounds announced in Europe, Israel, Asia and elsewhere.

**Does it return investors?**
Yes for rounds from funding news (lead investors and other participants as named in the announcement). Form D filings do not list investors, only how many there are (`investorsCount`).

**Something looks wrong?**
Open an issue on the Issues tab with the company name and we will look at it.

### Limitations

- Founder emails are confirmed from published addresses and patterns, not by sending mail. Verify medium and low addresses before large campaigns.
- About a third of SEC filers are in stealth or have no findable website; those rows have the filing's phone, address and executives but no email.
- Stage for SEC-only rows is an estimate from the amount raised.
- Investor names come only from funding announcements.
- Some company websites block automated reading; those rows may lack company emails.

### More tools from mogged

- [Hiring Leads](https://apify.com/moggedhq/hiring-leads): companies hiring now, with open roles and the people to contact
- [Google Ads Keyword Planner Scraper](https://apify.com/moggedhq/keyword-search-volume): Google search volume, CPC and keyword difficulty for any keyword list
- [Google Maps Rank Tracker](https://apify.com/moggedhq/google-maps-rank-tracker): geo grid rank checks and heatmaps for local SEO
- [Technical SEO Audit Tool](https://apify.com/moggedhq/seo-audit-tool): a full website SEO audit with a score and a fix list

# Actor input Schema

## `since` (type: `string`):

How far back to look for new funding rounds. Write a number of days such as "7 days" or "30 days", "yesterday", or a date such as 2026-10-01. For a daily feed, schedule the Actor every day with "1 day" or "2 days" and turn on "Only startups not delivered before".

## `maxLeads` (type: `integer`):

How many funded startups (leads) to return at most. You pay per startup returned, so this also caps the cost. Newest rounds come first.

## `fundingStages` (type: `array`):

Only return these rounds. Leave empty for all stages. News gives the stage named in the announcement; for SEC Form D filings the stage is estimated from the amount raised (under $1.5M pre-seed, under $5M seed, under $20M Series A, under $60M Series B, above that Series C+).

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

Only return startups in these industries. Leave empty for all (real estate is left out unless you pick it).

## `minAmountUsd` (type: `integer`):

Skip rounds smaller than this, in US dollars. The default of 100,000 leaves out tiny friends-and-family filings. Set 0 to include everything.

## `maxAmountUsd` (type: `integer`):

Skip rounds larger than this, in US dollars. Leave empty for no limit.

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

Only return startups based in these countries, written in full, for example "United States", "United Kingdom", "Germany". Leave empty for all. SEC Form D covers US companies and some foreign companies raising from US investors; funding news adds Europe, Israel and others.

## `usStates` (type: `array`):

Only return US startups in these states, as two-letter codes, for example CA, NY, TX. Leave empty for all.

## `keywords` (type: `array`):

Only return startups whose name, description or industry contains one of these words, for example "AI", "robotics", "payments".

## `includeFounderEmails` (type: `boolean`):

Find email addresses for founders and executives. Each email says how it was found and how sure we are (high, medium or low). Only emails with high or medium confidence are charged. This returns personal data (names and business emails of company executives). You are responsible for having a legal basis to collect and use it under privacy and anti-spam laws such as GDPR and CAN-SPAM.

## `includeGuessedEmails` (type: `boolean`):

When no address could be confirmed, add the most common startup pattern (firstname@company.com) as a low-confidence guess so you can check it with your own email verifier. Guesses are clearly labelled and never charged.

## `excludePublicCompanies` (type: `boolean`):

Skip companies that are already listed on a stock exchange or file annual reports with the SEC.

## `onlyYoungCompanies` (type: `boolean`):

Skip SEC filers that say they were incorporated more than five years ago.

## `skipPreviouslyDelivered` (type: `boolean`):

Remember which startups earlier runs returned (in a key-value store in your account) and skip them, so a daily schedule only returns new ones and you never pay twice for the same company.

## `sources` (type: `array`):

Where to look for new funding rounds. SEC Form D filings are official US filings made after a private raise; funding news covers announced rounds with round names and investors.

## Actor input object example

```json
{
  "since": "7 days",
  "maxLeads": 3,
  "minAmountUsd": 100000,
  "includeFounderEmails": true,
  "includeGuessedEmails": true,
  "excludePublicCompanies": true,
  "onlyYoungCompanies": false,
  "skipPreviouslyDelivered": false,
  "sources": [
    "sec-form-d",
    "funding-news"
  ]
}
```

# Actor output Schema

## `leads` (type: `string`):

No description

## `contacts` (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 = {
    "since": "7 days",
    "maxLeads": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("moggedhq/recently-funded-startups").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 = {
    "since": "7 days",
    "maxLeads": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("moggedhq/recently-funded-startups").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 '{
  "since": "7 days",
  "maxLeads": 3
}' |
apify call moggedhq/recently-funded-startups --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,moggedhq/recently-funded-startups"
        }
    }
}
```

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/WGVckL6ZMFStXyuUz/builds/pGNnh7XUFxhxf7KuA/openapi.json