# Fiverr Scraper (`mlg14/fiverr-scraper`) Actor

Scrape Fiverr gigs by category or keyword: starting price, rating, reviews, delivery time, seller level and country, gig URLs and images. Export to CSV/JSON/Excel. About 40-48 gigs per category; sitemap fallback without prices.

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

## Pricing

$0.40 / 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

## Fiverr Scraper: Gig Prices, Ratings, Reviews and Sellers

Scrape Fiverr gigs by category or keyword and export the data to CSV, JSON or Excel: starting price, rating, number of reviews, delivery time, seller level, seller country and gig images, plus gig URLs and seller usernames. It is a Fiverr gig scraper and a Fiverr API alternative for pricing research, freelancer market analysis and lead lists, with a cheap catalogue fallback when Fiverr blocks the browser.

Fiverr protects its pages with PerimeterX bot detection, so this actor works differently from a plain HTTP scraper. It opens Fiverr in a real browser on a US residential connection, clicks through from the homepage to the category the way a visitor would, and reads the gig data the page itself delivers. If Fiverr challenges a connection, the actor drops it and tries a new one. It never solves the "press and hold" challenge. Read the Limits section before you plan a large job: each category listing gives you about 40 to 48 distinct gigs, not the whole category.

### What data can you extract from Fiverr?

Every dataset item is one gig. Rows read from a category listing (`source` = `listing`) contain all fields below. Rows from the sitemap fallback (`source` = `sitemap`) contain only gig ID, title, URL, seller name and URL, sub-category, images and the input fields; price, rating and the other listing fields are not present on those rows.

| Field | Description | Example |
| --- | --- | --- |
| `gigId` | Fiverr gig ID (unique key) | `426714967` |
| `title` | Gig title | `I will design custom minimalist logo design and branding kit` |
| `gigUrl` | Gig URL | `https://www.fiverr.com/kainat_designex/...` |
| `startingPrice` | Price of the cheapest package, in `currency` | `15` |
| `currency` | Price currency | `USD` |
| `rating` | Gig rating, 0 to 5 | `4.89` |
| `reviewCount` | Number of reviews on the gig | `101` |
| `deliveryDays` | Delivery time of the cheapest package, in days | `1` |
| `packageCount` | Number of packages (1 or 3) | `3` |
| `sellerName` | Seller username | `kainat_designex` |
| `sellerUrl` | Seller profile URL | `https://www.fiverr.com/kainat_designex` |
| `sellerDisplayName` | Seller display name | `Kainat T` |
| `sellerCountry` | Seller country code | `PK` |
| `sellerLevel` | `top_rated`, `level_two`, `level_one`, or empty for new sellers | `level_two` |
| `sellerRating` | Seller's overall rating, 0 to 5 | `4.89` |
| `sellerReviewCount` | Seller's total reviews | `101` |
| `isPro` | Fiverr Pro gig | `false` |
| `isFiverrChoice` | Fiverr's Choice gig | `false` |
| `isPromoted` | Shown as a promoted gig in the listing | `false` |
| `isSellerOnline` | Seller online at scrape time | `true` |
| `subCategory` | Sub-category name | `Logo Design` |
| `categoryId`, `subCategoryId` | Fiverr category IDs | `3`, `49` |
| `images` | Gig image URLs, up to 10 | array of URLs |
| `sourceMode` | Which input produced the row: `search`, `category`, `searchUrl`, `sellerUrl` or `gigUrl` | `search` |
| `searchQuery` | The keyword used, if any | `logo design` |
| `source` | `listing` (browser, with prices) or `sitemap` (fallback, no prices) | `listing` |
| `listingUrl` | The category page the gig was read from | `https://www.fiverr.com/categories/graphics-design/creative-logo-design` |
| `scrapedAt` | Collection time (UTC) | `2026-10-23T16:36:59+00:00` |

`startingPrice` is the price of the cheapest package. Prices for the Standard and Premium packages, extras, gig descriptions, FAQs, individual review texts and order counts are not included, because the listing page does not contain them.

