# Bark.com Scraper (`solidcode/bark-scraper`) Actor

\[💰 $1.30 / 1K] Extract Bark.com service professionals across the UK and Ireland: company name, rating, review count, location, category, website, and full customer reviews as separate rows. Search by category and city, or paste Bark.com URLs. Great for lead generation and market research.

- **URL**: https://apify.com/solidcode/bark-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 $1.30 / 1,000 professionals

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.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

## Bark.com Scraper

Pull service professionals from Bark.com across the United Kingdom and Ireland at scale — company name, star rating, category, city, website, hires count, response time, and full customer reviews. Professionals and their reviews come back as separate, ready-to-join rows. Built for lead-generation agencies, market researchers, and CRM teams who need a fresh, structured directory of local service providers without copy-pasting profiles one at a time.

### Why This Scraper?

- **15 ready-made trade categories** — electricians, plumbers, gardeners, builders, painters & decorators, handyman, cleaners, photographers, personal trainers, tutors, accountants, web designers, graphic designers, wedding planners, and dog walkers — picked from a dropdown, no URL slugs to guess.
- **Full customer reviews as their own rows** — every review carries author name, 1–5 star rating, review text, and date, each linked back to its professional so you can analyze sentiment or join straight into a CRM.
- **United Kingdom and Ireland coverage** — search any GB or IE city directory, with sensible defaults (London, Manchester, Bristol for the UK; Dublin, Cork, Galway for Ireland) when you leave the city list blank.
- **Profile-level credibility signals** — hires count ("450 hires on Bark"), aggregate rating, total review count, typical response time ("1 hour"), company size, years in business, and long-form bio, so you can score a professional's track record at a glance.
- **Verified contact paths** — published external website plus the Bark profile URL on every professional, the two links that turn a listing into a lead.
- **Paste any Bark.com URL directly** — drop in a category/city directory page or an individual profile page and it's honored exactly as-is, no slug reverse-engineering.
- **Zero required input** — runs out of the box on the top UK trades and cities; no mandatory feedback or contact fields to fill in before you can start.
- **Pay-per-result, split pricing** — professionals and reviews are billed separately, so you can pull every available review on a busy professional without a single fixed price ballooning your cost.

### Use Cases

**Lead Generation & Sales Prospecting**
- Build targeted lists of local tradespeople and service businesses by category and city
- Capture website and profile links to fuel outreach campaigns
- Prioritize high-credibility professionals by hires count and rating before you call

**Market & Competitive Research**
- Map how many electricians, cleaners, or photographers operate in a given city
- Benchmark response times and review volumes across a service category
- Track which professionals dominate a local market by hires and ratings

**Reputation & Review Analysis**
- Pull full review text and star ratings to run sentiment analysis on a category
- Compare review counts and average ratings across competing professionals
- Surface common complaints or praise themes from real customer feedback

**Directory & Aggregator Building**
- Populate a local-services directory with structured professional profiles
- Keep an existing listings database fresh with current ratings and reviews
- Enrich a CRM with bios, services offered, and seller locations

**Recruitment & Partner Sourcing**
- Find skilled tradespeople and freelancers for subcontracting or hiring
- Identify wedding planners, photographers, or tutors for partnership programs
- Scout active professionals by recency and volume of completed hires

### Getting Started

#### Simple — top UK electricians

The minimal run: pick a category and let it use the default top cities.

