# Bark Seller Profiles & Reviews Scraper (`automation-lab/bark-seller-profiles-reviews-scraper`) Actor

Extract public Bark seller profiles and individual reviews into clean datasets for lead research, reputation monitoring, CRM enrichment, and competitor analysis.

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

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Bark Seller Profiles & Reviews Scraper

Turn public Bark.com seller pages into structured business and customer-review data.

Paste one or more Bark seller profile URLs and receive two clean datasets: seller profiles and individual reviews. Use the results for lead enrichment, competitor research, reputation monitoring, local-market analysis, or recurring CRM updates.

- 🏢 Capture business names, addresses, services, descriptions, ratings, and review counts.
- ⭐ Export every review visible in the public profile response with author, rating, date, text, and verification status.
- 🔗 Join sellers and reviews with stable profile IDs.
- ⚡ Use an HTTP-only workflow designed for quick, low-memory runs.
- 📤 Export through JSON, CSV, Excel, API, webhooks, Google Sheets, or your preferred Apify integration.

No Bark login is required. The Actor processes public seller profile URLs supplied by you; it does not access private leads or account data.

### What does Bark Seller Profiles & Reviews Scraper do?

Bark Seller Profiles & Reviews Scraper visits public company pages such as:

`https://www.bark.com/en/us/company/athena-playground/2noOY/`

For each valid URL, it extracts the public seller record and the individual customer reviews rendered on that page. It normalizes whitespace, converts ratings and counts to numbers, resolves the canonical URL, and generates deterministic IDs that help you update rather than duplicate records on later runs.

The Actor writes different entity types to separate named datasets:

1. **Bark Seller Profiles** — one row per successfully extracted company.
2. **Bark Seller Reviews** — one row per unique customer review.

This separation keeps spreadsheet exports clean and makes seller-to-review joins straightforward.

### Who is it for?

#### Sales and lead-generation teams

Enrich an existing list of Bark profile URLs before outreach. Add the public business name, address, service categories, description, rating, and review volume to CRM accounts.

#### Local-service agencies

Compare public positioning and customer feedback for groomers, photographers, builders, cleaners, tutors, and other service providers listed on Bark.

#### Reputation and customer-experience teams

Refresh review records on a schedule, upsert them by `reviewId`, and flag new feedback for analysis or follow-up.

#### Market researchers

Build source-linked datasets about local provider categories, geographic coverage, rating distribution, and review themes.

#### Data engineers and analysts

Feed normalized seller and review tables into a warehouse, dashboard, spreadsheet, or text-analysis pipeline without maintaining a custom Bark parser.

### Why use this Bark scraper?

- ✅ **URL-driven scope** — process the precise sellers you care about rather than crawling unrelated search pages.
- ✅ **Two normalized datasets** — avoid mixing business rows and review rows with incompatible columns.
- ✅ **Stable identifiers** — use `profileId` and `reviewId` for repeat-run deduplication.
- ✅ **Typed data** — ratings and review counts are numbers, dates are source dates, and URLs are absolute.
- ✅ **Fail-safe behavior** — invalid target URLs are rejected and total extraction failure exits non-zero.
- ✅ **Optional proxy support** — normal prefilled runs avoid proxy cost, while advanced users can configure Apify Proxy.
- ✅ **Apify-native delivery** — use datasets, schedules, API clients, webhooks, integrations, and MCP.

### What Bark data can you extract?

#### Seller profile dataset

| Field | Type | Description |
|---|---|---|
| `recordType` | string | Always `seller` |
| `profileId` | string | Stable public profile identifier |
| `businessName` | string | Seller or company name |
| `address` | string | Public location text, when present |
| `categories` | array | Public Bark services or categories |
| `description` | string | Public About description |
| `aggregateRating` | number | Aggregate star rating |
| `reviewCount` | number | Public aggregate review count |
| `profileUrl` | string | URL submitted in the input |
| `canonicalUrl` | string | Canonical Bark profile URL |
| `countryCode` | string | Country segment from the Bark URL |
| `scrapedAt` | string | UTC extraction timestamp |

#### Review dataset

| Field | Type | Description |
|---|---|---|
| `recordType` | string | Always `review` |
| `reviewId` | string | Deterministic ID for repeat-run upserts |
| `profileId` | string | Join key to the seller dataset |
| `businessName` | string | Reviewed seller name |
| `author` | string | Public reviewer name or `Anonymous` |
| `rating` | number | Review star rating, when present |
| `datePublished` | string | Source publication date |
| `text` | string | Normalized public review text |
| `service` | string | Review service/category, when shown |
| `verified` | boolean | Whether Bark displays verified text |
| `profileUrl` | string | Canonical seller profile URL |
| `scrapedAt` | string | UTC extraction timestamp |

Optional fields are omitted when Bark does not publish them. The Actor does not invent missing contact details.

