# Taskrabbit Scraper \[$1.90/1K💰] | Taskers by City + Service (`ahmed_jasarevic/taskrabbit-scraper`) Actor

Extract TaskRabbit tasker profiles and client reviews by city and service. Get names, ratings, review counts, tasks completed, Elite badges and bios across 6,751 city + service pages - no browser, no login, no proxy. Built for home-service lead generation and market research.

- **URL**: https://apify.com/ahmed_jasarevic/taskrabbit-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.90 / 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

## TaskRabbit Scraper — Tasker Data by City and Service for Lead Gen and Market Research

Scrape **TaskRabbit tasker profiles and client reviews by city × service** — ratings, review counts, tasks completed, Elite badges, bios, photos and testimonial text across **6,751 published city × service pages**.

Built for lead-gen teams, home-service franchises, gig-economy researchers and pricing-intelligence tools. **No browser, no login, no proxy required** — the whole run is plain static-HTML requests.

***

### Main use cases

- **Home-service lead lists** — build a target list of top-rated taskers per city and service, ready for outreach
- **Local competitor mapping** — see who dominates assembly, plumbing, moving or cleaning in each metro
- **Gig-economy and TaskRabbit market research** — coverage maps across cities, service mix and Elite-badge concentration
- **Service-demand analysis** — rank metros by how deep TaskRabbit's tasker bench is for a given service
- **Review mining** — pull the client testimonials TaskRabbit publishes on each page, which name taskers in free text
- **Franchise and territory planning** — quantify the tasker pool available in a market before entering it

***

### Data source: the server-rendered `__NEXT_DATA__` JSON blob

This Actor does **not** render pages with a browser and does **not** touch TaskRabbit's internal booking or GraphQL APIs. It reads the server-rendered JSON that Next.js embeds in every geo-marketing page.

#### Endpoint

```
https://www.taskrabbit.com/locations/{citySlug}/{serviceSlug}
```

Example: `https://www.taskrabbit.com/locations/los-angeles/plumbing`

Each of those pages ships this blob in the raw HTML — no JS execution required:

```html
<script id="__NEXT_DATA__" type="application/json">{ ... }</script>
```

#### Exact JSON path and fields used

```
props.pageProps.page.bff
```

| Field in the blob | What the Actor uses it for |
|---|---|
| `bff.featuredTaskers.taskers[]` | **The tasker rows** — name, id, rating, review count, tasks count, Elite flag, bio, photo |
| `bff.featuredTaskers.header` / `linkUrl` | Section context |
| `bff.location.{name, locationNameState, v3MetroId}` | City, state, metro id |
| `bff.service.{name, v3CategoryId, v3TaskTemplateId}` | Service, category id, task-template id |
| `bff.taskerCount` | Total taskers available in that city × service (e.g. `3528`) |
| `bff.reviews.reviews[]` | Optional client reviews (name, rating, text, service link) |
| `bff.seo.{title, description}` | Page SEO context |

#### Why this source was chosen

1. **It works with plain `curl`.** Geo pages return `HTTP 200` with a normal desktop User-Agent — no Cloudflare challenge, no Turnstile, no bot-management wall. `CheerioCrawler` is sufficient; a browser would add roughly 50× the cost for zero extra data.
2. **The data is already in the HTML.** Tasker objects are in the initial server payload, not fetched client-side. Nothing needs rendering.
3. **The heavier internal APIs are a dead end and were deliberately rejected:**
   - `POST /api/v3/rabbits` → `403` *"Something is wrong with your browser settings"* (anti-bot cookie gate)
   - `POST https://api.taskrabbit.com/graphql` → `500` on every query, including `{__typename}` and introspection
   - `/next-api/trpc/*` is the booking-funnel API — every probe returned tRPC `NOT_FOUND`, and the real tasker-list query is only reachable after a job draft (an address) is created, i.e. authenticated booking state
