# OMR Reviews Scraper (`automation-lab/omr-reviews-scraper`) Actor

Extract public OMR software reviews with detailed feedback, recommendation and dimension scores, reviewer and company context, use cases, incentive status, vendor replies, videos, and aggregate statistics. No login or OMR API key required.

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

## Pricing

Pay per event + usage

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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

## OMR Reviews Scraper

Extract **public OMR software reviews** into a clean, analysis-ready dataset.

The **OMR Reviews Scraper** accepts OMR product URLs or slugs and returns one row per review with ratings, detailed positive and negative feedback, problems solved, use cases, reviewer and company context, incentive status, vendor replies, videos, and aggregate product statistics.

No OMR login or API key is required.
The Actor uses OMR's anonymous structured review endpoint rather than a heavyweight browser, making scheduled review monitoring fast and economical.

### What does OMR Reviews Scraper do?

OMR Reviews Scraper turns public product-review pages on [OMR Reviews](https://omr.com/en/reviews) into typed records that are ready for spreadsheets, databases, dashboards, LLM analysis, or alerts.

It can:

- ⭐ Extract the newest, oldest, highest-rated, or lowest-rated reviews.
- 🗣️ Preserve full positive, negative, and problems-solved text.
- 👤 Capture public reviewer names and anonymous-review status.
- 🏢 Add company name, role, size, and industry context when OMR publishes it.
- 📊 Return recommendation, support, setup, ease-of-use, and requirements scores.
- 🧩 List the product use cases attached to each review.
- 🎁 Identify incentivized reviews.
- 💬 Include vendor replies and reply senders.
- 🎥 Include public review-video links and media metadata.
- 📈 Repeat product-level review counts and rating buckets on every row.
- 🔁 Paginate through large products while respecting your per-product limit.
- 🔎 Apply OMR's source-side review text search.

Start with the prefilled HubSpot Sales Hub URL and ten reviews for a quick first run.

### Who is this OMR review scraper for?

**SaaS product marketing teams**

- Track how buyers describe competing tools in their own words.
- Collect proof points, objections, and switching triggers for positioning work.
- Compare use-case language across OMR product pages.

**Voice-of-customer and research teams**

- Build a recurring corpus of public B2B software feedback.
- Segment reviews by company size, role, or industry.
- Send detailed prose to sentiment, topic, and feature-request models.

**Reputation and review-management agencies**

- Monitor new client and competitor reviews on a schedule.
- Route low recommendation scores or negative text into an alert workflow.
- Preserve vendor replies for response-time and messaging analysis.

**DACH market-intelligence teams**

- Add an OMR-specific source to an existing G2, Trustpilot, or Gartner dataset.
- Export public German and English review text without manual copying.
- Compare aggregate OMR rating distributions between products.

**Data engineers and analysts**

- Receive stable flattened fields rather than scraping HTML cards.
- Use review and product IDs for upserts and snapshot comparisons.
- Trigger runs through API, schedules, webhooks, Make, Zapier, or MCP.

### Why use this OMR reviews extractor?

- ✅ **No login or API key:** the useful records are public and anonymously accessible.
- ✅ **HTTP-first:** no browser startup or rendering overhead in normal runs.
- ✅ **Rich review rows:** prose, ratings, firmographics, use cases, replies, media, and aggregates travel together.
- ✅ **Multiple products:** process up to 100 OMR product URLs or slugs in one run.
- ✅ **Strict validation:** non-OMR URLs and malformed product paths fail before extraction.
- ✅ **Bounded pagination:** `maxReviewsPerProduct` keeps volume and spend predictable.
- ✅ **Deduplicated output:** each product-review ID pair is saved and charged once.
- ✅ **Transparent redaction:** OMR placeholder text such as `xx` is preserved and marked.
- ✅ **Export anywhere:** download JSON, CSV, Excel, XML, RSS, or JSONL from Apify.
- ✅ **Automation-ready:** schedule refreshes and consume datasets through API or webhooks.

### What OMR review data can you extract?

| Category | Fields | Example use |
|---|---|---|
| Review identity | `reviewId`, `reviewTitle`, `publishedAt`, `reviewUrl` | Upsert and track reviews over time. |
| Recommendation | `recommendationScore`, `rightDirection` | Rank advocates and detractors. |
| Dimension scores | `customerSupportScore`, `easeOfSetupScore`, `easeOfUseScore`, `requirementsScore` | Compare operational strengths and weaknesses. |
| Reviewer | `reviewerName`, `reviewerFirstName`, `reviewerLastName`, `reviewerAnonymous` | Understand public reviewer context. |
| Company | `companyName`, `companyRole`, `companySize`, `companyIndustry` | Segment voice-of-customer data. |
| Detailed feedback | `positive`, `negative`, `problemsSolved` | Topic, sentiment, and messaging analysis. |
| Review context | `useCases`, `incentivized`, `isTextRedacted` | Filter and qualify feedback. |
| Vendor response | `vendorReply`, `vendorReplySender` | Review response programs. |
| Video | `videoUrl`, `videoName`, `videoContentType` | Discover public video testimonials. |
| Product | `productId`, `productSlug`, `productTitle`, `productUrl` | Join reviews by product. |
| Aggregates | `productReviewCount`, rating buckets, source pages | Build product-level dashboards. |
| Provenance | `sourcePage`, `scrapedAt` | Audit extraction and snapshots. |

Optional fields are omitted when OMR does not publish them.
The Actor never invents missing reviewer surnames, company details, replies, or scores.

### How much does it cost to scrape OMR reviews?

This Actor uses **pay-per-event pricing**: a small run-start charge plus a charge for each unique review saved.
All Actor compute is included in the event price.

Current formula-derived prices are:

| Apify plan | Price per review |
|---|---:|
| Free | $0.00003339 |
| Starter / Bronze | $0.000029035 |
| Scale / Silver | $0.000022647 |
| Business / Gold | $0.000017421 |
| Platinum | $0.000011614 |
| Diamond | $0.00001000 |

The run-start charge is $0.005.
For example, 100 reviews cost about $0.0079 on the Starter tier, including the start event.
Five hundred reviews cost about $0.0195 on the Starter tier.

Apify's Free plan includes monthly platform credits, so a small evaluation run can usually be covered by those credits.
The final Store prices always appear in the Apify pricing tab and take precedence over examples here.

### How to scrape OMR product reviews

1. Open [OMR Reviews Scraper on Apify](https://apify.com/automation-lab/omr-reviews-scraper).
2. Add one or more public OMR product URLs or lowercase product slugs.
3. Set `maxReviewsPerProduct` to the number of reviews you need from each product.
4. Choose the review order, such as newest first or highest rating.
5. Optionally add a review text search phrase.
6. Click **Start** and wait for the run to finish.
7. Open the default dataset to preview the review rows.
8. Export JSON, CSV, Excel, XML, RSS, or JSONL, or use the API URL.
9. Save the input as an Apify task if you want recurring monitoring.
10. Add a schedule or webhook for downstream alerts and analysis.

**Small product example**

```json
{
  "productUrls": [
    { "url": "https://omr.com/en/reviews/product/hubspot-sales-hub" }
  ],
  "maxReviewsPerProduct": 20,
  "sortBy": "date"
}
````

**Slug and text-search example**

```json
{
  "productSlugs": ["hubspot-sales-hub"],
  "maxReviewsPerProduct": 100,
  "sortBy": "relevance",
  "search": "automation"
}
```

**Multi-product monitoring example**

```json
{
  "productUrls": [
    { "url": "https://omr.com/en/reviews/product/hubspot-sales-hub" },
    { "url": "https://omr.com/en/reviews/product/salesforce-sales-cloud" }
  ],
  "maxReviewsPerProduct": 100,
  "sortBy": "date"
}
```

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---:|---|
| `productUrls` | array | empty | Public OMR product URLs. |
| `productSlugs` | array | empty | Lowercase OMR product slugs. At least one URL or slug is required; 100 combined maximum. |
| `maxReviewsPerProduct` | integer | `50` | Maximum unique reviews saved per product; 1-10,000. |
| `sortBy` | string | `date` | `date`, `date_asc`, `rating`, `rating_asc`, `weighted_score`, or `relevance`. |
| `search` | string | empty | Optional source-side review text phrase, up to 200 characters. |
| `proxyConfiguration` | object | direct | Optional Apify or custom proxy configuration. |

The web form prefill uses ten reviews to keep the first run fast and inexpensive.
The runtime default is 50 when API callers omit the limit.

URL inputs must:

- use HTTPS;
- use `omr.com` or `www.omr.com`;
- use `/en/reviews/product/{slug}` or `/de/reviews/product/{slug}`;
- contain no credentials;
- identify one product rather than a category, search, or home page.

### Output example

Each dataset item represents one public OMR review.

```json
{
  "reviewId": "sales-hub-bewertung",
  "reviewUrl": "https://omr.com/en/reviews/product/hubspot-sales-hub",
  "reviewTitle": "Sales Hub Bewertung",
  "publishedAt": "2026-04-30T16:13:00+02:00",
  "recommendationScore": 10,
  "customerSupportScore": 7,
  "easeOfSetupScore": 7,
  "easeOfUseScore": 7,
  "requirementsScore": 7,
  "rightDirection": "yes",
  "reviewerName": "Julian",
  "reviewerFirstName": "Julian",
  "reviewerAnonymous": false,
  "companyName": "LANGEundPFLANZ digital GmbH",
  "companyRole": "Head of Digital Consulting & Strategy",
  "companySize": "11_50",
  "companyIndustry": "management_consulting",
  "incentivized": false,
  "positive": "The currently published positive review text...",
  "negative": "The currently published negative review text...",
  "problemsSolved": "Sales automation, reporting, and business development",
  "useCases": ["CRM", "Sales Analytics", "Sales Enablement"],
  "isTextRedacted": false,
  "productId": "9",
  "productSlug": "hubspot-sales-hub",
  "productTitle": "HubSpot Sales Hub",
  "productUrl": "https://omr.com/en/reviews/product/hubspot-sales-hub",
  "productReviewCount": 520,
  "sourcePage": 1,
  "sourceTotalPages": 11,
  "scrapedAt": "2026-07-22T00:00:00.000Z"
}
```

Values above illustrate the field shape.
Review text and aggregate counts can change as OMR updates its public pages.

### OMR review scores and redacted records

OMR recommendation and dimension scores are returned as source numbers, not converted into stars.
That preserves the exact public data for analysis.

Some anonymous or video-led reviews use `xx` as placeholder text.
The Actor keeps that source value and sets `isTextRedacted` to `true`.
This is preferable to silently dropping a valid review or pretending that the content was empty.

Reviewer surnames and company fields may also be absent.
Those optional fields are omitted rather than set to fabricated values.

### Sorting and text search

Choose `date` for newest-first monitoring.
Choose `date_asc` for historical collection in oldest-first order.
Choose `rating` or `rating_asc` for advocate or detractor research.
Choose `weighted_score` to use OMR's source ranking.
Choose `relevance` when the `search` field is present.

The Actor sends `search` to OMR's review API.
It does not perform fuzzy matching after extraction.
If a search has no matching reviews, the run fails clearly instead of reporting a misleading successful empty dataset.

### Tips for reliable OMR review extraction

- 🧪 Start with 10-20 reviews from one product before increasing volume.
- 🔁 Use newest-first order for scheduled monitoring tasks.
- 🆔 Deduplicate downstream by `productSlug` plus `reviewId`.
- 📅 Keep `publishedAt` and `scrapedAt`; they answer different questions.
- 🧩 Preserve `useCases` as an array when loading data into a warehouse.
- 🔎 Use a short, specific search phrase rather than a long sentence.
- 🌐 Leave proxy disabled unless direct requests fail in your environment.
- 📉 Use the aggregate rating buckets for quick product-level comparisons.
- ⚠️ Treat omitted fields as unavailable public source data, not extraction errors.

### Monitoring new OMR reviews

Create one saved Apify task per product group or competitive set.
Use `sortBy: "date"` and a bounded recent-review limit.
Schedule the task daily, weekly, or monthly depending on review velocity.

For change detection:

1. Store `productSlug` and `reviewId` in your destination.
2. Upsert each scheduled dataset item by that compound key.
3. Trigger alerts only for previously unseen IDs.
4. Route low scores or matching keywords to the relevant team.
5. Retain `scrapedAt` for monitoring audit history.

The Actor does not maintain cross-run state automatically.
This keeps each dataset complete and makes your destination the source of truth for alerts.

### OMR Reviews Scraper integrations

**OMR Reviews Scraper → Google Sheets**

- Append newly observed reviews to a product-marketing research sheet.
- Split use cases and company segments into reporting tabs.

**OMR Reviews Scraper → Slack or Microsoft Teams**

- Send an alert when a new review has a low recommendation score.
- Include the title, product, company context, and negative feedback.

**OMR Reviews Scraper → Make or Zapier**

- Run a saved task on a schedule.
- Filter new dataset rows by review ID.
- Create CRM notes, research cards, or notification messages.

**OMR Reviews Scraper → a data warehouse**

- Load JSONL into BigQuery, Snowflake, PostgreSQL, or DuckDB.
- Model reviews as facts and product/company fields as analysis dimensions.

**OMR Reviews Scraper → an LLM pipeline**

- Summarize recurring praise and objections.
- Cluster problems solved and requested improvements.
- Compare themes by product, company size, role, or industry.

### Using the Apify API with Node.js

Install the official client:

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

Run the Actor and fetch its dataset:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/omr-reviews-scraper').call({
  productUrls: [{ url: 'https://omr.com/en/reviews/product/hubspot-sales-hub' }],
  maxReviewsPerProduct: 50,
  sortBy: 'date',
});

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

### Using the Apify API with Python

Install the official client:

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

Then run:

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/omr-reviews-scraper').call(run_input={
    'productUrls': [
        {'url': 'https://omr.com/en/reviews/product/hubspot-sales-hub'}
    ],
    'maxReviewsPerProduct': 50,
    'sortBy': 'date',
})

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

### Using the Apify API with cURL

Start a run:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~omr-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "productUrls": [{"url":"https://omr.com/en/reviews/product/hubspot-sales-hub"}],
    "maxReviewsPerProduct": 50,
    "sortBy": "date"
  }'
```

After the run succeeds, download dataset items using its `defaultDatasetId`:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?format=json&clean=true"
```

Keep the API token in an environment variable rather than committing it to code.

### Use OMR Reviews Scraper with AI agents via MCP

OMR Reviews Scraper can be called by AI assistants that support the [Model Context Protocol](https://docs.apify.com/platform/integrations/mcp).

**Claude Code**

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

**Claude Desktop, Cursor, or VS Code**

Add this MCP configuration:

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

Your client will ask you to authenticate with Apify.

Example prompts:

- "Use automation-lab/omr-reviews-scraper to collect the 50 newest HubSpot Sales Hub reviews from OMR and summarize the main objections."
- "Extract OMR reviews matching automation and group the use cases by company size."
- "Compare public OMR feedback for HubSpot Sales Hub and Salesforce Sales Cloud, including rating buckets and problems solved."

### Is it legal to scrape OMR reviews?

Publicly accessible website data can generally be collected for legitimate purposes, but the exact legal position depends on jurisdiction, purpose, scale, and handling.
You are responsible for complying with OMR's terms, applicable copyright rules, database rights, privacy law, and data-protection obligations such as GDPR.

Use the Actor responsibly:

- collect only public review data;
- avoid attempts to access private accounts or restricted content;
- minimize personal data to what your workflow genuinely needs;
- apply retention and access controls to reviewer information;
- do not use output for harassment, discrimination, or unsolicited targeting;
- honor valid deletion or correction obligations in your destination systems.

This documentation is practical guidance, not legal advice.
Consult qualified counsel for regulated or high-risk use cases.

### Limitations

- OMR can change its public GraphQL schema, sort values, or rate limits.
- The Actor extracts supplied product pages or slugs; it does not discover the full OMR product catalog.
- Optional reviewer, company, score, reply, and video fields depend on what OMR publishes.
- Some review text is source-redacted as `xx`; the Actor marks rather than reconstructs it.
- Text search uses OMR's source behavior and may return fewer reviews than the unfiltered product count.
- Direct HTTP is the tested default, but large or geographically distributed workflows may need proxy configuration.
- Product review counts and aggregate rating buckets are snapshots at extraction time.
- The Actor does not translate review text or calculate sentiment automatically.

### Troubleshooting

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

The Actor accepts only HTTPS OMR product pages under `/en/reviews/product/{slug}` or `/de/reviews/product/{slug}`.
Category, search, profile, and unrelated URLs are rejected so they cannot silently bypass the product contract.

**Why did the run return no dataset?**

Check that the product slug still exists and remove an overly narrow `search` phrase.
The Actor deliberately fails a total zero-review extraction so schedules do not look healthy while producing no useful data.

**Why are reviewer or company fields missing?**

OMR does not publish every field on every review.
Anonymous reviews and privacy-redacted records naturally contain fewer public attributes.

**Why does a text field contain `xx`?**

That is OMR's public placeholder on some redacted or video-led reviews.
Use `isTextRedacted` to filter those records.

**Should I enable a proxy?**

Not for a normal first run.
Direct anonymous HTTP is the verified route; use proxy configuration only when your network or recurring scale requires it.

### Frequently asked questions

**How fast is OMR Reviews Scraper?**

The Actor uses structured HTTP requests and fetches up to 50 reviews per page.
Small runs normally finish far faster than browser-based page-by-page extraction.

**Can it scrape all reviews for a product?**

Yes.
Set `maxReviewsPerProduct` high enough for the product's public count, up to 10,000.

**Can it scrape several OMR products in one run?**

Yes.
Supply up to 100 product URLs or slugs; the limit applies independently to each product.

**Does it require an OMR account?**

No.
The Actor uses anonymous public product and review data.

**Does it replace the official OMR website?**

No.
It automates extraction and export for analysis; OMR remains the authoritative source and presentation layer.

**Can it find sentiment automatically?**

It returns the source prose and scores.
Connect the dataset to your preferred sentiment or topic-analysis model for derived labels.

**How should I detect new reviews?**

Schedule newest-first runs and upsert by `productSlug` plus `reviewId` in your destination.

### Other review scrapers and B2B intelligence tools

Extend the same workflow with Automation Labs actors:

- [G2 Scraper](https://apify.com/automation-lab/g2-scraper) — B2B software reviews and product intelligence from G2.
- [G2 Software Review Feed Scraper](https://apify.com/automation-lab/g2-software-review-feed-scraper) — recurring G2 review-feed collection.
- [Trustpilot Scraper](https://apify.com/automation-lab/trustpilot-scraper) — public company reviews from Trustpilot.
- [Gartner Peer Insights Reviews Scraper](https://apify.com/automation-lab/gartner-peer-insights-reviews-scraper) — enterprise software review intelligence.
- [Sitejabber Reviews Scraper](https://apify.com/automation-lab/sitejabber-reviews-scraper) — consumer review extraction.
- [BBB Reviews Scraper](https://apify.com/automation-lab/bbb-reviews-scraper) — public Better Business Bureau reviews.
- [Chrome Web Store Extension Reviews Scraper](https://apify.com/automation-lab/chrome-webstore-extension-reviews-scraper) — extension review monitoring.

Choose OMR Reviews Scraper when the required source is OMR and the workflow needs rich product-level B2B review records.

# Actor input Schema

## `productUrls` (type: `array`):

Add URLs such as https://omr.com/en/reviews/product/hubspot-sales-hub or slugs such as hubspot-sales-hub.

## `productSlugs` (type: `array`):

Alternatively add lowercase OMR product slugs such as hubspot-sales-hub. Use this field for API and bulk workflows that already store slugs.

## `maxReviewsPerProduct` (type: `integer`):

Stop after saving this many unique reviews from each supplied OMR product.

## `sortBy` (type: `string`):

Choose a verified OMR review sort order. Date returns the newest reviews first.

## `search` (type: `string`):

Optional. Ask OMR to return reviews matching this phrase. Leave empty to extract all reviews.

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

Optional proxy routing for OMR page and GraphQL requests.

## Actor input object example

```json
{
  "productUrls": [
    {
      "url": "https://omr.com/en/reviews/product/hubspot-sales-hub"
    }
  ],
  "maxReviewsPerProduct": 10,
  "sortBy": "date",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

Open the normalized public OMR reviews in the overview dataset view.

# 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 = {
    "productUrls": [
        {
            "url": "https://omr.com/en/reviews/product/hubspot-sales-hub"
        }
    ],
    "maxReviewsPerProduct": 10,
    "sortBy": "date",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/omr-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 = {
    "productUrls": [{ "url": "https://omr.com/en/reviews/product/hubspot-sales-hub" }],
    "maxReviewsPerProduct": 10,
    "sortBy": "date",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/omr-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 '{
  "productUrls": [
    {
      "url": "https://omr.com/en/reviews/product/hubspot-sales-hub"
    }
  ],
  "maxReviewsPerProduct": 10,
  "sortBy": "date",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/omr-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OMR Reviews Scraper",
        "description": "Extract public OMR software reviews with detailed feedback, recommendation and dimension scores, reviewer and company context, use cases, incentive status, vendor replies, videos, and aggregate statistics. No login or OMR API key required.",
        "version": "0.1",
        "x-build-id": "h5hhc5nu4K4DPpR9H"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~omr-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-omr-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~omr-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-omr-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~omr-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-omr-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",
                "properties": {
                    "productUrls": {
                        "title": "Product URLs or slugs",
                        "minItems": 1,
                        "maxItems": 100,
                        "type": "array",
                        "description": "Add URLs such as https://omr.com/en/reviews/product/hubspot-sales-hub or slugs such as hubspot-sales-hub.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "productSlugs": {
                        "title": "Product slugs",
                        "minItems": 1,
                        "maxItems": 100,
                        "type": "array",
                        "description": "Alternatively add lowercase OMR product slugs such as hubspot-sales-hub. Use this field for API and bulk workflows that already store slugs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerProduct": {
                        "title": "Maximum reviews per product",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after saving this many unique reviews from each supplied OMR product.",
                        "default": 50
                    },
                    "sortBy": {
                        "title": "Review order",
                        "enum": [
                            "date",
                            "date_asc",
                            "rating",
                            "rating_asc",
                            "weighted_score",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Choose a verified OMR review sort order. Date returns the newest reviews first.",
                        "default": "date"
                    },
                    "search": {
                        "title": "Review text search",
                        "maxLength": 200,
                        "type": "string",
                        "description": "Optional. Ask OMR to return reviews matching this phrase. Leave empty to extract all reviews."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy routing for OMR page and GraphQL requests."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```