# Bark Scraper — Pros, Reviews & Category Coverage — $4/1k (`chimerical_quicklime/bark-scraper`) Actor

Bark.com scraper for 10 countries incl. US: category coverage and gap finder per city, pros with ratings and reviews, and profile URL enrichment. Phone numbers are not collected. No login or cookies. MCP-ready for AI agents. $4 per 1,000 records.

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

## Pricing

from $4.00 / 1,000 records

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Bark Scraper: Pros, Reviews & Category Coverage

Scrape Bark.com in 10 countries, including the United States. Get the service professionals listed in a city, their ratings, reviews, response times and profile details, or run the cheap **coverage** mode to see which services Bark has a page for in which city, and where it has none.

No Bark account, no cookies, no API key, no proxy. The actor reads the same public pages a visitor sees, over plain HTTP, so runs are fast and small (512 MB).

### What you get

The actor has three modes.

| Mode | One row is | Use it for |
|---|---|---|
| `coverage` (default) | one city x service pair | Market-gap research: where does Bark have no page, a state page only, or a thin city page |
| `listings` | one professional found on a city x service page | Lead lists, competitor mapping, rating and review benchmarks |
| `profiles` | one Bark company profile URL | Enriching a list of Bark profile links |

An empty input (`{}`) runs a small coverage sample: San Diego, CA for "cake", "dog grooming" and "house cleaning". Any other input runs the mode you set (default `coverage`).

#### Coverage row fields

Coverage is built to answer one question: is a service covered in a city? Bark answers with the URL it redirects to, and the actor reads that.

| Field | Example | Meaning |
|---|---|---|
| `recordType` | `coverage` | Row type |
| `marketplace`, `country` | `bark`, `us` | Source and Bark country site |
| `city`, `service` | `San Diego, CA`, `dog grooming` | The pair you asked for, exactly as typed |
| `categoryExists` | `true` | Bark has this service category at all (false = no such category) |
| `cityPageExists` | `true` | Bark has a page for this service in this city |
| `coverageLevel` | `city` | `city`, `region`, `country` or `none` (see below) |
| `matchedSlug`, `matchType`, `matchedCategory` | `pet-grooming`, `all-words`, `Dog & Pet Grooming` | Which Bark category your words resolved to |
| `resolvedCity`, `regionSlug`, `citySlug` | `San Diego, California`, `california`, `san-diego` | How the city was resolved |
| `proCount` | `null` | Always null: Bark does not print a pro count anywhere (see Limits) |
| `resultCount` | `12` | Pros listed on the city page |
| `avgRating`, `ratingReviewCount` | `4.58`, `2919` | City-page aggregate rating and review count |
| `priceRange`, `priceMin`, `priceMax`, `priceAvg` | `$125 - $250 (Avg: $160)`, 125, 250, 160 | Price range Bark shows (US pages) |
| `topPros`, `topProUrls` | names and profile links | First three pros on the page |
| `pageUrl` | Bark URL | The page that was checked |
| `nearbyPlaces`, `relatedServices` | `["Chula Vista", "Coronado"]` | Other cities and related categories Bark links |
| `slugsTried` | `[{"slug":"cake-makers","path":"california/san-diego","status":301,...}]` | Every URL tried and the HTTP result |
| `error`, `scrapedAt` | `null`, ISO time | Failure text (if any) and timestamp |

##### How to read `coverageLevel`

| Value | What Bark did | Meaning |
|---|---|---|
| `city` | The city page returned 200 | Bark has a page for the service in that city. `resultCount` says how many pros it lists (it can still be 0) |
| `region` | The city URL redirected to the state or province page | The category exists in the region, but Bark has no page for this city |
| `country` | Redirected to the national category page | The category exists only nationally, nothing local |
| `none` | The category URL does not exist | Bark has no such category. This is a visible gap |

A miss still produces a row, so gaps show up in your dataset instead of being silently dropped.

#### Listing row fields