4. **Enumeration of city × service pages uses the sitemap, with a link-discovery fallback:**
   - Primary: `https://www.taskrabbit.com/sitemap.xml` (served gzip-encoded *in the body*, with **no** `content-encoding` header — the Actor sniffs the `1f 8b` magic bytes and inflates it) → `https://www.taskrabbit.com/sitemaps/www.taskrabbit.com/geo_marketing_pages.xml.gz` → **6,751** `locations/{city}/{service}` URLs
   - TaskRabbit's edge frequently returns `404` for the sitemap to datacenter IPs (including Apify's). When that happens the Actor switches to crawling the location index instead: `/locations` (193 cities) → `/locations/{city}` (that city's services) → the geo pages. City and service lists come from the pages' own `bff.locations` / `bff.services` blobs rather than scraped links, because scraped links also catch site-wide nav and footer entries whose combinations `404` and would waste the page budget. Cities are walked one at a time and the walk stops the moment `maxRequestsPerCrawl` is full. Both paths honour the `cities`, `services` and page-budget inputs, so the result is the same — only the number of list requests differs.
5. **There are no public tasker profile pages.** `/profiles/{id}`, `/tasker/{id}` and `/experts/{id}` all return 404 or redirect to login. TaskRabbit deliberately does not expose a public per-tasker page, so `profileUrl` points at the city × service page that publicly lists that tasker.

**Net effect:** the whole run is plain static-HTML requests with a realistic desktop User-Agent. No proxy is required for normal volumes.

***

### Input

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `cities` | array | no | `[]` (all 193) | City slugs, e.g. `los-angeles`, `chicago`, `austin`. Leave empty for every city TaskRabbit lists. |
| `services` | array | no | `[]` (all) | Service slugs, e.g. `plumbing`, `electrical-work`, `house-cleaning`. Leave empty for every service available in the selected cities. |
| `includeReviews` | boolean | no | `true` | Also emit client reviews into the separate `reviews` dataset. Billed per review. |
| `maxRequestsPerCrawl` | integer | no | `100` | **Main volume control.** How many city × service pages to fetch. Each page yields taskers *and* up to 6 reviews, so 100 pages ≈ 500 taskers and ~550 reviews. |
| `startUrls` | array | no | `[]` | Explicit `locations/{city}/{service}` URLs. When set, city/service discovery is skipped entirely. |
| `proxy` | object | no | `useApifyProxy: false` | Standard Apify proxy picker. |
| `maxTaskersPerPage` | integer | no | `50` | Safety cap on taskers taken per page. *Hidden (advanced).* |
| `maxConcurrency` | integer | no | `3` | Parallel page requests. *Hidden (advanced).* |
| `requestHandlerTimeoutSecs` | integer | no | `60` | Per-request timeout. *Hidden (advanced).* |

**The three advanced limits are hidden from the input form on purpose** — the defaults suit almost everyone. They are still accepted through the Apify API or the CLI if you need to tune them.

```bash
apify call oMTaUiw6fwiHrg4Vd -i '{"cities":["los-angeles"],"maxRequestsPerCrawl":500}'
```

***

### Output

Two separate datasets, each with its own table and schema in the **Output** tab.

| Dataset | Alias | Contents | Billed as |
|---|---|---|---|
| **Taskers** | `default` | one row per featured tasker | automatic default-dataset-item event |
| **Reviews** | `reviews` | one row per client review | `review-added` pay-per-event |

#### Taskers dataset (default)

| Field | Description |
|---|---|
| `taskerId` | TaskRabbit's internal numeric id |
| `taskerName` | Display name |
| `city`, `cityState`, `citySlug`, `metroId` | Location context of the page the tasker was listed on |
| `service`, `serviceSlug`, `categoryId`, `taskTemplateId` | Service context |
| `rating` | Average rating (0–5) |
| `reviewCount` | Total reviews received |
| `tasksCompleted` | Total tasks completed |
| `isElite` | `true` if TaskRabbit marks them Elite |
| `bio` | Self-written description, control chars and NBSPs cleaned |
| `photoUrl` | Profile photo |
| `profileUrl` / `cityServiceUrl` | Source page (see Known limitations) |
| `totalTaskersInCityService` | `bff.taskerCount` — the size of the pool this page is a slice of |
| `hourlyRateMin` / `hourlyRateMax` | Always `null` — see Known limitations |
| `scrapedAt` | ISO timestamp |

#### Reviews dataset (`reviews`)

| Field | Description |
|---|---|
| `reviewId` | Review identifier |
| `reviewerName` | Client display name |
| `city`, `service`, `categoryId`, `taskTemplateId` | Page context, repeated on every row |
| `rating` | Star rating |
| `reviewText` | Review body — TaskRabbit's name appears inside the free text |
| `serviceLinkUrl` | The city × service page the review came from |
| `scrapedAt` | ISO timestamp |

***

### Example input

Two metros, two services, modest page budget:

```json
{
  "cities": ["los-angeles", "austin"],
  "services": ["plumbing", "furniture-assembly"],
  "maxRequestsPerCrawl": 40
}
```

Broad sweep — 500 pages is roughly 2,500 taskers and 2,800 reviews:

```json
{ "maxRequestsPerCrawl": 500 }
```

Every published city × service page (6,751 of them — needs a generous cap):

```json
{ "maxRequestsPerCrawl": 5000, "maxConcurrency": 5 }
```

Single specific page, bypassing discovery:

```json
{ "startUrls": ["https://www.taskrabbit.com/locations/chicago/plumbing"] }
```

***

### Example output

Tasker row:

```json
{
  "taskerId": "5923230",
  "taskerName": "Alex R.",
  "city": "Los Angeles",
  "cityState": "CA",
  "citySlug": "los-angeles",
  "metroId": "9001",
  "service": "Plumbing",
  "serviceSlug": "plumbing",
  "categoryId": "1042",
  "taskTemplateId": "88123",
  "rating": 4.9,
  "reviewCount": 312,
  "tasksCompleted": 640,
  "isElite": true,
  "bio": "Licensed plumber with 12 years of experience. Same-day appointments available.",
  "photoUrl": "https://res.cloudinary.com/taskrabbit-com/image/upload/azshsq1zulzfymkvabel",
  "profileUrl": "https://www.taskrabbit.com/locations/los-angeles/plumbing",
  "totalTaskersInCityService": 3528,
  "hourlyRateMin": null,
  "hourlyRateMax": null,
  "scrapedAt": "2026-09-29T12:00:00.000Z"
}
```

Review row:

```json
{
  "reviewId": "88213",
  "reviewerName": "Dana",
  "city": "Los Angeles",
  "cityState": "CA",
  "service": "Furniture Assembly",
  "categoryId": "1042",
  "taskTemplateId": "88123",
  "rating": 5,
  "reviewText": "Alex was fantastic — arrived early and put everything together in under an hour.",
  "serviceLinkUrl": "https://www.taskrabbit.com/locations/los-angeles/furniture-assembly",
  "scrapedAt": "2026-09-29T12:00:00.000Z"
}
```

***

### Run TaskRabbit monitoring on a schedule

Every Apify Actor is callable over HTTP, so recurring coverage maps and watchlists are straightforward:

- **Weekly** — same `cities` / `services` set; diff `tasksCompleted` and `reviewCount` to see which taskers are gaining traction
- **Monthly** — sweep a new batch of cities to grow a national coverage map, keyed on `citySlug` × `serviceSlug`
- **Per service line** — one saved input per service category you sell into, so each gets its own dataset and its own schedule
- **Push to your stack** — Apify webhooks, Zapier, Make, Google Sheets and 100+ integrations fire on run completion; results export as JSON, CSV, Excel, XML, HTML or RSS

Because each page yields both taskers and reviews, one scheduled run refreshes two datasets at once.

***

### Related Actors

- [TaskRabbit Scraper](https://apify.com/crawlerbros/taskrabbit-scraper) (`crawlerbros/taskrabbit-scraper`) — mode-based tasker extraction (search, by city, by category, by URL) with a dropdown city/service taxonomy
- [TaskRabbit Scraper](https://apify.com/solidcode/taskrabbit-scraper) (`solidcode/taskrabbit-scraper`) — per-metro tasker rosters with five result sort modes
- [Freelancer Jobs Scraper](https://apify.com/ahmed_jasarevic/freelancer-jobs-scraper) — real-time project leads from the freelance marketplace side of the gig economy
- [Angi Scraper](https://apify.com/ahmed_jasarevic/angi-scraper) — contractor leads, reviews and ratings from another home-services marketplace
- [HomeAdvisor Scraper](https://apify.com/ahmed_jasarevic/homeadvisor-scraper) — home-improvement contractor lead lists from a second marketplace

***

### FAQ

#### Why not use the official TaskRabbit API instead?

TaskRabbit's Developer Hub exposes one **gated Partner API** (`developer.taskrabbit.com`) covering Delivery (inherited from Dolly's PAPI) and a 2025-12-versioned Home Services platform for *quoting and booking* — Estimate, Availability, Bid, Book. There is no public self-serve API, no API key you can sign up for yourself, and no endpoint that returns a tasker roster for research. Everything this Actor collects is on public marketing pages.

#### What are the alternatives to this Actor?

- **Browser-based scrapers** — roughly 50× the cost per run, and they still have to defeat the same anti-bot cookie gate on `/api/v3/rabbits`.
- **Scraping the internal GraphQL API** — returns HTTP 500 on every query, including `{__typename}` and full introspection.
- **Human research** — the only other way to compile a multi-city tasker list.

#### Why are hourly rates always `null`?

TaskRabbit does not publish per-tasker hourly rates on any public surface. Rates are negotiated inside the login-walled booking flow, and `/services/*` pages only carry generic "starting at around $X per hour" marketing copy. The fields exist so downstream pricing models have a stable schema; real rate data would require a logged-in booking session.

#### How many taskers do I actually get per page?

About **5–6**. `featuredTaskers` is a curated top slice of a much larger pool — the same page reports a `taskerCount` of 1,000–6,000, and that total is returned on every row as `totalTaskersInCityService` so you can gauge coverage. The full roster is only reachable through the login-walled booking funnel. Raise `maxRequestsPerCrawl` and vary `services` / `cities` to widen the net.

#### How do I get more reviews?

Raise the page count — that is the only lever. TaskRabbit publishes a fixed 6 testimonials per page, so expect roughly `6 × maxRequestsPerCrawl` reviews. A measured 22-page run produced 127 reviews (~6 per page). Reviews are city-specific, so different cities do not duplicate each other.

#### Are reviews linked to individual taskers?

No. `bff.reviews.reviews` is always exactly 6 testimonials per city × service page — the payload has no cursor, page, offset, `hasMore` or `totalCount` field, and there is no public reviews API (`/api/v3/reviews` → 404, the GraphQL API → 500). `taskerId` is therefore `null` on review rows, and TaskRabbit's name appears only inside the free text. That is also why there is deliberately **no "max reviews" input** — such a control could only ever lower the 6.

#### Do I need a proxy or API key?

No. Everything used here is publicly served static HTML that returns HTTP 200 with a normal desktop User-Agent. `proxy` defaults to `useApifyProxy: false`. The sitemap often 404s from datacenter IPs — that is expected and harmless; the run log says `Sitemap discovery failed (...); discovering via /locations instead.` and the fallback takes over.

#### How much does it cost?

Tasker rows are billed at **$0.0019–$0.002 per row**, so roughly **$1.90–$2.00 per 1,000 taskers**. Reviews are a separate `review-added` event priced independently in the Apify Console, so `includeReviews: false` gives you a tasker-only run at tasker price. Free accounts are capped at 100 tasker rows per run.

***

### For AI Agents & LLM Apps

Callable via the Apify MCP server and the Apify API. Returns tasker profiles (default dataset) and client reviews (second dataset).

**Minimal valid input** — 100 city × service pages, all cities and services:

```json
{ "maxRequestsPerCrawl": 100 }
```

**Targeted metro + service list:**

```json
{
  "cities": ["los-angeles", "austin"],
  "services": ["plumbing", "furniture-assembly"],
  "maxRequestsPerCrawl": 40
}
```

**Taskers only, cheapest run** — drops every review event from the bill:

```json
{ "cities": ["chicago"], "services": ["plumbing"], "includeReviews": false }
```

**Exact pages, no discovery** — `startUrls` bypasses the city/service walk entirely:

```json
{ "startUrls": ["https://www.taskrabbit.com/locations/chicago/plumbing"] }
```

**Output fields** — taskers: `taskerId`, `taskerName`, `city`, `cityState`, `citySlug`, `metroId`, `service`, `serviceSlug`, `categoryId`, `taskTemplateId`, `rating`, `reviewCount`, `tasksCompleted`, `isElite`, `bio`, `photoUrl`, `profileUrl`, `cityServiceUrl`, `totalTaskersInCityService`, `hourlyRateMin`, `hourlyRateMax`, `scrapedAt`. Reviews: `reviewId`, `reviewerName`, `city`, `cityState`, `service`, `categoryId`, `taskTemplateId`, `rating`, `reviewText`, `serviceLinkUrl`, `scrapedAt`.

**Behaviors an agent should know**

- **`maxRequestsPerCrawl` is the only volume control.** There is no page/pagination input and no "reviews per tasker" input. Expect roughly **5–6 taskers and 6 reviews per page**.
- **`startUrls` takes priority over `cities` and `services`.** If both are supplied, discovery is skipped entirely and only the given pages are fetched.
- **`includeReviews` defaults to `true`,** so a default run bills review events. Set it to `false` for a tasker-only run.
- **Empty `cities` / `services` means "everything",** which is a very large surface (193 cities, 6,751 city × service pages). Always pair it with an explicit `maxRequestsPerCrawl`.
- **`hourlyRateMin` and `hourlyRateMax` are always `null`.** Do not build pricing logic on them — TaskRabbit does not publish per-tasker rates publicly.
- **`totalTaskersInCityService` is the pool size, not the row count.** It is often 1,000–6,000 while only 5–6 taskers are returned per page, so coverage is a small fraction of the pool.
- **Review rows have no `taskerId`** — the testimonials are page-level, not per-tasker. Join reviews to taskers only via `city` + `service`.
- **`profileUrl` is a city × service page, not a personal profile page.** TaskRabbit exposes no public per-tasker URL; do not treat it as a direct profile link.
- **Free accounts are capped at 100 tasker rows** per run regardless of `maxRequestsPerCrawl`.

**Billing model** — pay per event: one `result` event per tasker row ($0.0019–$0.002) and one `Review` (`review-added`) event per review row, priced independently in the Console. The run stops cleanly if the user's charge budget is exhausted rather than producing unbilled rows.

***

### Legal & Compliance Disclaimer

This Actor is an independent third-party tool. It is not affiliated with, endorsed by, sponsored by, or connected to TaskRabbit, IKEA, or Ingka Group.

It reads **only publicly served static HTML** from `www.taskrabbit.com` public geo-marketing pages. It does not log in, does not create a TaskRabbit account, does not submit bookings or job drafts, does not bypass the login wall, does not solve CAPTCHAs, and does not use proxies by default. It deliberately does not request the internal booking, GraphQL or tRPC endpoints.

Extracted tasker rows include **display names, profile photos, self-written bios and public review counts**, and review rows include **client display names and free-text reviews**. That is personal data. TaskRabbit publishes it publicly, but you are responsible for your own lawful basis for processing it — and for complying with TaskRabbit's Terms of Service and any messaging or outreach law that applies to you, including CAN-SPAM, TCPA, GDPR and UK GDPR. Do not use this data for unsolicited commercial outreach without a valid basis.

This Actor is a data-collection tool; it does not provide legal advice and makes no claim that any particular use is permitted.

***

### SEO Keywords

taskrabbit scraper, taskrabbit data, taskrabbit api, taskrabbit tasker data, taskrabbit taskers by city, home service leads, gig economy data, taskrabbit lead generation, local service provider database, taskrabbit reviews, plumber leads, furniture assembly leads, moving company leads, handyman leads, contractor lead generation, home services market research, taskrabbit alternative, taskrabbit dataset, service provider directory data, taskrabbit city coverage map, elite tasker data, home improvement lead list, competitor mapping home services

# Actor input Schema

## `cities` (type: `array`):

City (location) slugs to scrape, e.g. los-angeles, chicago, austin. Leave empty to use every city TaskRabbit lists.

## `services` (type: `array`):

Service slugs to scrape, e.g. plumbing, electrical-work, house-cleaning. Leave empty to use every service available for the selected cities.

## `includeReviews` (type: `boolean`):

Also collect client reviews into the separate reviews dataset. Reviews are billed separately, one event per review.

## `maxRequestsPerCrawl` (type: `integer`):

How many 'city x service' pages to fetch in this run. This is the main volume control: each page returns both taskers and up to 6 reviews, so 100 pages is roughly 500 taskers and 550 reviews. Raise it to collect more, lower it to spend less.

## `startUrls` (type: `array`):

Optional explicit list of https://www.taskrabbit.com/locations/{city}/{service} URLs. When set, cities/services/discovery is skipped.

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

Select proxies to be used by your crawler.

## `maxTaskersPerPage` (type: `integer`):

Safety cap on how many featured taskers are taken from each geo page.

## `maxConcurrency` (type: `integer`):

Number of parallel page requests.

## `requestHandlerTimeoutSecs` (type: `integer`):

Per-request timeout.

## Actor input object example

```json
{
  "cities": [],
  "services": [],
  "includeReviews": true,
  "maxRequestsPerCrawl": 100,
  "startUrls": [],
  "proxy": {
    "useApifyProxy": false
  },
  "maxTaskersPerPage": 50,
  "maxConcurrency": 3,
  "requestHandlerTimeoutSecs": 60
}
```

# Actor output Schema

## `taskers` (type: `string`):

Tasker profiles scraped from TaskRabbit city x service pages (default dataset).

## `reviews` (type: `string`):

Client reviews scraped from the same TaskRabbit pages (separate reviews 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 = {
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/taskrabbit-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 = { "proxy": { "useApifyProxy": False } }

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/taskrabbit-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 '{
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/taskrabbit-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/taskrabbit-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/oMTaUiw6fwiHrg4Vd/builds/aIxUnnG8kTweFjAOM/openapi.json