# Webflow Template Scraper (`coolinbex/webflow-template-scraper`) Actor

Scrape Webflow Marketplace templates with prices, designers, categories, CMS/Ecommerce features, styles, tags, images, descriptions, and preview links.

- **URL**: https://apify.com/coolinbex/webflow-template-scraper.md
- **Developed by:** [coolinbex](https://apify.com/coolinbex) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

## Webflow Template Scraper

Scrape structured template data from the **Webflow Marketplace** for research, discovery, competitive analysis, catalog building, lead generation, and automation.

The Actor accepts Webflow search terms, marketplace URLs, category URLs, or individual template URLs and returns clean records ready for JSON, CSV, Excel, API, or downstream workflows.

### What you can collect

Each template can include:

- Template name and Webflow Marketplace URL
- Price in USD and free/paid status
- Designer name and designer profile URL
- Publication date
- Layout type: One Page, Multi Page, or Multi Layout
- Subcategory
- Design styles
- Webflow features such as CMS, Ecommerce, forms, interactions, responsive navigation, and more
- Related tags
- CMS and Ecommerce indicators
- Marketplace description
- Primary preview image
- Live preview URL when available
- Source URL and scrape timestamp

Fields are returned when Webflow exposes them for the template.

### Quick start

The Actor is ready to run with its default input. The default search is `saas` and returns up to 100 templates with detailed metadata.

Example:

```json
{
  "searchTerms": ["saas"],
  "maxItems": 100,
  "enrichDetails": true,
  "pricing": "all",
  "sortBy": "marketplace"
}
```

### Search multiple niches

```json
{
  "searchTerms": [
    "real estate",
    "agency",
    "portfolio"
  ],
  "maxItems": 250,
  "enrichDetails": true
}
```

Duplicate templates discovered from multiple searches are automatically removed.

### Scrape Webflow URLs directly

Use `startUrls` for Webflow Marketplace search pages, category pages, or individual template pages.

```json
{
  "searchTerms": [],
  "startUrls": [
    {
      "url": "https://webflow.com/templates/search/ecommerce"
    },
    {
      "url": "https://webflow.com/templates/html/cronza-website-template"
    }
  ],
  "maxItems": 100
}
```

Only Webflow template marketplace URLs are accepted. When explicit `startUrls` are supplied and the untouched default `saas` search is still present, the Actor prioritizes the explicit URLs so you do not receive unrelated default results.

### Filter results

#### Free templates only

```json
{
  "searchTerms": ["portfolio"],
  "pricing": "free",
  "maxItems": 100
}
```

#### Paid templates in a price range

```json
{
  "searchTerms": ["business"],
  "pricing": "paid",
  "minPrice": 29,
  "maxPrice": 79,
  "maxItems": 100
}
```

#### Filter by layout type

```json
{
  "searchTerms": ["landing page"],
  "layoutTypes": ["One Page"],
  "maxItems": 100
}
```

You can select one or more of:

- `One Page`
- `Multi Page`
- `Multi Layout`

### Sorting

Set `sortBy` to:

- `marketplace` — preserve the marketplace discovery order
- `newest` — newest publication date first
- `priceLowToHigh` — lowest known price first
- `priceHighToLow` — highest known price first

Sorting is applied before `maxItems`.

### Fast mode

Set `enrichDetails` to `false` when you mainly need listing-level information and want fewer requests.

```json
{
  "searchTerms": ["technology"],
  "maxItems": 500,
  "enrichDetails": false
}
```

Detailed fields such as descriptions, tags, and full feature lists are intentionally omitted in fast mode. Individual template URLs are still opened once when necessary so direct-URL runs return meaningful records.

### Input

| Field | Type | Default | Description |
|---|---|---:|---|
| `searchTerms` | string\[] | `["saas"]` | Webflow Marketplace searches |
| `startUrls` | object\[] | — | Search, category, or individual template URLs |
| `maxItems` | integer | `100` | Maximum unique templates to save |
| `enrichDetails` | boolean | `true` | Visit individual template pages for detailed metadata |
| `pricing` | string | `all` | `all`, `free`, or `paid` |
| `minPrice` | number | — | Minimum listed USD price |
| `maxPrice` | number | — | Maximum listed USD price |
| `layoutTypes` | string\[] | — | Optional layout filters |
| `sortBy` | string | `marketplace` | Marketplace, newest, or price sorting |
| `maxConcurrency` | integer | `10` | Maximum parallel page requests |
| `proxyConfiguration` | object | Apify Proxy | Proxy settings |

If both `searchTerms` and `startUrls` are empty, the Actor safely falls back to the `saas` marketplace search instead of producing an empty run.

### Output example

```json
{
  "name": "Cronza",
  "templateUrl": "https://webflow.com/templates/html/cronza-website-template",
  "priceUsd": 79,
  "isFree": false,
  "designer": "Theme Sleek",
  "designerUrl": "https://webflow.com/templates/designers/theme-sleek",
  "publishedDate": "2026-03-10",
  "layoutType": "Multi Page",
  "subcategory": "Business & Finance Blog",
  "styles": ["Dark", "Modern"],
  "features": [
    "Web fonts",
    "Responsive slider",
    "Ecommerce",
    "Content management system",
    "Responsive design",
    "Forms"
  ],
  "tags": ["crypto", "fintech", "business"],
  "hasCms": true,
  "hasEcommerce": true,
  "description": "A polished Webflow template for crypto blogs and digital product stores.",
  "imageUrl": "https://cdn.prod.website-files.com/example.webp",
  "previewUrl": "https://example.webflow.io/",
  "sourceUrl": "https://webflow.com/templates/search/crypto",
  "scrapedAt": "2026-09-18T12:00:00.000Z"
}
```

### Output formats

The default Apify dataset can be exported as:

- JSON
- CSV
- Excel
- XML
- RSS
- JSONL

You can also access results through the Apify API, integrations, webhooks, or other Actors.

A `SUMMARY` record is stored in the default key-value store with:

- Source URLs
- Number of unique templates discovered
- Number passing filters
- Number selected and saved
- Listing/detail request counts
- Failed request counts
- Effective run settings

### Reliability

The Actor is designed for repeatable marketplace scraping:

- Deduplicates templates by canonical Webflow template URL
- Retries temporary request failures
- Preserves listing metadata if a detail page cannot be enriched
- Validates Webflow-only start URLs
- Applies a hard maximum result limit
- Supports controlled concurrency
- Handles free and paid templates
- Normalizes dates, prices, and marketplace URLs
- Uses content-based extraction rather than depending on a single fragile CSS class

Webflow can change Marketplace markup over time. When a field is not available on a page, the Actor returns `null` or an empty array rather than inventing data.

### Common use cases

- Build searchable Webflow template catalogs
- Track newly published templates
- Compare template pricing
- Research designers and studios
- Find templates for specific industries
- Analyze style and feature trends
- Discover CMS or Ecommerce-ready templates
- Feed template data into spreadsheets, databases, dashboards, or AI workflows

### Responsible use

This Actor accesses publicly available Webflow Marketplace pages. Use the data responsibly and in accordance with applicable laws, Webflow's terms, and the rights of template creators.

# Changelog

This Actor's version history is a separate document: https://apify.com/coolinbex/webflow-template-scraper/changelog.md

# Actor input Schema

## `searchTerms` (type: `array`):

Search the Webflow Marketplace by keyword. The default searches for SaaS templates so the Actor works immediately.

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

Optional Webflow Marketplace search, category, or individual template URLs.

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

Maximum number of unique templates to save.

## `enrichDetails` (type: `boolean`):

Open individual template pages to collect descriptions, features, styles, tags, preview links, and additional metadata.

## `pricing` (type: `string`):

Choose whether to collect all templates, free templates, or paid templates.

## `minPrice` (type: `number`):

Optional minimum template price. Free templates are treated as $0.

## `maxPrice` (type: `number`):

Optional maximum template price. Free templates are treated as $0.

## `layoutTypes` (type: `array`):

Optionally filter templates by Webflow layout type.

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

Choose how collected templates are sorted.

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

Maximum number of Webflow pages processed simultaneously.

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

Configure proxy usage for Webflow Marketplace requests.

## Actor input object example

```json
{
  "searchTerms": [
    "saas"
  ],
  "startUrls": [
    {
      "url": "https://webflow.com/templates/search?query=saas"
    }
  ],
  "maxItems": 100,
  "enrichDetails": true,
  "pricing": "all",
  "sortBy": "marketplace",
  "maxConcurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `templates` (type: `string`):

Scraped Webflow templates.

## `summary` (type: `string`):

Counts, effective input, and run statistics.

# 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://webflow.com/templates/search?query=saas"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("coolinbex/webflow-template-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://webflow.com/templates/search?query=saas" }] }

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

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://webflow.com/templates/search?query=saas"
    }
  ]
}' |
apify call coolinbex/webflow-template-scraper --silent --output-dataset

```

## MCP server setup

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

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

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/6VNMGu6Jxp1ECfrtR/builds/DPpyxXPwBqXTcpAEh/openapi.json