| Field | Example |
|---|---|
| `recordType`, `marketplace`, `country` | `listing`, `bark`, `us` |
| `searchCity`, `searchService`, `matchedSlug` | `Austin, TX`, `dog grooming`, `pet-grooming` |
| `category`, `city`, `listingUrl` | `Dog & Pet Grooming`, `Austin`, city page URL |
| `cityAvgRating`, `cityPriceRange`, `position` | `5`, `$85 - $125 (Avg: $110)`, `2` |
| `providerId`, `sellerProfileId` | `4GqZp`, `1132005` |
| `providerName`, `profileUrl`, `profileImageUrl` | `Virtuous Pet Care`, Bark URL, image URL |
| `location` | `Austin, TX` |
| `description`, `about` | Card blurb and the full About text |
| `providerRating`, `reviewCount` | `5`, `2` (rating is null when the pro has no reviews) |
| `hiresCount`, `responseTime` | `10`, `3+ day response time` (hires only when Bark shows it) |
| `yearsInBusiness`, `companySize`, `remoteServices` | when Bark shows them |
| `isElite`, `badges` | `false`, `["Certificate of Excellence 2021"]` |
| `categories` | `[{"name":"Dog & Pet Grooming","slug":"pet-grooming"}]` |
| `services` | `["Overnight pet sitting", "In-home pet grooming"]` |
| `photosCount`, `photoUrls` | `5`, up to 20 image URLs |
| `websiteUrl`, `links` | website and social links the pro published |
| `publicPhoneNumbers`, `publicEmails` | only numbers or addresses written in the pro's own text |
| `qa` | `[{"question": "...", "answer": "..."}]` |
| `featuredReview` | one review quoted on the city page |
| `reviews` | with Include reviews: `author`, `rating`, `date`, `text`, `platform` |
| `detailError`, `scrapedAt` | profile-fetch failure text (if any), timestamp |

Fields a profile does not show are left out of the row rather than invented. Treat every field as optional when you load the data.

### Why this one

- **10 countries**: US, UK (`gb`), Canada, Ireland, Australia, New Zealand, South Africa, Singapore, France, Germany. The best-known Bark scraper on the Store covers GB and IE only, so US data was not available from it.
- **Coverage mode**: one cheap row per city x service with `categoryExists`, `cityPageExists` and `coverageLevel`. I found no other Bark actor on the Store that offers this.
- **Plain-English services**: type "dog grooming" and the actor resolves it with Bark's own service search to `pet-grooming`, and reports the match type. You can also pass Bark slugs or category URLs.
- **Bulk input**: lists of cities and services, or a CSV or Google Sheet link.
- **Compatible input names**: `categories`, `locations` and `targetType` work as aliases of `services`, `cities` and `mode`, so inputs written for other Bark scrapers run unchanged.
- **Partial results kept**: if one target fails, the others still return, and a summary record lists the status per target.

### Use cases

1. **Find service gaps in a city.** Run coverage for a city against a long list of services. Rows with `coverageLevel` of `region`, `country` or `none` are services Bark does not serve locally there.
2. **Compare supply across cities.** Run the same service across many cities and sort by `resultCount`, `avgRating` and `priceAvg`.
3. **Build a local-pro lead list.** Listings mode returns names, ratings, review counts, response times, websites and profile links for the pros on each city page.
4. **Benchmark pricing.** Coverage rows carry the price range Bark shows for the city and service (US pages).
5. **Monitor competitors' reputations.** Re-run profiles mode on a list of Bark profile URLs on a schedule and track `providerRating`, `reviewCount` and `hiresCount`.
6. **Research reviews.** Turn on Include reviews to get the reviews shown on each profile with their source platform (Bark, Facebook, Google Maps, Houzz and others).
7. **Market entry research for a marketplace or directory.** Cross-check Bark coverage with another marketplace's supply to find categories with demand and no listings.

### Input

| Input | Type | Default | Meaning |
|---|---|---|---|
| `mode` | select | `coverage` | `coverage`, `listings` or `profiles` |
| `country` | select | `us` | `us`, `gb`, `ca`, `ie`, `au`, `nz`, `za`, `sg`, `fr`, `de` |
| `cities` | string list | none | "San Diego, CA", "Austin", "Leeds", "Toronto, ON", "west-yorkshire/leeds", or a Bark city page URL |
| `services` | string list | none | Plain names ("dog grooming"), Bark slugs ("pet-grooming") or category URLs |
| `listUrl` | string | none | CSV or Google Sheet link. Rows can be `city,service` pairs, a single city, or Bark URLs |
| `startUrls` | string list | none | Bark city x category pages (listings) or company URLs (profiles) |
| `profileUrls` | string list | none | Bark company profile URLs (profiles mode) |
| `maxItems` | integer | 10 | Cap on provider rows in listings and profiles modes. Coverage always returns every city x service |
| `fetchDetails` | boolean | true | Listings: open each profile for the full detail set. Off = only what the city card shows (faster) |
| `includeReviews` | boolean | false | Add the `reviews` array to each provider row. No extra requests |
| `maxReviewsPerProvider` | integer | 20 | Cap on reviews per provider |
| `includeNearby` | boolean | false | Listings: also collect from the Nearby Places pages until `maxItems` is reached |
| `maxConcurrency` | integer | 4 | Parallel workers. Requests are still spaced out globally |
| `proxyConfiguration` | proxy | none | Not needed. Set one only if you see HTTP 403 or 429 errors |
| `categories`, `locations`, `targetType` | | | Aliases of `services`, `cities`, `mode` (`discovery` = listings) |

