# Expertise.com Scraper - Top Professional Directory by City (`jungle_synthesizer/expertise-scraper`) Actor

Scrape top-rated professional listings from Expertise.com. Extract business names, phone numbers, addresses, ratings, reviews, and descriptions across legal, home improvement, finance, insurance, and business categories. Filter by category, practice area, and US state.

- **URL**: https://apify.com/jungle\_synthesizer/expertise-scraper.md
- **Developed by:** [BowTiedRaccoon](https://apify.com/jungle_synthesizer) (community)
- **Categories:** Lead generation, Business, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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.

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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Expertise.com Professional Directory Scraper

Scrape top-rated professional listings from the Expertise.com directory. Extracts business names, contact details, addresses, ratings, review counts, and review source breakdowns for professionals ranked by city across five categories: legal, home improvement, finance, insurance, and business.

The actor reads category sitemaps to discover city-level ranking pages, then extracts structured data from JSON-LD (schema.org `LocalBusiness`) blocks embedded in each page. No proxy required — Expertise.com serves structured data publicly.

---

### Expertise.com Scraper Features

- **Extracts** business name, phone, address, city, state, ZIP, and website URL
- **Captures** aggregate ratings and total review counts from all sources
- **Parses** per-source review breakdowns (e.g. `Google: 4.8, Yelp: 4.5`)
- **Filters** by category (legal, home improvement, finance, insurance, business)
- **Filters** by US state and practice area / service type
- **Respects** `maxItems` — stops crawling once the target count is reached
- **Handles** rate limits automatically with built-in backoff

---

### Expertise.com Scraper Input Options

| Field | Type | Description |
|---|---|---|
| `category` | string | Professional category to scrape. One of: `legal`, `home-improvement`, `finance`, `insurance`, `business`. Default: `legal`. |
| `states` | array | Filter by US state slug (e.g. `california`, `new-york`). Leave empty to scrape all states. |
| `practiceArea` | string | Filter by practice area or service type slug (e.g. `personal-injury-lawyers`, `plumbing`). Leave empty for all. |
| `maxItems` | integer | Maximum number of listings to return. `0` means no limit. Default: `100`. |

#### Input Examples

**Scrape personal injury lawyers in California:**
```json
{
  "category": "legal",
  "states": ["california"],
  "practiceArea": "personal-injury-lawyers",
  "maxItems": 500
}
````

**Scrape plumbers across Texas and Florida:**

```json
{
  "category": "home-improvement",
  "states": ["texas", "florida"],
  "practiceArea": "plumbing",
  "maxItems": 200
}
```

**Scrape all finance professionals nationwide:**

```json
{
  "category": "finance",
  "states": [],
  "practiceArea": "",
  "maxItems": 0
}
```

***

### Expertise.com Scraper Output Fields

| Field | Type | Description |
|---|---|---|
| `businessName` | string | Name of the business or professional |
| `phone` | string | Contact phone number |
| `address` | string | Street address |
| `city` | string | City |
| `state` | string | Two-letter state code (e.g. `CA`, `TX`) |
| `zip` | string | ZIP/postal code |
| `websiteUrl` | string | Business website URL |
| `description` | string | Business description from the Expertise.com profile |
| `aggregateRating` | number | Aggregate rating across all review sources |
| `reviewCount` | number | Total review count across all sources |
| `reviewSources` | string | Per-source ratings (e.g. `Google: 4.8, Yelp: 4.5`) |
| `practiceArea` | string | Practice area or service type (title-cased from URL slug) |
| `rankingCity` | string | City where this professional is ranked |
| `rankingState` | string | State where this professional is ranked |
| `profileUrl` | string | Full URL to the Expertise.com listing page |

#### Sample Output

```json
{
  "businessName": "Smith & Associates Personal Injury Law",
  "phone": "(310) 555-0142",
  "address": "1234 Wilshire Blvd",
  "city": "Los Angeles",
  "state": "CA",
  "zip": "90017",
  "websiteUrl": "https://smithinjurylaw.com",
  "description": "Smith & Associates has represented accident victims in Los Angeles for over 20 years.",
  "aggregateRating": 4.9,
  "reviewCount": 312,
  "reviewSources": "Google: 4.9, Yelp: 4.8, Avvo: 5.0",
  "practiceArea": "Personal Injury Lawyers",
  "rankingCity": "Los Angeles",
  "rankingState": "California",
  "profileUrl": "https://www.expertise.com/legal/personal-injury-lawyers/california/los-angeles"
}
```

***

### Who Uses Expertise.com Data?

- **Legal marketing agencies** building attorney lead lists segmented by city and practice area
- **Home services platforms** sourcing verified contractors ranked by local reputation
- **Financial advisor networks** mapping top-rated professionals by state for referral pipelines
- **Market research teams** analyzing professional density and rating distribution by geography
- **Insurance brokers** identifying top-ranked local agents for partnership outreach

***

### Expertise.com Scraper Pricing

This actor uses pay-per-result pricing. You pay only for the records returned. Typical costs:

- \~100 listings: a few cents
- \~10,000 listings: under $1.00

Run a small test with `maxItems: 50` to estimate cost before a full crawl.

***

### Frequently Asked Questions

**How does this scraper find listings on Expertise.com?**
It reads the category sitemap XML (e.g. `/category/sitemap/legal.xml`) to get all city-level ranking page URLs, applies your state and practice area filters, then fetches each page and extracts the JSON-LD structured data.

**What practice area slugs are available?**
They follow the URL pattern on Expertise.com. Legal examples: `personal-injury-lawyers`, `criminal-defense-attorneys`, `family-law-attorneys`. Home improvement: `plumbing`, `hvac`, `roofing`. Browse expertise.com to find the slug for your target service.

**What state slugs do I use?**
Full lowercase state names with hyphens: `california`, `new-york`, `north-carolina`, etc.

**How many listings does Expertise.com have?**
Coverage varies by category and geography. Legal is the largest category with thousands of city-level pages. A full legal crawl with no filters returns tens of thousands of records.

**Does this actor need a proxy?**
No. Expertise.com serves its structured data without bot detection. The actor runs without proxy by default.

**How do I get all listings for a state?**
Set `states: ["california"]` (or your target state), leave `practiceArea` empty, and set `maxItems: 0` for no limit.

***

Need custom features or a different practice area? Get in touch.

# Actor input Schema

## `sp_intended_usage` (type: `string`):

Please describe how you plan to use the data extracted by this crawler.

## `sp_improvement_suggestions` (type: `string`):

Provide any feedback or suggestions for improvements.

## `sp_contact` (type: `string`):

Provide your email address so we can get in touch with you.

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

Professional category to scrape.

## `states` (type: `array`):

Filter by US state (slug format, e.g. 'california', 'new-york'). Leave empty to scrape all states.

## `practiceArea` (type: `string`):

Filter by specific practice area or service type slug (e.g. 'personal-injury-lawyers', 'plumbing'). Leave empty for all.

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

Maximum number of professional listings to scrape. Set to 0 for no limit.

## Actor input object example

```json
{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "category": "legal",
  "states": [],
  "practiceArea": "",
  "maxItems": 100
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "category": "legal",
    "states": [],
    "practiceArea": "",
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("jungle_synthesizer/expertise-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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "category": "legal",
    "states": [],
    "practiceArea": "",
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("jungle_synthesizer/expertise-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 '{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "category": "legal",
  "states": [],
  "practiceArea": "",
  "maxItems": 100
}' |
apify call jungle_synthesizer/expertise-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Expertise.com Scraper - Top Professional Directory by City",
        "description": "Scrape top-rated professional listings from Expertise.com. Extract business names, phone numbers, addresses, ratings, reviews, and descriptions across legal, home improvement, finance, insurance, and business categories. Filter by category, practice area, and US state.",
        "version": "1.0",
        "x-build-id": "EEGV797p8s6283Fdu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jungle_synthesizer~expertise-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jungle_synthesizer-expertise-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/jungle_synthesizer~expertise-scraper/runs": {
            "post": {
                "operationId": "runs-sync-jungle_synthesizer-expertise-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/jungle_synthesizer~expertise-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-jungle_synthesizer-expertise-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": {
                    "sp_intended_usage": {
                        "title": "What is the intended usage of this data?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Please describe how you plan to use the data extracted by this crawler."
                    },
                    "sp_improvement_suggestions": {
                        "title": "How can we improve this crawler for you?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide any feedback or suggestions for improvements."
                    },
                    "sp_contact": {
                        "title": "Contact Email",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide your email address so we can get in touch with you."
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "legal",
                            "home-improvement",
                            "finance",
                            "insurance",
                            "business"
                        ],
                        "type": "string",
                        "description": "Professional category to scrape.",
                        "default": "legal"
                    },
                    "states": {
                        "title": "State Filter",
                        "type": "array",
                        "description": "Filter by US state (slug format, e.g. 'california', 'new-york'). Leave empty to scrape all states.",
                        "default": []
                    },
                    "practiceArea": {
                        "title": "Practice Area / Service Type",
                        "type": "string",
                        "description": "Filter by specific practice area or service type slug (e.g. 'personal-injury-lawyers', 'plumbing'). Leave empty for all.",
                        "default": ""
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "type": "integer",
                        "description": "Maximum number of professional listings to scrape. Set to 0 for no limit.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
