# Thumbtack Professionals Scraper (`automation-lab/thumbtack-professionals-scraper`) Actor

Find and export public Thumbtack professionals by service, city, state, or profile URL. Get ratings, reviews, hires, badges, prices, media, and links.

- **URL**: https://apify.com/automation-lab/thumbtack-professionals-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## Thumbtack Professionals Scraper

**Thumbtack Professionals Scraper** finds public local-service professionals by category and US location or extracts known profile URLs.
It returns clean lead records with business names, ratings, reviews, hire signals, badges, pricing context, media, and canonical links.
No Thumbtack login, private account, or API key is required.

Use it for repeatable **contractor prospecting**, local-market coverage research, reputation monitoring, and competitive intelligence.
Choose a service, city, and state; start with five records; then export the dataset as JSON, CSV, Excel, XML, or RSS.

### What does Thumbtack Professionals Scraper do?

The Actor opens public [Thumbtack](https://www.thumbtack.com) category and professional pages in a real browser.
It resolves Thumbtack's JavaScript challenge and reads structured application data rather than relying only on fragile visual selectors.

It supports three workflows:

- 🔍 **Search** by service category plus US city/state or ZIP code.
- 📚 **Browse** a public service category using the run's US location context.
- 👤 **Extract profiles** from canonical Thumbtack professional URLs.

Search results and profile details use one consistent professional-record schema.
Direct profile extraction enriches the same row with description, years in business, employee count, media count, and credentials when visible.

### Who is Thumbtack Professionals Scraper for?

**Local-service marketing agencies**

- Build prospect lists by trade and metro area.
- Prioritize providers with strong ratings but limited digital visibility.
- Refresh campaign lists on a schedule instead of rebuilding spreadsheets manually.

**Field-service SaaS sales teams**

- Find cleaning, plumbing, HVAC, landscaping, moving, and other service businesses.
- Segment leads by reviews, hires, response time, Top Pro status, or background-check signals.
- Send records to a CRM through Make, Zapier, webhooks, or the Apify API.

**Franchise, insurance, and partnership teams**

- Compare provider coverage across cities.
- Identify established operators using experience and hire signals.
- Research public marketplace credentials before outreach or deeper verification.

**Market researchers and analysts**

- Track category density, rating distributions, and visible price context.
- Monitor selected profiles for review, badge, description, or media changes.
- Create reproducible snapshots for local-market reports.

### Why use this Thumbtack scraper?

- ✅ **No Thumbtack account required** — it reads public pages only.
- ✅ **Location-aware search** — use a city/state or an exact five-digit ZIP code.
- ✅ **Search and profile modes together** — discover leads or enrich known URLs.
- ✅ **Structured-state extraction** — more resilient than CSS-only scraping.
- ✅ **Fail-closed filters** — missing source values never silently pass a requested threshold.
- ✅ **Typed flat records** — ready for spreadsheets, BI tools, CRMs, and databases.
- ✅ **Duplicate control** — each Thumbtack service ID is emitted once per run.
- ✅ **Apify-native automation** — schedule runs, call an API, use webhooks, or connect through MCP.

### What Thumbtack professional data can you extract?

| Data group | Fields | Example |
|---|---|---|
| Identity | `proId`, `name`, `businessName` | `524848507703738374`, `Moreira’s cleaning` |
| Service | `serviceCategory`, `serviceDescription` | `house-cleaning` |
| Location | `city`, `state`, `zipCode` | `Sharon`, `CT`, `06069` |
| Reputation | `rating`, `reviewCount`, `reviewQualifier` | `5`, `20`, `Exceptional` |
| Marketplace activity | `hireCount`, `responseTime`, `inHighDemand` | `16`, `within an hour`, `false` |
| Business profile | `yearsInBusiness`, `numEmployees` | `4`, `1 employee` |
| Trust signals | `isVerified`, `isBackgroundChecked`, `topPro` | `true`, `true`, `false` |
| Commercial context | `price`, `highlightedReview` | `Contact for price` |
| Media and links | `avatarUrl`, `mediaCount`, `profileUrl` | Public image and profile URLs |
| Provenance | `recordType`, `siteName`, `scrapedAt` | `professional`, `Thumbtack`, ISO time |

Fields appear only when Thumbtack makes them visible for that listing or profile.
Optional fields are omitted instead of filled with invented values.

### How much does it cost to scrape Thumbtack professionals?

This Actor uses **pay-per-event pricing**.
A small one-time start event covers browser startup, and each saved professional uses one result event.
Apify platform usage is included according to the active Store pricing record.

| Apify plan tier | Start | Per professional |
|---|---:|---:|
| Free | $0.005 | $0.00071106 |
| Starter / Bronze | $0.005 | $0.00061831 |
| Scale / Silver | $0.005 | $0.00048228 |
| Business / Gold | $0.005 | $0.00037099 |
| Platinum | $0.005 | $0.00024733 |
| Diamond | $0.005 | $0.00017313 |

At the Free-tier rate, 10 saved professionals cost about **$0.0121** including the start event.
One hundred saved professionals in one run cost about **$0.0761** including the start event.
The final charge is visible before and after each Apify run.

With $5 of monthly Free-plan credits, the per-result component alone covers about 7,000 records; browser availability and source volume determine actual throughput.
Start with a five-record run to verify the category and location before increasing volume.

### How to scrape Thumbtack professionals by city

1. Open **Thumbtack Professionals Scraper** on Apify.
2. Select **Search by service and location**.
3. Enter a Thumbtack service slug such as `house-cleaning`, `plumbers`, or `personal-trainers`.
4. Enter a US city and two-letter state code.
5. Optionally enter an exact ZIP code for precise targeting.
6. Set a small maximum such as `5` or `10`.
7. Add rating, review, Top Pro, or background-check filters if needed.
8. Click **Start**.
9. Preview the dataset, then export it or connect an integration.

A city/state search resolves a representative public ZIP code.
Provide `zipCode` when a metro spans many ZIP codes or when reproducibility matters most.

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search`, `byCategory`, or `byProfile` |
| `category` | string | `house-cleaning` | Thumbtack category slug for search/category modes |
| `profileUrls` | array | sample public profile | Canonical Thumbtack `/service/<id>` URLs |
| `city` | string | `San Francisco` | US city for search mode |
| `state` | string | `CA` | Two-letter US state code |
| `zipCode` | string | none | Optional exact five-digit location override |
| `maxItems` | integer | `10` | Maximum unique professionals, from 1 to 100 |
| `minRating` | number | none | Minimum visible rating from 0 to 5 |
| `minReviews` | integer | none | Minimum visible review count |
| `topProOnly` | boolean | `false` | Keep only visible Top Pro records |
| `backgroundCheckedOnly` | boolean | `false` | Keep only visible background-checked records |
| `proxyConfiguration` | object | direct connection | Optional Apify Proxy fallback |

Mode-specific validation is strict.
Direct profile mode requires at least one valid Thumbtack service URL.
Search mode requires a valid city/state pair or an explicit ZIP code.

### Search input example

Find house cleaners around San Francisco:

```json
{
  "mode": "search",
  "category": "house-cleaning",
  "city": "San Francisco",
  "state": "CA",
  "maxItems": 10
}
````

Use a ZIP code and reputation filters for New York plumbers:

```json
{
  "mode": "search",
  "category": "plumbers",
  "zipCode": "10001",
  "minRating": 4.8,
  "minReviews": 10,
  "maxItems": 20
}
```

### Direct Thumbtack profile input example

Use `byProfile` when you already know the professional URLs:

```json
{
  "mode": "byProfile",
  "profileUrls": [
    {
      "url": "https://www.thumbtack.com/ct/sharon/house-cleaning/moreiras-cleaning/service/524848507703738374"
    }
  ],
  "maxItems": 1
}
```

Only public `thumbtack.com` paths containing `/service/<numeric-id>` are accepted.
Query parameters are removed from canonical output links.

### Output example

```json
{
  "proId": "524848507703738374",
  "name": "Moreira’s cleaning",
  "businessName": "Moreira’s cleaning",
  "serviceCategory": "commercial-cleaning",
  "serviceDescription": "Ready to make your home shine. We are cleaning experts.",
  "city": "Sharon",
  "state": "CT",
  "zipCode": "06069",
  "rating": 5,
  "reviewCount": 20,
  "reviewQualifier": "Exceptional",
  "hireCount": 16,
  "yearsInBusiness": 4,
  "numEmployees": "1 employee",
  "isVerified": true,
  "isBackgroundChecked": true,
  "topPro": false,
  "price": "Contact for price",
  "mediaCount": 49,
  "profileUrl": "https://www.thumbtack.com/ct/sharon/house-cleaning/moreiras-cleaning/service/524848507703738374",
  "recordType": "professional",
  "siteName": "Thumbtack",
  "scrapedAt": "2026-07-23T06:54:09.893Z"
}
```

Numbers are emitted as numbers and booleans as booleans.
URLs are absolute and timestamps use ISO 8601 UTC.

### How filters behave

Filters apply after extraction and before a row is saved or charged.
They deliberately **fail closed**:

- If `minRating` is set and a listing has no parseable rating, it is excluded.
- If `minReviews` is set and a listing has no parseable count, it is excluded.
- If `topProOnly` is true, only an explicit Top Pro signal passes.
- If `backgroundCheckedOnly` is true, only an explicit background-check signal passes.

This behavior prevents unknown values from being mistaken for verified qualifications.
Run without filters first when evaluating a new category.

### Search coverage and pagination

A public Thumbtack category page normally exposes roughly 10–15 professionals in its initial structured payload.
The Actor saves up to `maxItems` from that payload.
For broader coverage, run multiple category/ZIP combinations and merge records by `proId`.

`maxItems` is a hard cap, not a promise that the source contains that many matching professionals.
Strict filters can naturally produce fewer rows.
Category browse mode reflects the browser's US location context unless you provide a ZIP code.

### Tips for reliable results

- 🎯 Use an exact ZIP code for repeatable metro targeting.
- 🧪 Start with `maxItems: 5` before scheduling larger workflows.
- 🧹 Use the category slug shown in Thumbtack URLs, not a sentence or keyword list.
- 🔗 Prefer canonical service profile URLs without tracking parameters.
- 📊 Test filters separately before combining several strict conditions.
- 🕐 Schedule moderate refreshes; public professional data rarely requires minute-by-minute polling.
- 🧭 Search neighboring ZIP codes when a market spans several cities.
- 🪪 Treat badges as marketplace signals, not as substitutes for independent credential checks.

### Integrate Thumbtack data with Google Sheets

Use the Apify Google Sheets integration to append each run's professional records to a lead workbook.
A practical workflow is:

1. Run one task per service category and ZIP code.
2. Append rows to a shared sheet.
3. Deduplicate on `proId`.
4. Assign outreach owners by city or category.
5. Refresh weekly and compare `reviewCount`, `rating`, and `topPro`.

This creates a lightweight local-market CRM without custom infrastructure.

### Integrate with Make, Zapier, Slack, and webhooks

**Thumbtack → Make or Zapier**

Trigger a scenario after a successful run, filter for high-rating providers, and create CRM contacts or enrichment jobs.

**Thumbtack → Slack or Discord**

Schedule direct-profile monitoring and post an alert when a provider's rating, review count, badge, description, or price context changes.

**Thumbtack → database or data warehouse**

Send the dataset webhook to an ingestion endpoint and upsert rows using `proId` as the stable source key.

**Thumbtack → qualification workflow**

Use `isBackgroundChecked` and `topPro` only as routing signals, then perform the independent checks required by your organization.

### Use the Apify API with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/thumbtack-professionals-scraper').call({
  mode: 'search',
  category: 'house-cleaning',
  city: 'Austin',
  state: 'TX',
  maxItems: 10,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Keep the API token in an environment variable rather than source control.
The returned run object contains links to logs, dataset storage, and usage information.

### Use the Apify API with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("automation-lab/thumbtack-professionals-scraper").call(run_input={
    "mode": "search",
    "category": "plumbers",
    "zipCode": "10001",
    "maxItems": 10,
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

Use scheduled Actor tasks when the same search should run repeatedly.
Store the `proId` and `scrapedAt` fields to compare snapshots over time.

### Use the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~thumbtack-professionals-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "mode": "search",
    "category": "personal-trainers",
    "city": "Chicago",
    "state": "IL",
    "maxItems": 5
  }'