#### Example: coverage across several cities

```json
{
  "mode": "coverage",
  "country": "us",
  "cities": ["San Diego, CA", "Austin, TX", "Denver, CO"],
  "services": ["dog grooming", "house cleaning", "cake", "goat yoga"]
}
```

This returns 12 rows, one per city x service. A service Bark has no category for returns `categoryExists: false` and `coverageLevel: "none"`.

#### Example: providers with reviews

```json
{
  "mode": "listings",
  "country": "us",
  "cities": ["Austin, TX"],
  "services": ["dog grooming"],
  "maxItems": 25,
  "includeReviews": true,
  "includeNearby": true
}
```

#### Example: UK

```json
{
  "mode": "coverage",
  "country": "gb",
  "cities": ["London", "Leeds", "Manchester"],
  "services": ["electrician", "wedding cake"]
}
```

For UK and Canadian cities, Bark puts a region in the URL. The actor finds it for you, but each city that needs a region lookup costs extra time (about 45 seconds for Leeds in a cloud run). Pass "west-yorkshire/leeds" or "Toronto, ON" to skip the lookup.

#### Example: enrich profile URLs

```json
{
  "mode": "profiles",
  "profileUrls": ["https://www.bark.com/en/us/company/virtuous-pet-care/4GqZp/"],
  "includeReviews": true
}
```

#### Example: from a spreadsheet

```json
{
  "mode": "coverage",
  "listUrl": "https://docs.google.com/spreadsheets/d/YOUR_SHEET_ID/edit?usp=sharing"
}
```

Share the sheet as "anyone with the link". Use `city,service` rows, or a single city column and put the services in the `services` input.

#### Example: input written for another Bark scraper

```json
{
  "targetType": "discovery",
  "categories": ["electricians"],
  "locations": ["london"],
  "country": "gb",
  "maxItems": 2,
  "includeReviews": true
}
```

### Real output rows

These rows come from real cloud runs.

#### Coverage: city page found

```json
{
  "recordType": "coverage",
  "marketplace": "bark",
  "country": "us",
  "city": "San Diego, CA",
  "service": "house cleaning",
  "categoryExists": true,
  "cityPageExists": true,
  "coverageLevel": "city",
  "matchedSlug": "cleaners",
  "matchType": "exact",
  "matchedCategory": "House Cleaning",
  "categoryId": 1212,
  "resolvedCity": "San Diego, California",
  "regionSlug": "california",
  "citySlug": "san-diego",
  "proCount": null,
  "resultCount": 12,
  "avgRating": 4.58,
  "ratingReviewCount": 2919,
  "priceRange": "$125 - $250 (Avg: $160)",
  "priceMin": 125,
  "priceMax": 250,
  "priceAvg": 160,
  "topPros": ["Remedy Cleaning", "Stephanie's Detailed Cleaning Services", "Truth Cleaning Services"],
  "topProUrls": [
    "https://www.bark.com/en/us/company/remedy-cleaning/9jZQO/",
    "https://www.bark.com/en/us/company/stephanies-detailed-cleaning-services/mzmpy/",
    "https://www.bark.com/en/us/company/truth-cleaning-services/Xm0Zm/"
  ],
  "pageUrl": "https://www.bark.com/en/us/cleaners/california/san-diego/",
  "nearbyPlaces": ["Chula Vista", "Coronado", "El Cajon", "Escondido", "Imperial Beach", "La Jolla"],
  "relatedServices": ["Commercial & Office Cleaning", "Deep Cleaning Services", "End of Tenancy Cleaning", "Carpet Cleaning", "Window Cleaners", "Oven Cleaning"],
  "slugsTried": [{"slug": "cleaners", "path": "california/san-diego", "status": 200, "redirectedTo": null}],
  "error": null,
  "scrapedAt": "2026-10-22T02:30:50.944Z"
}
```

#### Coverage: a gap

In the same run, "cake" in San Diego returned `categoryExists: true`, `cityPageExists: false`, `coverageLevel: "region"`, `matchedSlug: "cake-makers"`, `resultCount: 0` and `pageUrl: https://www.bark.com/en/us/cake-makers/california/`. Bark's category exists for California, but not for the city. The `wedding-cakes` category it also tried redirected to its national page.