### How to scrape Bark seller profiles

1. Open the Actor input page.
2. Add one or more public Bark company profile URLs under **Bark seller profile URLs**.
3. Set **Maximum seller profiles** to bound the batch.
4. Choose how many public reviews to save per profile.
5. Leave proxy disabled for a normal first run.
6. Click **Start**.
7. Open the **Bark Seller Profiles** and **Bark Seller Reviews** datasets.
8. Export the data or connect it to your workflow.

For a cheap smoke test, keep the prefilled one-profile input unchanged.

### Input parameters

#### `startUrls` (required)

An array of public Bark company profile URLs. Supported URLs follow this pattern:

`https://www.bark.com/en/{country}/company/{seller-slug}/{profile-id}/`

Current Bark profiles using `/en/{country}/b/{seller-slug}/{profile-id}/` are also supported.

Category pages, search pages, arbitrary Bark pages, and other domains fail validation. This prevents accidental out-of-scope crawling.

#### `maxProfiles`

Maximum number of unique profiles to process. Default: `20`. Prefill: `1`. Allowed range: `1–200`.

Duplicate URLs are removed before requests begin.

#### `maxReviewsPerProfile`

Maximum reviews saved from each profile response. Default: `100`. Set it to `0` for profile-only enrichment.

This is a safety limit, not a promise that every public profile contains that many reviews.

#### `proxyConfiguration`

Optional Apify Proxy settings. The prefill disables proxy use because the proven public profile route works anonymously over direct HTTP. If Bark returns region-specific behavior for your target profiles, enable a matching proxy configuration.

### Example input

```json
{
  "startUrls": [
    {
      "url": "https://www.bark.com/en/us/company/athena-playground/2noOY/"
    }
  ],
  "maxProfiles": 1,
  "maxReviewsPerProfile": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

To collect only the seller record, change `maxReviewsPerProfile` to `0`.

### Example seller output

```json
{
  "recordType": "seller",
  "profileId": "2noOY",
  "businessName": "Athena Playground",
  "address": "4724 Melrose Avenue, Los Angeles, CA",
  "categories": ["Dog & Pet Grooming"],
  "aggregateRating": 5,
  "reviewCount": 2,
  "canonicalUrl": "https://www.bark.com/en/us/company/athena-playground/2noOY/",
  "countryCode": "US",
  "scrapedAt": "2026-07-17T00:00:00.000Z"
}
```

### Example review output

```json
{
  "recordType": "review",
  "reviewId": "deterministic-24-character-id",
  "profileId": "2noOY",
  "businessName": "Athena Playground",
  "author": "AmandaW",
  "rating": 5,
  "datePublished": "2023-10-09",
  "text": "My fur baby always looks like a superstar after a visit here...",
  "verified": false,
  "profileUrl": "https://www.bark.com/en/us/company/athena-playground/2noOY/",
  "scrapedAt": "2026-07-17T00:00:00.000Z"
}
```

Actual values come from the live public profile and can change between runs.

### How much does it cost to scrape Bark seller profiles and reviews?

The Actor uses pay-per-event pricing:

- **Start:** $0.005 once per run.
- **Dataset record:** tiered price for each seller or review record; the BRONZE rate is $0.00022661 per record, with plan discounts down to $0.00006345.

A one-profile example with one seller and two review rows charges the start plus three records: about $0.00568 at the BRONZE rate. Apify platform usage treatment depends on your plan and the active Store pricing display.

Check the Actor pricing tab for your exact plan tier.

### Review monitoring workflow

Run the same URL list daily or weekly with an Apify schedule:

1. Store the stable input in an Apify task.
2. Schedule the task at your preferred interval.
3. Send dataset items to a webhook or integration.
4. Upsert sellers by `profileId`.
5. Upsert reviews by `reviewId`.
6. Treat unseen review IDs as new feedback.

Because a review ID incorporates the profile, author, date, and text, repeat runs produce the same identifier for unchanged review content.

### CRM enrichment workflow

A sales operations team can maintain the Bark URL in each CRM company record, run a batch export, and map:

- `businessName` to account name;
- `address` to public business location;
- `categories` to service tags;
- `aggregateRating` and `reviewCount` to reputation fields;
- `canonicalUrl` to source URL;
- `scrapedAt` to enrichment timestamp.

Use individual reviews as related records rather than flattening them into the company table.

### Integrations

#### Google Sheets

Use the Google Sheets integration to send seller rows to an account sheet and review rows to a feedback sheet. Join them with `profileId`.

#### Webhooks and automation platforms

Trigger Make, Zapier, n8n, or your backend when a run succeeds. Fetch the dataset IDs from the run storage metadata and process each named dataset.

#### Data warehouses

Load seller and review exports into separate warehouse tables. Partition review snapshots by `scrapedAt` and deduplicate by `reviewId`.

#### AI review analysis

Send review `text`, `rating`, `service`, and `businessName` to a classification or sentiment model. Retain `profileUrl` for source traceability.

### JavaScript API example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/bark-seller-profiles-reviews-scraper').call({
  startUrls: [{ url: 'https://www.bark.com/en/us/company/athena-playground/2noOY/' }],
  maxProfiles: 1,
  maxReviewsPerProfile: 10,
  proxyConfiguration: { useApifyProxy: false }
});

console.log(run.id, run.status);
```

