# TaskRabbit Scraper (`solidcode/taskrabbit-scraper`) Actor

\[💰 $2.50 / 1K] Extract TaskRabbit taskers by city, service, search phrase, or URL. Get names, ratings, review counts, completed tasks, and Elite status for lead generation and market research.

- **URL**: https://apify.com/solidcode/taskrabbit-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Lead generation, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

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

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


# README

## TaskRabbit Scraper

Pull local-service providers from TaskRabbit at scale — every tasker's name, star rating, review count, completed-task total, Elite status, hourly rate, bio, and profile link, across 100+ US metros and roughly 211 services. Built for lead-generation teams, recruiters, and market researchers who need clean, structured local-service-provider data without copy-pasting profiles off TaskRabbit one page at a time.

### Why This Scraper?

- **Roughly 211 services across 16 groups** — Furniture Assembly, Mounting, Moving Help, Cleaning, Handyman, Yard Work, Packing, Electrical, Plumbing, Painting, and more, addressable by their TaskRabbit service name.
- **Elite Tasker flag on every record** — instantly isolate TaskRabbit's top-tier vetted providers with the `eliteOnly` toggle instead of eyeballing badges.
- **Three quality signals per tasker** — 0-to-5 average star rating, total review count, and lifetime completed-task count, each available as a hard filter (`minRating`, `minReviewCount`, `minTasksCount`).
- **Hourly rate captured per tasker** — the displayed rate (e.g. "$52.13/hr") plus the raw cents value and currency, ready for pricing analysis.
- **100+ US metros by name** — target Los Angeles, New York, Chicago, or any TaskRabbit city; each returns the full tasker roster for a service (up to ~675 providers per city-service pair) with no page-by-page clicking.
- **Five result sort modes** — order by highest rating, most reviews, most completed tasks, name A-to-Z, or leave in TaskRabbit's own ranking.
- **Rich profile detail** — per-tasker bio, experience level, reliability rate, avatar photo, spoken languages, special tools, vehicles, and the most-recent review snippet, not just a name and rating.
- **Keyword filter across four fields** — keep only taskers whose name, bio, service, or city contains your phrase, so a single run can surface, say, every "IKEA"-mentioning assembler in a metro.

### Use Cases

**Lead Generation**
- Build targeted lists of service providers by city and service type
- Isolate Elite taskers as premium outreach prospects
- Filter to taskers above a rating and review-count floor for quality leads
- Surface providers by keyword (a tool, language, or specialty they mention)

**Market Research**
- Map how many taskers serve a given service in each metro
- Compare provider supply for Furniture Assembly vs. Moving Help across cities
- Track Elite-tasker density as a signal of a market's maturity
- Benchmark average ratings and review volumes between markets

**Competitive Analysis**
- Monitor top-rated providers in a service category over time
- Identify the most-reviewed and most-completed taskers in a metro
- Watch which providers hold Elite status and which lose it
- Compare experience levels and reliability rates across a category

**Recruiting & Sourcing**
- Source skilled local contractors (handymen, movers, cleaners) by metro
- Shortlist providers by completed-task volume and reliability rate
- Filter by spoken languages for language-specific staffing needs
- Pull profile links for direct follow-up on TaskRabbit

**Pricing Intelligence**
- Collect hourly rates across a service and metro to benchmark market pricing
- Compare Elite vs. standard tasker rates in the same category
- Track rate distributions by experience level
- Feed rate data into quoting and estimation tools

### Getting Started

#### Simple — one search phrase

Just type what you'd search on TaskRabbit; the scraper works out the city and service:

```json
{
    "searchQueries": ["furniture assembly los angeles"]
}
````

#### By city and service

Pick TaskRabbit cities and services by name and the scraper covers every combination:

```json
{
    "cities": ["los-angeles", "new-york"],
    "categories": ["assemble-furniture", "help-moving"],
    "maxItems": 200
}
```

#### Advanced — filtered and sorted

Elite providers only, above a quality floor, sorted by review volume:

```json
{
    "cities": ["chicago"],
    "categories": ["house-cleaning", "mount-art-shelves"],
    "eliteOnly": true,
    "minRating": 4,
    "minReviewCount": 25,
    "minTasksCount": 50,
    "containsKeyword": "detail",
    "sortBy": "review-count-desc",
    "maxItems": 500
}
```

#### From TaskRabbit URLs

Paste direct TaskRabbit service links to scrape exactly those:

```json
{
    "startUrls": [
        "https://www.taskrabbit.com/services/furniture-assembly/assemble-furniture"
    ],
    "cities": ["seattle"]
}
```

### Input Reference

#### What to Scrape

Fill in whichever is easiest — you can combine them.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | string\[] | `["furniture assembly los angeles"]` | Free-text phrases like "furniture assembly los angeles". The scraper infers the city and service for you. |
| `cities` | string\[] | `[]` | TaskRabbit city names as they appear in the website address, e.g. `los-angeles`, `new-york`, `chicago`. Combined with your chosen services. |
| `categories` | string\[] | `[]` | TaskRabbit service names as they appear in the website address, e.g. `assemble-furniture`, `help-moving`, `mount-art-shelves`. Combined with your chosen cities. |
| `startUrls` | string\[] | `[]` | Direct links to TaskRabbit tasker or service listing pages to scrape exactly those. |

#### Filters & Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxItems` | integer | `50` | The most tasker records to return in total. Set to `0` to collect everything found. |
| `eliteOnly` | boolean | `false` | Return only taskers flagged as Elite by TaskRabbit. |
| `minRating` | integer | — | Skip taskers whose average rating is below this value (0 to 5). |
| `minReviewCount` | integer | — | Skip taskers with fewer reviews than this. |
| `minTasksCount` | integer | — | Skip taskers who have completed fewer tasks than this. |
| `containsKeyword` | string | — | Keep only taskers whose name, bio, service, or city contains this word or phrase. |
| `sortBy` | select | `Default (as found)` | Order results: Default, Highest rating first, Most reviews first, Most completed tasks first, or Name (A to Z). |

### Output

Each row is one tasker. Here's a representative record:

```json
{
    "recordType": "tasker",
    "taskerId": "profile_44556677",
    "userId": 44556677,
    "slug": "jordan-m",
    "name": "Jordan M.",
    "isElite": true,
    "averageRating": 4.9,
    "ratingPercentage": "100%",
    "reviewsCount": 312,
    "messageReviewsCount": 48,
    "tasksCount": 540,
    "hoursWorked": 1180,
    "hourlyRate": "$52.13/hr",
    "hourlyRateCents": 5213,
    "hourlyRateCurrency": "USD",
    "recommendedPriceCents": 5500,
    "photoUrl": "https://taskrabbit.imgix.net/photos/jordan-m.jpg",
    "bio": "Professional furniture assembler with 8 years of experience. IKEA specialist.",
    "categoryDescription": "Furniture Assembly pro since 2018",
    "experienceLevel": "expert",
    "identityLabel": "ID verified",
    "reliabilityRate": 99,
    "specialTools": "Power drill, socket set",
    "spokenLanguages": "English, Spanish",
    "vehicles": ["truck"],
    "nextAvailableAt": "2026-07-04T09:00:00Z",
    "categoryId": "33",
    "serviceName": "Furniture Assembly",
    "serviceFamily": "Furniture Assembly",
    "serviceSlug": "assemble-furniture",
    "city": "LA & OC",
    "citySlug": "los-angeles",
    "state": "California",
    "country": "United States",
    "postalCode": "90012",
    "mostRecentReview": { "comment": "Fast, friendly, and cleaned up after.", "author": "Alex R.", "date": "2026-06-28T18:12:00+00:00" },
    "profileUrl": "https://www.taskrabbit.com/profile/jordan-m",
    "sourceUrl": "https://www.taskrabbit.com/services/furniture-assembly/assemble-furniture",
    "scrapedAt": "2026-07-03T14:30:00Z"
}
```