```json
{
    "category": "electricians",
    "maxResults": 50
}
````

#### Filtered — cleaners across Irish cities

Target a specific country and your own list of cities.

```json
{
    "category": "cleaners",
    "country": "ie",
    "cities": ["dublin", "cork", "galway"],
    "maxResults": 200
}
```

#### Advanced — full detail with capped reviews

Pull every field, capping reviews to the 10 most recent per professional to control cost.

```json
{
    "category": "photographers",
    "country": "gb",
    "cities": ["london", "manchester", "bristol"],
    "includeProfileDetails": true,
    "maxReviewsPerPro": 10,
    "maxResults": 500
}
```

#### Paste your own Bark.com URLs

Drop in directory pages or individual profile pages — filters in the URL are honored as-is.

```json
{
    "searchUrls": [
        "https://www.bark.com/en/gb/electricians/london/",
        "https://www.bark.com/en/ie/cleaners/dublin/"
    ],
    "maxResults": 300
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchUrls` | array | `[]` | Bark.com category/city directory URLs or individual professional profile URLs. Honored as-is. Leave blank to use the guided filters below. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `category` | string | `"electricians"` | Service category to search. Choose from 15 trades. Ignored when URLs are provided. |
| `country` | string | `"gb"` | Country directory: United Kingdom (`gb`) or Ireland (`ie`). |
| `cities` | array | `["london", "manchester", "bristol"]` | City names to search for the chosen category. Blank uses the top cities for the country. |

#### Output Control

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeProfileDetails` | boolean | `true` | Visit each professional's profile to add bio, total review count, hires count, response time, company size, years in business, remote-availability, website, and customer reviews. Turn off for faster, listing-only runs with no reviews. |
| `maxReviewsPerPro` | integer | `0` | Cap reviews captured per professional (most recent first). `0` = every available review. Ignored when profile details are off. |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Cap on total professionals across all category/city combinations. `0` = no cap — collects every professional found across the searches you set up (naturally bounded by your category, city, and URL list, since Bark directory pages have no pagination). |

### Output

Results come back as two record types in one dataset. Each row carries a `recordType` field: `professional` rows are the parent listings, and `review` rows are individual customer reviews linked back to their professional. Use the **Professionals** and **Reviews** dataset views to see each on its own.

#### Professional

```json
{
    "recordType": "professional",
    "companyName": "Bright Spark Electrical Ltd",
    "category": "electricians",
    "city": "London",
    "country": "gb",
    "rating": 4.9,
    "aggregateRating": 4.9,
    "totalReviewCount": 128,
    "hiresCount": 450,
    "responseTime": "1 hour",
    "companySize": "self-employed",
    "companyAge": 16,
    "availableRemotely": false,
    "description": "NICEIC-approved electricians serving Greater London.",
    "about": "Family-run electrical contractor with over 15 years of experience covering domestic and commercial work across London...",
    "servicesOffered": ["Electrical Installation", "Fuse Board Upgrades", "EV Charger Installation"],
    "sellerLocation": "London, Greater London",
    "website": "https://www.brightsparkelectrical.co.uk",
    "profileImage": "https://images.bark.com/.../profile.jpg",
    "profileUrl": "https://www.bark.com/en/gb/b/bright-spark-electrical/01Alb/",
    "listingUrl": "https://www.bark.com/en/gb/electricians/london/",
    "scrapedAt": "2026-06-12T09:31:00.000000+00:00"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"professional"` for these rows |
| `companyName` | string | Professional / company display name |
| `category` | string | Service category searched |
| `city` | string | City of the directory page |
| `country` | string | Country code (`gb` or `ie`) |
| `rating` | number | Average star rating from the listing card (0–5) |
| `aggregateRating` | number | Profile-level aggregate rating (0–5) |
| `totalReviewCount` | integer | Total reviews shown on the profile |
| `hiresCount` | integer | Number of completed hires on Bark |
| `responseTime` | string | Typical response time published on the profile (e.g. `"1 hour"`, `"4 min"`) |
| `companySize` | string | Self-reported company size (e.g. `"self-employed"`, `"2-10"`) |
| `companyAge` | integer | Years the company has been operating |
| `availableRemotely` | boolean | Whether the professional offers services remotely |
| `description` | string | Short listing tagline |
| `about` | string | Long-form bio from the profile |
| `servicesOffered` | array | Service tags the professional offers |
| `sellerLocation` | string | Professional's stated location |
| `website` | string | Published external website, when available |
| `profileImage` | string | Profile image URL |
| `profileUrl` | string | Bark.com profile URL |
| `listingUrl` | string | Source directory page URL |
| `scrapedAt` | string | ISO-8601 collection timestamp |

#### Review

```json
{
    "recordType": "review",
    "author": "Sarah M.",
    "rating": 5,
    "text": "Fantastic service from start to finish. Arrived on time, tidy work, and fairly priced. Would absolutely recommend.",
    "date": "2026-05-28",
    "serviceUsed": null,
    "professionalProfileUrl": "https://www.bark.com/en/gb/b/bright-spark-electrical/01Alb/",
    "professionalName": "Bright Spark Electrical Ltd",
    "scrapedAt": "2026-06-12T09:31:00.000000+00:00"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"review"` for these rows |
| `author` | string | Review author name |
| `rating` | number | Star rating for this review (0–5) |
| `text` | string | Full review body text |
| `date` | string | Review date |
| `serviceUsed` | string | Service the reviewer hired the professional for. Bark rarely labels this on the review, so it is usually `null` |
| `professionalProfileUrl` | string | Links back to the parent professional's `profileUrl` |
| `professionalName` | string | Links back to the parent professional's `companyName` |
| `scrapedAt` | string | ISO-8601 collection timestamp |

### Tips for Best Results

- **Combine categories with cities to scale up.** Each city directory holds a fixed set of professionals with no extra pages, so the fastest way to a large dataset is many category-and-city combinations rather than a single search.
- **Bark publishes up to 50 reviews per professional** on the profile page, even for those showing a higher total review count. Setting `maxReviewsPerPro` to `0` collects up to that 50.
- **Turn off `includeProfileDetails` for a quick, cheap headcount** — you'll get every professional's name, rating, city, and profile link without bios or reviews.
- **Some city pages only exist in a county-prefixed form** (for example `west-midlands/birmingham` rather than `birmingham`). If a city returns nothing, try a major city like London, Manchester, or Dublin, or paste the exact directory URL.
- **Paste profile URLs directly** when you already know the professionals you want — they're fetched straight from the profile page with full detail and reviews.
- **Use `maxReviewsPerPro` to control review cost** on review-heavy categories; the most recent reviews are kept first.
- **Phone and email are not published on Bark** — use the website and profile URL as your contact paths.

### Pricing

**From $1.30 per 1,000 professionals** (plus $0.20 per 1,000 reviews collected) at the Gold tier — a transparent, results-based price for a fully structured UK and Ireland service-provider directory. You are charged per professional plus per review collected, so review-heavy professionals never blow up a single fixed price.

#### Price per event by discount tier

| Event | No discount | Bronze | Silver | Gold |
|-------|-------------|--------|--------|------|
| Professional (per 1,000) | $1.55 | $1.45 | $1.40 | $1.30 |
| Review (per 1,000) | $0.24 | $0.22 | $0.21 | $0.20 |

#### Example run cost (Gold tier)

| Scenario | Professionals | Reviews | Approx. total |
|----------|---------------|---------|---------------|
| Quick lead list | 100 × 10 reviews | 1,000 | ≈ $0.33 |
| Category sweep | 1,000 × 20 reviews | 20,000 | ≈ $5.30 |
| Large directory | 10,000 × 15 reviews | 150,000 | ≈ $43.00 |

*Totals cover professionals plus reviews; a small fixed per-run start fee (about $0.005) applies on top.*

**No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.** Charged per professional plus per review collected. Bronze, Silver, and Gold loyalty discounts apply automatically on the Apify platform, so larger and longer-term usage costs progressively less.

### 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 collects publicly available information from Bark.com. Use it responsibly and in compliance with Bark.com's terms of service and all applicable laws, including data-protection regulations such as the UK GDPR and EU GDPR. Personal data contained in reviews and professional profiles must be handled lawfully — obtain a valid legal basis before processing, and respect the rights of the individuals concerned. You are responsible for how you use the collected data; do not use it for spam, harassment, or any unlawful purpose.

# Actor input Schema

## `searchUrls` (type: `array`):

Paste one or more Bark.com URLs. Accepts category/city directory pages (e.g. https://www.bark.com/en/gb/electricians/london/) or individual professional profile pages. Filters in the URL are honored as-is. Leave blank to use the guided category and city filters below.

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

Type of service professional to search for. Ignored when you provide URLs above (the URL already specifies the category).

## `country` (type: `string`):

Country directory to search. Bark provides directory pages for the United Kingdom and Ireland.

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

City names to search for the chosen category (e.g. london, manchester, dublin). Leave blank to use the top cities for the selected country.

## `includeProfileDetails` (type: `boolean`):

Visit each professional's profile page to add their bio, total review count, hires count, response time, company size, years in business, remote-availability, website, and customer reviews. Reviews are only available with this turned on (they come from profile pages). Turn off for faster, cheaper runs that return only the listing-card data and no reviews.

## `maxReviewsPerPro` (type: `integer`):

Cap on the number of reviews captured per professional (most recent first). Default is 0 = capture every available review. Note: Bark.com itself only publishes up to 50 reviews per professional on the page, so 0 collects up to that 50, even when a professional shows a higher total review count. Each review collected is returned as its own result and billed as a separate result (a small per-review fee — see pricing). Set a positive number to limit how many reviews you collect per professional and cap that cost. Ignored when 'Include Full Profile Details' is off (no reviews are collected then).

## `maxResults` (type: `integer`):

Cap on the total number of professionals returned across all category/city combinations. Default 100 — increase for bigger runs, or set to 0 for no cap, which collects every professional found across all of the searches you set up. (Bark directory pages have no pagination, so a no-cap run is naturally bounded by the categories, cities, and URLs you supply.) The actor stops processing new professionals once the cap is reached.

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

Proxy settings used to collect data. The default works for most runs.

## Actor input object example

```json
{
  "searchUrls": [],
  "category": "electricians",
  "country": "gb",
  "cities": [
    "london",
    "manchester",
    "bristol"
  ],
  "includeProfileDetails": true,
  "maxReviewsPerPro": 0,
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Table of scraped service professionals with key fields.

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

Table of customer reviews collected for the 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 = {
    "searchUrls": [],
    "category": "electricians",
    "country": "gb",
    "cities": [
        "london",
        "manchester",
        "bristol"
    ],
    "includeProfileDetails": true,
    "maxReviewsPerPro": 0,
    "maxResults": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/bark-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 = {
    "searchUrls": [],
    "category": "electricians",
    "country": "gb",
    "cities": [
        "london",
        "manchester",
        "bristol",
    ],
    "includeProfileDetails": True,
    "maxReviewsPerPro": 0,
    "maxResults": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/bark-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 '{
  "searchUrls": [],
  "category": "electricians",
  "country": "gb",
  "cities": [
    "london",
    "manchester",
    "bristol"
  ],
  "includeProfileDetails": true,
  "maxReviewsPerPro": 0,
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call solidcode/bark-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bark.com Scraper",
        "description": "[💰 $1.30 / 1K] Extract Bark.com service professionals across the UK and Ireland: company name, rating, review count, location, category, website, and full customer reviews as separate rows. Search by category and city, or paste Bark.com URLs. Great for lead generation and market research.",
        "version": "1.0",
        "x-build-id": "xcEfEjC9lGsZ3B4Hc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~bark-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-bark-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~bark-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-bark-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~bark-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-bark-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": {
                    "searchUrls": {
                        "title": "Bark.com URLs",
                        "type": "array",
                        "description": "Paste one or more Bark.com URLs. Accepts category/city directory pages (e.g. https://www.bark.com/en/gb/electricians/london/) or individual professional profile pages. Filters in the URL are honored as-is. Leave blank to use the guided category and city filters below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "category": {
                        "title": "Service Category",
                        "enum": [
                            "electricians",
                            "plumbers",
                            "gardeners",
                            "builders",
                            "painting-decorating",
                            "handyman",
                            "cleaners",
                            "photographers",
                            "personal-trainers",
                            "private-tutors",
                            "accountants",
                            "web-designers",
                            "graphic-designers",
                            "wedding-planners",
                            "dog-walking"
                        ],
                        "type": "string",
                        "description": "Type of service professional to search for. Ignored when you provide URLs above (the URL already specifies the category)."
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "gb",
                            "ie"
                        ],
                        "type": "string",
                        "description": "Country directory to search. Bark provides directory pages for the United Kingdom and Ireland."
                    },
                    "cities": {
                        "title": "Cities",
                        "type": "array",
                        "description": "City names to search for the chosen category (e.g. london, manchester, dublin). Leave blank to use the top cities for the selected country.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeProfileDetails": {
                        "title": "Include Full Profile Details",
                        "type": "boolean",
                        "description": "Visit each professional's profile page to add their bio, total review count, hires count, response time, company size, years in business, remote-availability, website, and customer reviews. Reviews are only available with this turned on (they come from profile pages). Turn off for faster, cheaper runs that return only the listing-card data and no reviews.",
                        "default": true
                    },
                    "maxReviewsPerPro": {
                        "title": "Max Reviews Per Professional",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap on the number of reviews captured per professional (most recent first). Default is 0 = capture every available review. Note: Bark.com itself only publishes up to 50 reviews per professional on the page, so 0 collects up to that 50, even when a professional shows a higher total review count. Each review collected is returned as its own result and billed as a separate result (a small per-review fee — see pricing). Set a positive number to limit how many reviews you collect per professional and cap that cost. Ignored when 'Include Full Profile Details' is off (no reviews are collected then).",
                        "default": 0
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap on the total number of professionals returned across all category/city combinations. Default 100 — increase for bigger runs, or set to 0 for no cap, which collects every professional found across all of the searches you set up. (Bark directory pages have no pagination, so a no-cap run is naturally bounded by the categories, cities, and URLs you supply.) The actor stops processing new professionals once the cap is reached.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings used to collect data. The default works for most runs.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