Named dataset IDs are available in the completed run's storage metadata.

### Python API example

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/bark-seller-profiles-reviews-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.bark.com/en/us/company/athena-playground/2noOY/'}],
    'maxProfiles': 1,
    'maxReviewsPerProfile': 10,
    'proxyConfiguration': {'useApifyProxy': False},
})

print(run['id'], run['status'])
```

### cURL API example

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~bark-seller-profiles-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url":"https://www.bark.com/en/us/company/athena-playground/2noOY/"}],
    "maxProfiles": 1,
    "maxReviewsPerProfile": 10,
    "proxyConfiguration": {"useApifyProxy": false}
  }'
```

Poll the returned run ID until it reaches a terminal status, then inspect its datasets.

### Use with Apify MCP

Expose the Actor to Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/bark-seller-profiles-reviews-scraper"
```

For Claude Desktop, Cursor, or VS Code, add an HTTP MCP server:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/bark-seller-profiles-reviews-scraper"
    }
  }
}
```

Example prompts:

- “Extract this Bark seller profile and summarize its customer feedback.”
- “Run the Bark review monitor for these profile URLs and list newly seen review IDs.”
- “Compare service categories, ratings, and review themes for this Bark seller list.”

### Tips for reliable runs

- 🔗 Copy the canonical public company page, not a Bark search or category URL.
- 🧪 Start with one profile and verify both datasets before increasing the batch.
- 💸 Leave proxy disabled unless direct access is regionally restricted.
- 🧱 Split very large URL inventories into bounded scheduled tasks.
- 🔁 Upsert with stable IDs rather than appending full snapshots blindly.
- 📅 Use `datePublished` for source chronology and `scrapedAt` for extraction chronology.
- 📝 Treat missing optional fields as “not publicly shown,” not as empty business facts.

### Limitations

- The Actor is URL-driven; it does not discover sellers by category or location.
- It extracts reviews present in Bark's public server-rendered profile response. Bark can change how many reviews it renders or how pagination works.
- Private lead details, account-only contacts, and authenticated dashboards are not accessed.
- Public profiles can omit addresses, descriptions, ratings, categories, dates, or review metadata.
- Bark can change HTML markup, regional availability, or anti-bot controls without notice.
- A successful seller row does not guarantee review rows when the seller has no public reviews.
- `maxReviewsPerProfile` caps extracted rows; it does not make hidden or unavailable reviews public.

### Error handling

Invalid target URLs fail before scraping so category pages or unrelated websites cannot bypass product scope.

For a mixed valid batch, one profile-level fetch or parse error is logged and skipped. If every profile fails, the Actor exits with a failed status rather than silently returning an empty success.

HTTP requests use realistic browser headers, a 45-second request timeout, and two bounded retries. This avoids infinite retry loops and keeps failures observable.

### Is scraping Bark legal?

This Actor extracts information from public seller pages. Web-scraping laws and contractual restrictions vary by country and use case.

You are responsible for:

- having a lawful purpose and legal basis for processing the data;
- respecting Bark's terms, applicable robots guidance, and access restrictions;
- following privacy, direct-marketing, database, and consumer-protection laws;
- minimizing collection and retention of personal data;
- honoring deletion, objection, and suppression requirements;
- avoiding harassment, spam, discrimination, or automated decisions with harmful effects.

This documentation is general information, not legal advice. Consult qualified counsel for regulated or high-risk workflows.

### Troubleshooting

#### Why did my run reject a URL?

Confirm that it is a public Bark company profile under `/en/{country}/company/{slug}/{id}/` or `/en/{country}/b/{slug}/{id}/`. Search results, category pages, lead forms, shortened URLs, and non-Bark domains are intentionally unsupported.

#### Why is the reviews dataset empty?

The seller may have no public reviews, `maxReviewsPerProfile` may be `0`, or Bark may not render review blocks in that profile response. Check the seller's `reviewCount`, run log, and live public page.

#### Why did the whole run fail?

The Actor fails when no seller profile can be extracted. Inspect logs for HTTP status codes, validation messages, or missing profile markup. Test one known public profile and consider a region-matched proxy only when direct access is restricted.

#### Why are some fields absent?

Optional fields are emitted only when Bark publishes them. This avoids misleading empty strings and fabricated values.

### FAQ

#### Do I need a Bark account?