#### Listing row

```json
{
  "recordType": "listing",
  "marketplace": "bark",
  "country": "us",
  "searchCity": "Austin, TX",
  "searchService": "dog grooming",
  "matchedSlug": "pet-grooming",
  "category": "Dog & Pet Grooming",
  "city": "Austin",
  "listingUrl": "https://www.bark.com/en/us/pet-grooming/texas/austin/",
  "cityAvgRating": 5,
  "cityPriceRange": "$85 - $125 (Avg: $110)",
  "position": 2,
  "providerId": "4GqZp",
  "sellerProfileId": 1132005,
  "providerName": "Virtuous Pet Care",
  "profileUrl": "https://www.bark.com/en/us/company/virtuous-pet-care/4GqZp/",
  "location": "Austin, TX",
  "providerRating": 5,
  "reviewCount": 2,
  "responseTime": "3+ day response time",
  "remoteServices": false,
  "isElite": false,
  "badges": [],
  "categories": [
    {"name": "Dog & Pet Grooming", "slug": "pet-grooming"},
    {"name": "Pet Care", "slug": "pet-services"},
    {"name": "Dog Training", "slug": "dog-training"}
  ],
  "services": ["Overnight pet sitting", "In-home pet grooming", "Puppy training", "Pet taxi"],
  "photosCount": 5,
  "publicPhoneNumbers": [],
  "publicEmails": [],
  "qa": [{"question": "What do you love most about your job?", "answer": "I love getting to spoil beloved fur-family members. ..."}],
  "reviews": [
    {"author": "Corinne Mason", "rating": 5, "date": "2020-06-24", "text": "Stephanie does a wonderful job and takes her time with our fur babies. ...", "platform": "Facebook"}
  ],
  "scrapedAt": "2026-10-22T02:28:21.348Z"
}
```

Long text fields, the description, the About text, `photoUrls` and `links` are shortened here. Real rows carry them in full.

#### Run summary

Every run also stores an `OUTPUT` record in the key-value store with the mode, country, number of records, number of targets, number failed, and one status line per target (`city_page`, `no_city_page` with the fallback level, `no_category`, `ok` or `error`).

### Pricing

Pay per event, no subscription.

| Event | Price |
|---|---|
| Actor start | $0.001 |
| Record (one coverage row or one provider row) | $0.004 |

That is **$4.00 per 1,000 rows**, plus the start event. A coverage check of 50 cities x 20 services is 1,000 rows, about $4. A listings run of 200 providers costs about $0.80. Reviews are embedded in the provider row and cost nothing extra. Apify's free plan credits cover small tests.

Compare like with like: a listings row here includes the full profile (about text, services, Q\&As, photos, badges), not just the card. Set `fetchDetails` to false if you only want the card fields.

Runs in cloud testing used 512 MB and took seconds for the default sample. Set a max charge per run in the Apify run options if you want a hard spending cap.

### Limits and FAQ

**Does Bark show how many pros a city has?** No. Bark prints no total count on city pages, in its structured data, or in its APIs that I could find. `proCount` is therefore always null. `resultCount` is the number of pros listed on the page.

**How many pros per city page?** A city page lists up to about 12 pros, in an order Bark reshuffles on each request. There is no paging. To go beyond one page, turn on `includeNearby` to collect from the Nearby Places pages for the same service, or list more cities.

**Are phone numbers included?** No. On Bark, phone numbers sit behind a "Reveal phone number" button, and the actor does not click it. `publicPhoneNumbers` and `publicEmails` only contain numbers or addresses a pro wrote in their own About or Q\&A text, so they are often empty.

**Is `coverageLevel: none` always a true gap?** It means the category URL Bark would use does not exist. Service names are matched with Bark's own service search, and `matchType` and `slugsTried` show what was tried. If your wording is unusual, pass the Bark slug or category URL directly.

**Why is a UK city slow?** Bark puts a region in UK and Canadian URLs. When a bare city name is given, the actor scans region pages to find the link. This is cached per city for the run. A town that no region page of that category links to (Bromley for electricians in my test) comes back at `region` level, and `slugsTried` shows why. Give "region/city" to be exact.

**Can it be blocked?** In cloud runs without a proxy, Bark returned data. From one home IP, bursts of about 300 requests per minute got HTTP 403 for a few minutes. The actor spaces requests 350 ms apart and retries 403 with a growing delay. A proxy input exists if you ever need it.

**India?** Not supported: Bark's India site is not a working marketplace the actor can read.

**Not collected:** phone reveals, accreditations (rendered client-side with no data in the page), and review owner replies (not present in the profile pages I inspected).