#### Core & Quality Fields

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"tasker"` |
| `taskerId` | string | Unique TaskRabbit tasker identifier |
| `userId` | number | Underlying user account ID |
| `slug` | string | Profile URL slug |
| `name` | string | Tasker display name |
| `isElite` | boolean | Whether TaskRabbit flags this tasker as Elite |
| `averageRating` | number | Average star rating, 0 to 5 |
| `ratingPercentage` | string | TaskRabbit's positive-rating percentage (e.g. "100%") |
| `reviewsCount` | number | Total number of reviews |
| `messageReviewsCount` | number | Number of message-based reviews |
| `tasksCount` | number | Lifetime completed tasks |
| `hoursWorked` | number | Total hours worked on the platform |

#### Pricing & Profile

| Field | Type | Description |
|-------|------|-------------|
| `hourlyRate` | string | Displayed hourly rate (e.g. "$52.13/hr") |
| `hourlyRateCents` | number | Hourly rate in cents |
| `hourlyRateCurrency` | string | Currency code (e.g. "USD") |
| `recommendedPriceCents` | number | TaskRabbit's recommended price in cents |
| `photoUrl` | string | Avatar photo URL |
| `bio` | string | Tasker self-description |
| `categoryDescription` | string | Short service-specific descriptor |
| `experienceLevel` | string | Experience tier for the service |
| `identityLabel` | string | Identity-verification label |
| `reliabilityRate` | number | Reliability rate |
| `specialTools` | string | Tools the tasker brings |
| `spokenLanguages` | string | Languages the tasker speaks |
| `vehicles` | string\[] | Vehicles available for jobs |
| `nextAvailableAt` | string | Next available booking time |
| `mostRecentReview` | object | The tasker's most recent review: `comment` (review text), `author` (reviewer name), and `date` (ISO timestamp) |

#### Service, Location & Source

| Field | Type | Description |
|-------|------|-------------|
| `categoryId` | string | Numeric TaskRabbit service ID |
| `serviceName` | string | Human-readable service name (e.g. "Furniture Assembly") |
| `serviceFamily` | string | Parent service group |
| `serviceSlug` | string | Service slug you searched under |
| `city` | string | TaskRabbit metro name (e.g. "LA & OC") |
| `citySlug` | string | City slug you searched under |
| `state` | string | State / region |
| `country` | string | Country (default United States) |
| `postalCode` | string | Postal code of the search location |
| `profileUrl` | string | Direct link to the tasker's TaskRabbit profile |
| `sourceUrl` | string | The listing URL this tasker was found on |
| `scrapedAt` | string | ISO timestamp of extraction |

### Tips for Best Results

- **Find the city and service names in any TaskRabbit URL.** Open a service page like `taskrabbit.com/services/furniture-assembly/assemble-furniture` — the last path segment (`assemble-furniture`) is the `categories` value. For cities, use the slug from the site address (`los-angeles`, `new-york`), all lowercase with hyphens.
- **Prefer `cities` + `categories` over free-text phrases** for reliable results. The city-and-service combination is exact; search phrases have to guess where the city ends and the service begins.
- **Start with a small `maxItems`** (25–50) to confirm the data fits your needs, then raise it or set it to `0` for everything.
- **Combine many cities and services in one run** — the scraper covers every city-and-service combination automatically, so one run can span a whole region.
- **Stack the filters for tight lead lists** — `eliteOnly` plus `minRating`, `minReviewCount`, and `minTasksCount` narrows thousands of providers down to a premium shortlist in a single run.
- **Sort before you export** — set `sortBy` to "Most reviews first" or "Most completed tasks first" so the highest-signal taskers sit at the top of your dataset.
- **Use `containsKeyword` for niche specialties** — a tool, brand, or language mentioned in bios (e.g. "IKEA", "Spanish") pulls out providers a plain category search can't isolate.

### Pricing

**From $2.50 per 1,000 results** — a flat, predictable rate per tasker, with the lowest price for Gold-tier subscribers. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.30 | $0.28 | $0.27 | $0.25 |
| 1,000 | $3.00 | $2.80 | $2.65 | $2.50 |
| 10,000 | $30.00 | $28.00 | $26.50 | $25.00 |
| 100,000 | $300.00 | $280.00 | $265.00 | $250.00 |

A "result" is one tasker record in your dataset. **No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.**

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate market research, lead generation, and competitive analysis. You are responsible for complying with applicable laws and TaskRabbit's Terms of Service. Do not use extracted data for spam, harassment, or any unlawful purpose, and handle any personal data in line with privacy regulations such as GDPR and CCPA.

# Actor input Schema

## `searchQueries` (type: `array`):

Type what you'd search on TaskRabbit, for example 'furniture assembly los angeles'. The scraper works out the city and service for you. Add several phrases to run them all.

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

TaskRabbit city names as they appear in the website address, for example 'los-angeles', 'new-york', 'chicago'. Combined with the services you choose below.

## `categories` (type: `array`):

TaskRabbit service names as they appear in the website address, for example 'assemble-furniture', 'help-moving', 'mount-art-shelves'. Combined with the cities you choose above.

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

Paste direct links to TaskRabbit tasker or service listing pages to scrape exactly those.

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

The most tasker records to return in total across all your searches. Set to 0 to collect everything found.

## `eliteOnly` (type: `boolean`):

Return only taskers flagged as Elite by TaskRabbit.

## `minRating` (type: `integer`):

Skip taskers whose average rating is below this value (0 to 5).

## `minReviewCount` (type: `integer`):

Skip taskers with fewer reviews than this.

## `minTasksCount` (type: `integer`):

Skip taskers who have completed fewer tasks than this.

## `containsKeyword` (type: `string`):

Only keep taskers whose name, bio, service, or city contains this word or phrase.

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

Choose the order of the taskers in your results.

## Actor input object example

```json
{
  "searchQueries": [
    "furniture assembly los angeles"
  ],
  "cities": [],
  "categories": [],
  "startUrls": [],
  "maxItems": 50,
  "eliteOnly": false,
  "sortBy": "default"
}
```

# Actor output Schema

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

Table of scraped taskers with key fields.

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

Full tasker records including bio, photo, service, and location.

# 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 = {
    "searchQueries": [
        "furniture assembly los angeles"
    ],
    "cities": [],
    "categories": [],
    "startUrls": [],
    "maxItems": 50,
    "sortBy": "default"
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/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 = {
    "searchQueries": ["furniture assembly los angeles"],
    "cities": [],
    "categories": [],
    "startUrls": [],
    "maxItems": 50,
    "sortBy": "default",
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/taskrabbit-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "furniture assembly los angeles"
  ],
  "cities": [],
  "categories": [],
  "startUrls": [],
  "maxItems": 50,
  "sortBy": "default"
}' |
apify call solidcode/taskrabbit-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TaskRabbit Scraper",
        "description": "[💰 $2.50 / 1K] Extract TaskRabbit taskers by city, service, search phrase, or URL. Get names, ratings, review counts, completed tasks, and Elite status for lead generation and market research.",
        "version": "1.0",
        "x-build-id": "xu9QRiu2KA0TuRI8T"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~taskrabbit-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-taskrabbit-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/solidcode~taskrabbit-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-taskrabbit-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/solidcode~taskrabbit-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-taskrabbit-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQueries": {
                        "title": "Search phrases",
                        "type": "array",
                        "description": "Type what you'd search on TaskRabbit, for example 'furniture assembly los angeles'. The scraper works out the city and service for you. Add several phrases to run them all.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "cities": {
                        "title": "Cities",
                        "type": "array",
                        "description": "TaskRabbit city names as they appear in the website address, for example 'los-angeles', 'new-york', 'chicago'. Combined with the services you choose below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categories": {
                        "title": "Services",
                        "type": "array",
                        "description": "TaskRabbit service names as they appear in the website address, for example 'assemble-furniture', 'help-moving', 'mount-art-shelves'. Combined with the cities you choose above.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "TaskRabbit URLs",
                        "type": "array",
                        "description": "Paste direct links to TaskRabbit tasker or service listing pages to scrape exactly those.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum taskers",
                        "minimum": 0,
                        "type": "integer",
                        "description": "The most tasker records to return in total across all your searches. Set to 0 to collect everything found."
                    },
                    "eliteOnly": {
                        "title": "Elite taskers only",
                        "type": "boolean",
                        "description": "Return only taskers flagged as Elite by TaskRabbit.",
                        "default": false
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Skip taskers whose average rating is below this value (0 to 5)."
                    },
                    "minReviewCount": {
                        "title": "Minimum number of reviews",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Skip taskers with fewer reviews than this."
                    },
                    "minTasksCount": {
                        "title": "Minimum completed tasks",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Skip taskers who have completed fewer tasks than this."
                    },
                    "containsKeyword": {
                        "title": "Keyword filter",
                        "type": "string",
                        "description": "Only keep taskers whose name, bio, service, or city contains this word or phrase."
                    },
                    "sortBy": {
                        "title": "Sort results by",
                        "enum": [
                            "default",
                            "rating-desc",
                            "review-count-desc",
                            "tasks-count-desc",
                            "name-asc"
                        ],
                        "type": "string",
                        "description": "Choose the order of the taskers in your results.",
                        "default": "default"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