No. v1 uses public seller profile pages and does not log in.

#### Can I search Bark by category and location?

No. This Actor accepts precise seller profile URLs. Use a discovery product to build a URL list, then pass those URLs here for profile and review enrichment.

#### Can I extract only seller details?

Yes. Set `maxReviewsPerProfile` to `0`.

#### Can I run it on a schedule?

Yes. Save the input as an Apify task and attach a daily, weekly, or monthly schedule.

#### How do I prevent duplicate reviews?

Upsert rows by `reviewId`. Unchanged public reviews keep the same deterministic ID across runs.

#### Does it scrape emails or phone numbers?

It only emits the documented public profile and review fields. It does not claim or infer contact details that are not part of the proven public response.

#### What happens if one URL is unavailable?

The URL is logged and skipped if another seller succeeds. If none succeed, the run fails visibly.

### Related scrapers

Extend a local-services research workflow with other Automation Lab actors:

- [Google Maps Scraper](https://apify.com/automation-lab/google-maps-scraper) — discover and enrich local business listings.
- [Trustpilot Scraper](https://apify.com/automation-lab/trustpilot-scraper) — collect company reputation data from another public review source.
- [Website Contact Scraper](https://apify.com/automation-lab/website-contact-scraper) — inspect public company websites after obtaining authorized target URLs.

Choose related actors only when their source and data-use terms fit your workflow.

### Data quality checklist

Before operationalizing a batch:

1. Confirm each input is the intended seller.
2. Review sample seller and review rows.
3. Verify ratings and dates are typed correctly.
4. Confirm join behavior with `profileId`.
5. Decide how missing optional fields should map downstream.
6. Deduplicate historical reviews by `reviewId`.
7. Retain canonical source URLs for auditability.
8. Set a retention policy appropriate to your use case.

### Support

If a current public Bark seller profile fails, include the run ID, the affected public URL, and the relevant log message in your Apify issue. Do not share private credentials, lead details, or personal account data.

For input questions, compare your payload with the prefilled example and schema descriptions. For API questions, include the client language and sanitized request body.

# Actor input Schema

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

Add public Bark company profile URLs such as https://www.bark.com/en/us/company/athena-playground/2noOY/ or current /en/xx/b/.../.../ profiles. Category and search-result URLs are not supported.

## `maxProfiles` (type: `integer`):

Stop after this many unique profile URLs. Keep the first run small, then increase for a CRM or monitoring batch.

## `maxReviewsPerProfile` (type: `integer`):

Save up to this many reviews found on each public profile page. Use 0 when only seller details are needed.

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

Optional Apify Proxy settings. Leave disabled for normal public profile requests; enable a country-matched proxy if Bark restricts your region.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.bark.com/en/us/company/athena-playground/2noOY/"
    }
  ],
  "maxProfiles": 1,
  "maxReviewsPerProfile": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `sellers` (type: `string`):

No description

## `reviews` (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 = {
    "startUrls": [
        {
            "url": "https://www.bark.com/en/us/company/athena-playground/2noOY/"
        }
    ],
    "maxProfiles": 1,
    "maxReviewsPerProfile": 10,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/bark-seller-profiles-reviews-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 = {
    "startUrls": [{ "url": "https://www.bark.com/en/us/company/athena-playground/2noOY/" }],
    "maxProfiles": 1,
    "maxReviewsPerProfile": 10,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/bark-seller-profiles-reviews-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 '{
  "startUrls": [
    {
      "url": "https://www.bark.com/en/us/company/athena-playground/2noOY/"
    }
  ],
  "maxProfiles": 1,
  "maxReviewsPerProfile": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/bark-seller-profiles-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bark Seller Profiles & Reviews Scraper",
        "description": "Extract public Bark seller profiles and individual reviews into clean datasets for lead research, reputation monitoring, CRM enrichment, and competitor analysis.",
        "version": "0.1",
        "x-build-id": "niGQz7UFWO1PMKDiy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~bark-seller-profiles-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-bark-seller-profiles-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~bark-seller-profiles-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-bark-seller-profiles-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~bark-seller-profiles-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-bark-seller-profiles-reviews-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "🔗 Bark seller profile URLs",
                        "type": "array",
                        "description": "Add public Bark company profile URLs such as https://www.bark.com/en/us/company/athena-playground/2noOY/ or current /en/xx/b/.../.../ profiles. Category and search-result URLs are not supported.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxProfiles": {
                        "title": "Maximum seller profiles",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Stop after this many unique profile URLs. Keep the first run small, then increase for a CRM or monitoring batch.",
                        "default": 20
                    },
                    "maxReviewsPerProfile": {
                        "title": "Maximum reviews per profile",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Save up to this many reviews found on each public profile page. Use 0 when only seller details are needed.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings. Leave disabled for normal public profile requests; enable a country-matched proxy if Bark restricts your region."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```