### How to scrape Fiverr gigs

1. Enter one or more **Keywords** (for example `logo design`), or paste a Fiverr **category URL**. A keyword is matched to the closest Fiverr category, and the actor writes the chosen category to the log.
2. Set **Maximum rows**. You pay per result, so this is your cost cap.
3. Click **Start**. A run with one category usually takes 1.5 to 4 minutes, because the browser may need a few attempts until Fiverr lets a connection through.
4. Download the dataset as JSON, CSV, Excel or HTML, or read it with the Apify API.

### Input

| Name | Type | Default | Description |
| --- | --- | --- | --- |
| `searchQueries` | array of strings | `["logo design"]` | Keywords. Each keyword is mapped to the closest Fiverr category (all words must appear in the category name). Keywords that match no category use the sitemap fallback without prices. This is not Fiverr's own search ranking. |
| `categoryUrls` | array of URLs | one logo-design category | Category or sub-category URLs such as `https://www.fiverr.com/categories/graphics-design/creative-logo-design`. A top-level category such as `https://www.fiverr.com/categories/graphics-design` is expanded into its sub-categories. |
| `startUrls` | array of URLs | empty | Category URLs work like `categoryUrls`. Seller URLs return that seller's gigs from the sitemap. A gig URL returns one row built from the URL only. A search URL uses its `query` parameter as a keyword. Rows from these inputs have no price. |
| `maxItems` | integer | `40` | Maximum rows across all inputs. |
| `maxItemsPerSearch` | integer | `40` | Maximum rows for each keyword or category. |
| `proxyConfiguration` | object | Apify proxy | Used for the sitemap downloads. The browser always uses a US residential connection. |

All inputs are optional. With no input at all the actor scrapes the default keyword `logo design`.

Example input:

```json
{
  "searchQueries": ["logo design", "wordpress"],
  "categoryUrls": ["https://www.fiverr.com/categories/video-animation/video-editing"],
  "maxItems": 120,
  "maxItemsPerSearch": 48
}
```

### Output example

```json
{
  "gigId": "426714967",
  "title": "I will design custom minimalist logo design and branding kit",
  "gigUrl": "https://www.fiverr.com/kainat_designex/esign-a-minimalist-and-professional-logo-for-your-business",
  "startingPrice": 15,
  "currency": "USD",
  "rating": 4.89,
  "reviewCount": 101,
  "deliveryDays": 1,
  "packageCount": 3,
  "sellerName": "kainat_designex",
  "sellerUrl": "https://www.fiverr.com/kainat_designex",
  "sellerDisplayName": "Kainat T",
  "sellerCountry": "PK",
  "sellerLevel": "level_two",
  "sellerRating": 4.891089,
  "sellerReviewCount": 101,
  "isPro": false,
  "isFiverrChoice": false,
  "isPromoted": false,
  "isSellerOnline": true,
  "subCategory": "Logo Design",
  "categoryId": 3,
  "subCategoryId": 49,
  "images": ["https://fiverr-res.cloudinary.com/t_main1,q_auto,f_auto/gigs/426714967/original/b8fa8b4e....png"],
  "sourceMode": "search",
  "searchQuery": "logo design",
  "source": "listing",
  "listingUrl": "https://www.fiverr.com/categories/graphics-design/creative-logo-design",
  "scrapedAt": "2026-10-23T16:36:59+00:00"
}
```

In a real run of 40 logo-design gigs, every row had a price, rating, review count, delivery time and seller level. Starting prices ranged from 10 to 130 USD.

### How does the Fiverr scraper work?

Fiverr listing pages are rendered by a server that embeds the full list of gigs as JSON inside the page. The actor reads that embedded data instead of parsing visible text, which is why prices, ratings and review counts come out as clean numbers rather than text such as "From $15".

Getting to that page is the hard part. Direct requests to Fiverr, from data-center or residential connections, receive an HTTP 403 and a "press and hold" test. The actor starts a hardened Firefox browser on a US residential connection, opens the Fiverr homepage, and then clicks through to the category and sub-category the way a visitor would. About six in ten connections are let through; the others are dropped and replaced automatically. The actor never solves the interactive test and never logs in.