```

For long-running automation, use the asynchronous `/runs` endpoint and poll the run status.
For small workflows, the synchronous dataset endpoint returns records directly.

### Use Thumbtack Professionals Scraper with AI agents via MCP

The Actor is available to AI assistants through Apify's hosted [Model Context Protocol](https://docs.apify.com/platform/integrations/mcp) server.

For Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/thumbtack-professionals-scraper"
```

For Claude Desktop, Cursor, or VS Code, add this configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/thumbtack-professionals-scraper"
    }
  }
}
```

Your client will ask you to authenticate with Apify.

**Example prompts**

Try these prompts:

- “Use `automation-lab/thumbtack-professionals-scraper` to find house cleaners in Austin, Texas with at least 20 reviews.”
- “Extract this public Thumbtack professional profile and summarize its reputation and business signals.”
- “Create a weekly monitor for five Thumbtack profiles and alert me when review counts or badges change.”

### Is it legal to scrape Thumbtack?

This Actor extracts publicly available professional marketplace information.
Scraping public data is generally legal in many jurisdictions, but the purpose, scale, storage, and use of data matter.

You are responsible for complying with Thumbtack's terms, applicable privacy and database laws, and outreach regulations.
Do not use the Actor to collect private account information, circumvent access controls, harass professionals, or make automated eligibility decisions without appropriate review.

Minimize personal data, keep only what your workflow requires, honor deletion requests where applicable, and use reasonable refresh intervals.
Marketplace badges and background-check labels should be verified independently before high-impact decisions.

### Troubleshooting empty or short datasets

**Why did I receive fewer rows than `maxItems`?**

`maxItems` is a cap.
The page may expose fewer professionals, filters may exclude records, or the chosen category/ZIP combination may have limited coverage.
Run without filters, verify the category slug, and try a neighboring ZIP code.

**Why did the run fail instead of returning an empty dataset?**

A total extraction failure is treated as an error so broken source pages are not mistaken for valid zero-result markets.
Inspect the run log, retry once, and enable a US Apify Proxy fallback if repeated logs show browser blocking.

**Why is a profile URL rejected?**

Direct URLs must use `thumbtack.com` and contain a canonical `/service/<numeric-id>` path.
Search pages, sign-in links, shortened URLs, and other domains are rejected to preserve product scope.

### Performance and resource use

The Actor runs Chromium with images, fonts, media, and common analytics requests blocked.
A category or profile page usually completes within tens of seconds, including the JavaScript challenge.
The default memory allocation is 1024 MB.

Pages are processed conservatively to reduce block risk and source load.
Direct browsing is the default and avoids proxy bandwidth charges.
If you enable a proxy fallback, residential or datacenter transfer may add platform usage according to your Apify plan.

### Data quality and known limitations

- Thumbtack controls which fields are visible for each professional and category.
- Category pages provide listing-level data; direct profiles provide richer optional fields.
- Public page structure and marketplace labels can change.
- The initial category payload is finite and may not include every provider in a metro.
- `isVerified` represents visible Thumbtack trust signals, not independent verification by Automation Lab.
- City/state lookup chooses a representative ZIP; provide `zipCode` for exact targeting.
- Highlighted review text may be a source-provided excerpt rather than the full review.
- No private contact details, account data, or messages are accessed.

### FAQ

**How fast is the Thumbtack scraper?**

A small category or profile run typically finishes in tens of seconds.
The browser must resolve Thumbtack's public JavaScript challenge before structured data becomes available.

**Does it require a Thumbtack login or API key?**

No.
The Actor accesses public professional and category pages without a Thumbtack account.

**Can it search any US city?**

Search mode accepts a city and two-letter state code and resolves a representative ZIP through a public place directory.
For the most reliable location, enter a five-digit ZIP directly.

**Can I scrape more than one category in a run?**

One category is processed per search run.
Create several Apify tasks or API calls, then merge datasets using `proId`.

**How are records charged?**

The start event is charged once per run, and the result event is charged only for each record saved after filtering and deduplication.
Rejected or duplicate rows are not result events.

**Is this an official Thumbtack API?**

No.
It is an independent public-web data extraction Actor and is not affiliated with or endorsed by Thumbtack.

**Can I use results for cold outreach?**

You must comply with applicable marketing, privacy, anti-spam, and platform rules.
Use public business context responsibly and maintain suppression and opt-out processes.

### Other lead generation and business directory scrapers

Combine this Actor with other Automation Lab tools:

- [Yellow Pages Scraper](https://apify.com/automation-lab/yellowpages-scraper) for public local-business directory records.
- [Google Maps Shared List Scraper](https://apify.com/automation-lab/google-maps-shared-list-scraper) for places saved in public Maps lists.
- [Google Search Scraper](https://apify.com/automation-lab/google-search-scraper) for broader business discovery and web presence research.
- [Hitta.se Business Directory Scraper](https://apify.com/automation-lab/hitta-se-business-directory-scraper) for Swedish company discovery.
- [Search.ch Swiss Business Directory Scraper](https://apify.com/automation-lab/search-ch-swiss-business-directory-scraper) for Swiss local businesses.
- [Singapore BCA Registered Contractors Scraper](https://apify.com/automation-lab/singapore-bca-registered-contractors-scraper) for official Singapore contractor records.

Use source-specific IDs when joining datasets and preserve each source URL for traceability.

# Actor input Schema

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

Choose location search, category browsing, or direct professional profile extraction.

## `category` (type: `string`):

Enter the Thumbtack category slug, for example house-cleaning, plumbers, handyman, personal-trainers, or photographers.

## `profileUrls` (type: `array`):

Add public Thumbtack URLs containing /service/<numeric-id>. Used only in Direct profile URLs mode.

## `city` (type: `string`):

Enter a US city. Search mode resolves it to a representative ZIP code unless ZIP code is provided.

## `state` (type: `string`):

Enter the two-letter US state abbreviation, such as CA, NY, TX, or FL.

## `zipCode` (type: `string`):

Optionally provide exactly five digits for precise location targeting and to skip city lookup.

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

Stop after saving this many unique professional records. A category page normally provides about 10–15 records.

## `minRating` (type: `number`):

Keep only professionals whose visible rating meets this threshold. Missing ratings do not pass.

## `minReviews` (type: `integer`):

Keep only professionals with at least this many visible reviews. Missing counts do not pass.

## `topProOnly` (type: `boolean`):

Return only records where Thumbtack visibly marks the professional as a Top Pro.

## `backgroundCheckedOnly` (type: `boolean`):

Return only records whose visible profile signals include a completed background check.

## `proxyConfiguration` (type: `object`):

Optionally configure Apify Proxy for a retry if direct browser extraction is blocked.

## Actor input object example

```json
{
  "mode": "search",
  "category": "house-cleaning",
  "profileUrls": [
    {
      "url": "https://www.thumbtack.com/ct/sharon/house-cleaning/moreiras-cleaning/service/524848507703738374"
    }
  ],
  "city": "San Francisco",
  "state": "CA",
  "maxItems": 5,
  "topProOnly": false,
  "backgroundCheckedOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `professionals` (type: `string`):

Open the default dataset table containing extracted Thumbtack professionals.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "search",
    "category": "house-cleaning",
    "profileUrls": [
        {
            "url": "https://www.thumbtack.com/ct/sharon/house-cleaning/moreiras-cleaning/service/524848507703738374"
        }
    ],
    "city": "San Francisco",
    "state": "CA",
    "maxItems": 5,
    "topProOnly": false,
    "backgroundCheckedOnly": false,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/thumbtack-professionals-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "mode": "search",
    "category": "house-cleaning",
    "profileUrls": [{ "url": "https://www.thumbtack.com/ct/sharon/house-cleaning/moreiras-cleaning/service/524848507703738374" }],
    "city": "San Francisco",
    "state": "CA",
    "maxItems": 5,
    "topProOnly": False,
    "backgroundCheckedOnly": False,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/thumbtack-professionals-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 '{
  "mode": "search",
  "category": "house-cleaning",
  "profileUrls": [
    {
      "url": "https://www.thumbtack.com/ct/sharon/house-cleaning/moreiras-cleaning/service/524848507703738374"
    }
  ],
  "city": "San Francisco",
  "state": "CA",
  "maxItems": 5,
  "topProOnly": false,
  "backgroundCheckedOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/thumbtack-professionals-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Thumbtack Professionals Scraper",
        "description": "Find and export public Thumbtack professionals by service, city, state, or profile URL. Get ratings, reviews, hires, badges, prices, media, and links.",
        "version": "0.1",
        "x-build-id": "45dr68TM3mMhNcH7o"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~thumbtack-professionals-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-thumbtack-professionals-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/automation-lab~thumbtack-professionals-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-thumbtack-professionals-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/automation-lab~thumbtack-professionals-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-thumbtack-professionals-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": {
                    "mode": {
                        "title": "🔍 Scraping mode",
                        "enum": [
                            "search",
                            "byCategory",
                            "byProfile"
                        ],
                        "type": "string",
                        "description": "Choose location search, category browsing, or direct professional profile extraction.",
                        "default": "search"
                    },
                    "category": {
                        "title": "Service category",
                        "type": "string",
                        "description": "Enter the Thumbtack category slug, for example house-cleaning, plumbers, handyman, personal-trainers, or photographers.",
                        "default": "house-cleaning"
                    },
                    "profileUrls": {
                        "title": "Professional profile URLs",
                        "type": "array",
                        "description": "Add public Thumbtack URLs containing /service/<numeric-id>. Used only in Direct profile URLs mode.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "city": {
                        "title": "🏙️ City",
                        "type": "string",
                        "description": "Enter a US city. Search mode resolves it to a representative ZIP code unless ZIP code is provided.",
                        "default": "San Francisco"
                    },
                    "state": {
                        "title": "State",
                        "minLength": 2,
                        "maxLength": 2,
                        "type": "string",
                        "description": "Enter the two-letter US state abbreviation, such as CA, NY, TX, or FL.",
                        "default": "CA"
                    },
                    "zipCode": {
                        "title": "ZIP code override",
                        "pattern": "^[0-9]{5}$",
                        "type": "string",
                        "description": "Optionally provide exactly five digits for precise location targeting and to skip city lookup."
                    },
                    "maxItems": {
                        "title": "Maximum professionals",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Stop after saving this many unique professional records. A category page normally provides about 10–15 records.",
                        "default": 10
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Keep only professionals whose visible rating meets this threshold. Missing ratings do not pass."
                    },
                    "minReviews": {
                        "title": "Minimum review count",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only professionals with at least this many visible reviews. Missing counts do not pass."
                    },
                    "topProOnly": {
                        "title": "Top Pro only",
                        "type": "boolean",
                        "description": "Return only records where Thumbtack visibly marks the professional as a Top Pro.",
                        "default": false
                    },
                    "backgroundCheckedOnly": {
                        "title": "Background checked only",
                        "type": "boolean",
                        "description": "Return only records whose visible profile signals include a completed background check.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy fallback",
                        "type": "object",
                        "description": "Optionally configure Apify Proxy for a retry if direct browser extraction is blocked.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```