# Serchen Software Reviews Scraper (`crawlerbros/serchen-scraper`) Actor

Scrape Serchen, a global SaaS marketplace with 40,000+ products and structured reviews. Search by keyword, browse by category, or fetch specific product pages. Returns name, description, rating, review count, logo, website URL, category, and more.

- **URL**: https://apify.com/crawlerbros/serchen-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Automation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 3 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Serchen Software Reviews Scraper

Scrape [Serchen](https://www.serchen.com) — a global SaaS marketplace with 40,000+ cloud software products and structured reviews. Search by keyword, browse by category, or fetch specific product pages.

> **Note:** This actor replaces GetApp scraping. GetApp (Gartner) blocks all scraping from datacenter IPs with HTTP 403. Serchen provides equivalent or richer software listing data and is fully accessible without authentication or proxy.

### What you can scrape

- **Product name, slug, and description** (from JSON-LD structured data)
- **Rating** (1–5 stars) and **review count**
- **Logo URL** and **vendor website URL**
- **Category** (CRM, Project Management, HR, etc.)
- **Serchen product URL**

### Use cases

- Build a database of SaaS products in a specific niche
- Monitor software ratings and review trends
- Research competitors in a category
- Enrich product lists with pricing and review data

### Input

| Field | Type | Description |
|---|---|---|
| `mode` | select | `search`, `byCategory`, or `byUrl` |
| `searchQuery` | string | Keyword to search (mode=search) |
| `category` | select | Serchen category slug (mode=byCategory) |
| `softwareUrls` | array | Serchen URLs for byUrl mode |
| `maxItems` | integer | Max products to return (1–1000, default 50) |

#### Mode: Search

Search Serchen for software products using the built-in search API.

```json
{
  "mode": "search",
  "searchQuery": "CRM software",
  "maxItems": 20
}
````

#### Mode: Browse by Category

Browse all products in a specific Serchen category.

```json
{
  "mode": "byCategory",
  "category": "crm-software",
  "maxItems": 50
}
```

#### Mode: Fetch by URL

Scrape specific product pages by their Serchen URLs.

```json
{
  "mode": "byUrl",
  "softwareUrls": [
    "https://www.serchen.com/company/nutshell/",
    "https://www.serchen.com/company/salesforce-com/"
  ]
}
```

### Output

Each record contains:

```json
{
  "slug": "nutshell",
  "name": "Nutshell",
  "description": "Nutshell is a user-friendly CRM that helps teams win more deals...",
  "logoUrl": "https://images.serchen.com/logos/24361.jpg",
  "websiteUrl": "http://www.nutshell.com/",
  "serchenUrl": "https://www.serchen.com/company/nutshell/",
  "rating": 4.33,
  "reviewCount": 3,
  "category": "CRM Software",
  "scrapedAt": "2026-05-23T10:00:00+00:00"
}
```

Fields are omitted when not available — no null values in output.

### Available Categories

Use these slugs in `byCategory` mode. Browse the full list at https://www.serchen.com/category/

| Category | Slug |
|---|---|
| CRM | `crm-software` |
| Project Management | `project-management-software` |
| Accounting | `accounting-software` |
| HR Management | `hr-management-software` |
| Help Desk | `help-desk-software` |
| eCommerce | `ecommerce-software` |
| Collaboration | `collaboration-software` |
| Time Tracking | `time-tracking-software` |
| Email Marketing | `email-marketing` |
| Payroll | `payroll-software` |
| Learning Management | `learning-management-system` |
| Video Conferencing | `video-conferencing-software` |

Serchen has 500+ category slugs. If a category you need is not in the dropdown, type it directly in the custom category field.

### Technical notes

- **No authentication required** — Serchen is a public directory
- **No proxy required** — works from Apify datacenter IPs
- **JSON-LD extraction** — uses structured schema.org data for reliability
- **Rate limit friendly** — 300–500ms delays between requests
- **Retry logic** — 3 attempts with exponential backoff on 429/5xx

### Data Source

Serchen describes itself as "the world's largest online marketplace for cloud services and SaaS software." The platform aggregates software products with descriptions, reviews, and ratings — comparable to GetApp or Capterra, but accessible without bot detection.

### FAQs

**Q: Why Serchen instead of GetApp?**
A: GetApp (Gartner-owned) returns HTTP 403 for all requests from datacenter IPs. Serchen provides similar software listing data and works reliably without proxies or authentication.

**Q: How is rating different from Capterra/GetApp?**
A: Serchen collects its own user reviews independently. Ratings are on a 1–5 scale, same as other review platforms.

**Q: Can I get all software in a category?**
A: Yes — set `maxItems` to a high value. Each category page shows 10 products, and the actor auto-paginates.

**Q: What is the `slug` field?**
A: The Serchen slug is the URL identifier for the product (e.g. `salesforce-com` for Salesforce). You can use it to construct the product URL: `https://www.serchen.com/company/{slug}/`

# Actor input Schema

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

What to scrape.

## `searchQuery` (type: `string`):

Keyword to search for software products (mode=search). Uses Serchen's autocomplete API, then fetches full details for each match.

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

Serchen category slug for byCategory mode (e.g. crm-software). Browse more at https://www.serchen.com/category/

## `softwareUrls` (type: `array`):

List of Serchen product page URLs to scrape (e.g. https://www.serchen.com/company/slack-2).

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

Maximum number of software products to return.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "CRM software",
  "category": "",
  "maxItems": 50
}
```

# Actor output Schema

## `software` (type: `string`):

Dataset containing all scraped Serchen software products.

# 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 = {
    "mode": "search",
    "searchQuery": "CRM software",
    "category": "",
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/serchen-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 = {
    "mode": "search",
    "searchQuery": "CRM software",
    "category": "",
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/serchen-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 '{
  "mode": "search",
  "searchQuery": "CRM software",
  "category": "",
  "maxItems": 50
}' |
apify call crawlerbros/serchen-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Serchen Software Reviews Scraper",
        "description": "Scrape Serchen, a global SaaS marketplace with 40,000+ products and structured reviews. Search by keyword, browse by category, or fetch specific product pages. Returns name, description, rating, review count, logo, website URL, category, and more.",
        "version": "1.0",
        "x-build-id": "Mn1ptmcehG0ryqRVl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~serchen-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-serchen-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/crawlerbros~serchen-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-serchen-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/crawlerbros~serchen-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-serchen-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byCategory",
                            "byUrl"
                        ],
                        "type": "string",
                        "description": "What to scrape.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Keyword to search for software products (mode=search). Uses Serchen's autocomplete API, then fetches full details for each match."
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "",
                            "crm-software",
                            "project-management-software",
                            "accounting-software",
                            "hr-management-software",
                            "marketing-automation",
                            "ecommerce-software",
                            "customer-service-software",
                            "collaboration-software",
                            "analytics",
                            "document-management-software",
                            "email-marketing",
                            "social-media-software",
                            "inventory-management",
                            "time-tracking-software",
                            "help-desk-software",
                            "video-conferencing-software",
                            "cyber-security",
                            "manufacturing-software",
                            "payroll-software",
                            "billing-invoicing",
                            "learning-management-system",
                            "task-management-software",
                            "team-collaboration-software",
                            "workflow-management"
                        ],
                        "type": "string",
                        "description": "Serchen category slug for byCategory mode (e.g. crm-software). Browse more at https://www.serchen.com/category/",
                        "default": ""
                    },
                    "softwareUrls": {
                        "title": "Software URLs (mode=byUrl)",
                        "type": "array",
                        "description": "List of Serchen product page URLs to scrape (e.g. https://www.serchen.com/company/slack-2).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of software products to return.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