Before it starts the browser, the actor maps each keyword to a category using Fiverr's public category sitemap. For example, `logo design` becomes `https://www.fiverr.com/categories/graphics-design/creative-logo-design`, and the chosen category is written to the run log so you can check it. Inputs that cannot be turned into a category, such as seller profile URLs or gig URLs, are served from the public gig sitemaps, which list gig IDs, URLs, sellers and images but no prices.

### Example: compare freelancer prices by seller level

Run the actor on a sub-category such as `https://www.fiverr.com/categories/video-animation/video-editing`, export the dataset to Excel, and group by `sellerLevel`. You can then compare median `startingPrice`, `rating` and `deliveryDays` for top rated, level two, level one and new sellers, and see whether the extra price of a top rated seller buys faster delivery or only a better rating. Repeat the run weekly with the same input to see how prices move.

### Use cases

- **Pricing research for freelancers and agencies.** See what the cheapest package costs in your category, how delivery time and seller level relate to price, and where you can position yourself.
- **Market analysis.** Compare categories by price level, rating and seller concentration, or by seller country.
- **Competitor and benchmark tracking.** Schedule the actor weekly on the same categories and compare ratings, review counts and prices over time.
- **Lead lists for B2B tools.** Build lists of Fiverr sellers by category and level for outreach on products that serve freelancers.
- **Data for dashboards and models.** Feed price, rating and delivery data into spreadsheets, BI tools or machine-learning pipelines.

### How much does it cost to scrape Fiverr?

You pay per result (the price per 1,000 results is on the actor page) and Apify platform usage is included. `maxItems` is a hard cap on what you can be charged. You are only charged for rows written to the dataset, including sitemap-fallback rows.

Examples, with one category listing giving about 40 to 48 gigs:

- 40 gigs from one category: one browser session, usually 1.5 to 3 minutes.
- 200 gigs from five categories: five listing pages read over one to three connections.
- 1,800 gigs from a top-level category such as Graphics & Design, which is expanded into up to 40 sub-categories.

Results are charged per gig, not per attempt: connections that Fiverr challenges and the actor replaces do not add to your bill.

### Tips for best results

- To get more than one page of gigs, give several sub-categories or keywords instead of one. Each category listing contributes its first page of about 48 gigs.
- Use sub-category URLs (three path segments, for example `/categories/graphics-design/creative-logo-design`). They contain the gigs; top-level categories do not and are expanded for you.
- Keep `maxItems` close to what you need. The actor stops as soon as the cap is reached.
- Run at off-peak times and schedule repeated runs instead of one huge run. Rows are de-duplicated by `gigId` inside a run.
- A keyword works best when it is the name of a Fiverr service (`logo design`, `video editing`, `wordpress`). Free-text phrases that are not a category name use the sitemap fallback and return no prices.

### Limits

- **First page per category.** Fiverr challenges the second page of a listing with an interactive "press and hold" test. The actor does not solve it, so you get the first listing page of each category: 48 slots, about 40 to 48 distinct gigs (promoted gigs repeat). Add categories for more.
- **No Fiverr search.** Fiverr's `/search/` pages are disallowed in its robots.txt and are not used. Keywords are mapped to categories instead, so the result order is the category's default order, not a search ranking.
- **Cheapest package only.** The price, delivery time and package count describe the listing card, not all package tiers.
- **Success is not guaranteed on every connection.** Roughly 4 in 10 connections are challenged at the homepage and are replaced automatically, which makes runs take 1.5 to 4 minutes. If every attempt fails, the actor falls back to the public sitemap (no prices, `source` = `sitemap`) and says so in the log.
- **No gig detail pages, seller pages or reviews.** Those pages are challenged more strictly.
- **Prices are shown in US dollars.**

### Use with AI agents (MCP)

Example prompts for an agent connected to this actor through the Apify MCP server:

- "Get 40 Fiverr logo design gigs and tell me the median starting price and the share sold by top rated sellers."
- "Scrape the Fiverr video editing category and list the five cheapest gigs with at least 100 reviews and delivery in 2 days or less."

### FAQ

**Is it legal to scrape Fiverr?** The actor reads only public pages that any visitor can open, does not log in, and does not collect private data. Fiverr's terms of service restrict automated access, so check them for your use case, and handle seller names under GDPR and local privacy laws.

**Do I need to set up proxies?** No. The browser uses a US residential connection that the actor sets up. The proxy setting only affects the sitemap downloads.

**How fast is it?** About 1.5 to 4 minutes for one category, mostly browser start-up and retries after challenged connections.

**Can I schedule it or get alerts on changes?** Yes. Use Apify schedules and compare datasets between runs, or connect a webhook to your workflow.

**Can I export to Google Sheets or Excel?** Yes. Download Excel or CSV, or use the Google Sheets integration.

**Why is a field empty?** `sellerLevel` is empty for sellers without a level. Rows with `source` = `sitemap` have no price, rating or delivery fields.

**Why do I get fewer gigs than my maximum?** A category listing page holds about 48 gigs and the second page is protected. Add more categories or keywords.

### Integrations

Run the actor from the Apify API, schedule it, trigger webhooks when a run finishes, and connect the dataset to Zapier, Make, n8n, Google Sheets or your own code.

### Support

Open an issue on the Issues tab. We reply within 24 hours and add fields on request.

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords. Each keyword is matched to the closest Fiverr category (e.g. 'logo design' -> Logo Design) and that category's gig listing is scraped with price, rating, reviews and delivery time. Keywords that match no category fall back to the public sitemap catalogue (no prices). This is not Fiverr's own search ranking.

## `categoryUrls` (type: `array`):

Fiverr category or subcategory URLs (https://www.fiverr.com/categories/<category>/<subcategory>). A top-level category (https://www.fiverr.com/categories/graphics-design) is expanded into its sub-categories. Gigs are read from the listing pages with price, rating, reviews, delivery time and seller level.

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

Optional extra URLs. Category URLs work like 'Category URLs'. Seller profile URLs and gig URLs return sitemap-only rows (gig ID, URL, seller, images; no price). Search URLs use their query as a keyword.

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

Stop after this many gigs across all inputs. You pay per result, so this is also your cost cap. Each category listing yields about 40-48 distinct gigs (Fiverr's second page is protected), so use several categories, keywords or a top-level category for more.

## `maxItemsPerSearch` (type: `integer`):

Maximum gigs for each keyword, category or seller input.

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

Apify proxy settings for the sitemap downloads. The browser part always uses a US residential IP (a new one is picked automatically if Fiverr challenges the current one).

## Actor input object example

```json
{
  "searchQueries": [
    "logo design"
  ],
  "categoryUrls": [
    "https://www.fiverr.com/categories/graphics-design/creative-logo-design"
  ],
  "startUrls": [],
  "maxItems": 40,
  "maxItemsPerSearch": 40,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Gig catalog rows in the default dataset.

# 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 = {
    "searchQueries": [
        "logo design"
    ],
    "categoryUrls": [
        "https://www.fiverr.com/categories/graphics-design/creative-logo-design"
    ],
    "maxItems": 40,
    "maxItemsPerSearch": 40,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("mlg14/fiverr-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 = {
    "searchQueries": ["logo design"],
    "categoryUrls": ["https://www.fiverr.com/categories/graphics-design/creative-logo-design"],
    "maxItems": 40,
    "maxItemsPerSearch": 40,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("mlg14/fiverr-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 '{
  "searchQueries": [
    "logo design"
  ],
  "categoryUrls": [
    "https://www.fiverr.com/categories/graphics-design/creative-logo-design"
  ],
  "maxItems": 40,
  "maxItemsPerSearch": 40,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call mlg14/fiverr-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mlg14/fiverr-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/yxFZnGo1myWgJMd38/builds/6gf7gpWKha9kPFa3B/openapi.json