**Is this legal?** The actor reads publicly visible pages and does not log in. Bark's robots.txt disallows crawling of `/company/` paths, so decide for yourself whether that fits your use and your jurisdiction, and follow Bark's terms. Do not use the data to send unsolicited messages in ways your local law forbids.

### Integrations

- **API**: start runs and fetch the dataset with the Apify API. Example: `POST https://api.apify.com/v2/acts/chimerical_quicklime~bark-scraper/runs?token=YOUR_TOKEN` with the input JSON as the body, then `GET /v2/datasets/{datasetId}/items?format=csv`.
- **Python and JavaScript**: use the `apify-client` package: `client.actor("chimerical_quicklime/bark-scraper").call(run_input=...)`.
- **Schedules**: run coverage weekly on the same city list and diff the datasets to see when Bark adds or drops a category in a city.
- **Webhooks**: trigger a webhook when a run succeeds to push rows into your own system.
- **Make, Zapier, n8n**: use the Apify app or HTTP module to run the actor and read the dataset.
- **Google Sheets**: export the dataset as CSV or use the Apify Sheets integration. The same sheet can feed `listUrl`.
- **AI agents (MCP)**: the actor can be called through Apify's MCP server, so an agent can ask "which services are missing in Austin on Bark?" and receive coverage rows.

### Output views

In the Apify console the dataset has two tables: **Pros** (name, rating, reviews, hires, response time, location, badges, website, profile) and **Coverage** (city, service, coverage level, category and city-page flags, pros listed, rating, price range, top pros, page URL).

### Support

Found a city or service that returns the wrong thing? Open an issue on the actor page with the input and the run link. Bark changes its pages from time to time, and issues with reproducible inputs get fixed fastest.

# Actor input Schema

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

coverage = one row per city × service showing whether Bark has a page there and how many pros it lists (gap finder). listings = one row per provider found on the city × service pages (or Bark listing URLs). profiles = one row per Bark profile URL.

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

Bark country site.

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

City names as you would type them ("San Diego, CA", "Austin", "Leeds", "Toronto, ON"), Bark location paths ("california/san-diego", "west-yorkshire/leeds") or Bark city page URLs. Leave empty with no URLs to run a San Diego sample.

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

Plain service names ("dog grooming", "house cleaning") or Bark category slugs ("pet-grooming", "cleaners"). Each is matched with Bark's own service search; the matched slug is reported.

## `listUrl` (type: `string`):

Optional CSV / Google Sheet link (shared as anyone with the link). Rows can be "city,service" pairs, a single city (crossed with Services), or Bark listing / profile URLs.

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

Bark category × city pages (https://www.bark.com/en/us/cleaners/california/san-diego/) for listings mode, or company profile URLs (https://www.bark.com/en/us/company/.../ID/) for profiles mode.

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

Bark company profile URLs to enrich (profiles mode).

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

Maximum provider rows in listings and profiles modes. Coverage mode always returns one row per city × service.

## `fetchDetails` (type: `boolean`):

Listings mode: open every provider profile for rating, review count, hires, response time, badges, services, about text, photos, website and Q\&As. Off = only what the city page card shows (faster).

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

Add a reviews array (author, rating, date, text, platform) to each provider row. No extra requests.

## `maxReviewsPerProvider` (type: `integer`):

Cap on reviews embedded per provider when Include reviews is on.

## `includeNearby` (type: `boolean`):

Listings mode: also collect providers from the Nearby Places pages Bark links from each city page (same service), until Max providers is reached.

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

Alias of Services, for inputs written for other Bark scrapers.

## `locations` (type: `array`):

Alias of Cities, for inputs written for other Bark scrapers.

## `targetType` (type: `string`):

Alias of Mode: "discovery" = listings, "profiles" = profiles.

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

Parallel requests to Bark.

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

Not needed: Bark serves Apify cloud IPs directly. Set one only if you see HTTP 403/429 errors.

## Actor input object example

```json
{
  "mode": "coverage",
  "country": "us",
  "maxItems": 10,
  "fetchDetails": true,
  "includeReviews": false,
  "maxReviewsPerProvider": 20,
  "includeNearby": false,
  "maxConcurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `records` (type: `string`):

Dataset of coverage and provider rows (JSON).

# 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 = {};

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

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

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

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

```

## CLI example

```bash
echo '{}' |
apify call chimerical_quicklime/bark-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,chimerical_quicklime/bark-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/k6c3WWimnreVyyZ7g/builds/9bDD1ELEsz1oRdrdJ/openapi.json