# Fiverr Scraper - Gigs, Sellers, Prices & Delivery (`dami_studio/fiverr-scraper`) Actor

Scrape Fiverr gig listings from any search or category page. Each row has the gig title and link, seller username, level and country, the gig rating and review count, starting price in US dollars, delivery time and tags. Repeated ad slots are dropped, so one gig is never billed twice.

- **URL**: https://apify.com/dami\_studio/fiverr-scraper.md
- **Developed by:** [Dami's Studio](https://apify.com/dami_studio) (community)
- **Categories:** E-commerce, Lead generation, Jobs
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.52 / 1,000 gig returneds

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

Pulls gig listings off Fiverr search and category pages. One row per gig, with the title, the
seller, what the gig is rated, what it starts at, how fast it delivers, and the address of the
listing itself.

Start with the awkward part, because it changes what you get back. **A Fiverr results page holds 48
slots, and about 20 of them are paid placements.** The same gig is frequently served twice: once in
an ad slot, once organically. Across nine pages of one keyword, 432 slots held 289 distinct gigs.
This actor deduplicates on the gig id before anything is written, so you are never handed the same
gig twice and never billed for it twice. It also means a page yields roughly 30 new gigs, not 48.
Plan your page count around 30.

No account, no cookie, no login. It reads the same page a signed-out visitor sees.

### What you get

One row per gig:

| Field | What it is |
|---|---|
| `gigId`, `gigSlug`, `gigUrl` | Fiverr's own id, the URL slug, and the full link |
| `title` | the gig title as written by the seller |
| `gigImage` | the listing thumbnail |
| `sellerName`, `sellerDisplayName`, `sellerUrl`, `sellerImage` | username, the name they display, profile link, profile photo |
| `sellerLevel` | `new_seller`, `level_one_seller`, `level_two_seller` or `top_rated_seller` |
| `sellerCountry`, `sellerLanguages`, `sellerOnline` | country code, language codes, online right now |
| `sellerIsPro`, `sellerIsAgency` | vetted Pro seller; listing belongs to an agency |
| `sellerRating`, `sellerRatingCount` | the seller's score across everything they sell |
| `rating`, `reviewsCount` | **this gig's** score and review count, which is the one people usually want |
| `startingPrice`, `currency` | the cheapest package, in the currency Fiverr rendered |
| `startingPriceUsd` | the same figure converted to US dollars |
| `hourlyRateUsd` | filled in only where the seller offers hourly work |
| `deliveryDays`, `extraFastAvailable`, `packagesCount` | delivery on the cheapest package, whether a rush option exists, how many packages |
| `offersConsultation`, `hasSubscription` | consultation offered; the gig can be bought as a subscription |
| `tags` | Fiverr's own facet values for the category |
| `categoryId`, `subCategoryId` | Fiverr's numeric category ids |
| `isPromoted`, `isFiverrChoice`, `isFeatured` | paid slot, Fiverr's Choice badge, featured |
| `searchLabel`, `searchUrl`, `page`, `position`, `scrapedAt` | where the row came from |

A real row, from a run on 20 September:

```json
{
  "gigId": "156202007",
  "title": "create a professional minimalist logo design",
  "gigUrl": "https://www.fiverr.com/kairachel451/create-a-professional-logo-design",
  "gigImage": "https://fiverr-res.cloudinary.com/t_main1,q_auto,f_auto/gigs/156202007/original/6986058e637c412b45483f0f5f51f2b57e2de93c.jpg",
  "sellerName": "kairachel451",
  "sellerDisplayName": "Rachel",
  "sellerUrl": "https://www.fiverr.com/kairachel451",
  "sellerLevel": "top_rated_seller",
  "sellerCountry": "PK",
  "sellerIsPro": false,
  "sellerLanguages": ["en"],
  "sellerRating": 4.93,
  "sellerRatingCount": 14304,
  "rating": 4.9,
  "reviewsCount": 14182,
  "startingPrice": 25,
  "currency": "USD",
  "startingPriceUsd": 25,
  "deliveryDays": 3,
  "packagesCount": 3,
  "tags": ["3d", "monogram", "wordmark", "pictorial", "ai", "jpg", "pdf", "png", "psd", "eps", "svg"],
  "categoryId": 3,
  "subCategoryId": 49,
  "isPromoted": false,
  "page": 1,
  "position": 8
}
```

Note the title and the URL slug disagree. Sellers rename gigs and Fiverr keeps the original slug, so
read `title` for what the gig is called today and `gigUrl` for where it lives.

### Input

Give it keywords, or paste listing addresses, or both.

```json
{
  "searchQueries": ["logo design", "wordpress developer"],
  "startUrls": [
    { "url": "https://www.fiverr.com/categories/graphics-design/creative-logo-design" }
  ],
  "maxItems": 200,
  "maxPagesPerSearch": 5,
  "sellerLevels": ["level_two_seller", "top_rated_seller"],
  "maxStartingPriceUsd": 100,
  "maxDeliveryDays": 3
}
```

`maxItems` is the ceiling on rows returned and therefore the ceiling on what the run can cost.
Duplicates, filtered-out gigs and failed pages are all free, so nothing else can push past it.

The filters (`sellerLevels`, `proOnly`, `minRating`, `minReviews`, `maxStartingPriceUsd`,
`maxDeliveryDays`, `excludePromoted`) are applied to rows after the page is read. A gig dropped by
a filter is not written and not charged. Verified on real runs: asking for top-rated sellers only
returned 19 rows, all of them top rated; asking for a $30 ceiling and 2-day delivery returned rows
topping out at exactly $25 and 2 days.

Leave the proxy settings alone unless you have your own. The run already handles Fiverr's page
limits on its own.

### What it does not do

This is the part worth reading before you buy.

- **Listing pages only.** It does not open individual gig pages, so there is no package comparison
  table, no full gig description, no gig FAQ and no buyer reviews. What you get is what a results
  page carries.
- **No seller profiles.** `sellerRating` and `sellerRatingCount` come off the listing card. It does
  not visit the seller's page for their portfolio, description or full review history.
- **Fiverr stops at page 21.** Page 22 answers 404. That caps one keyword at 1,008 slots, which
  after deduplication is roughly 600 gigs. If you need more than that from one topic, split it into
  narrower keywords or work through category pages.
- **`tags` are Fiverr's category facets, not seller tags.** For logo design you get style, logo type
  and file formats. A different category returns entirely different keys, and about 6% of rows carry
  none at all. That was 853 of 909 rows on one run and 2,020 of 2,155 on another.
- **No sort control, on purpose.** Fiverr ignores `sort_by` on the page it serves to a signed-out
  visitor. Three different sorts were measured returning the same gigs in the same order, so
  offering a sort here would be a button that does nothing. Same for Fiverr's own seller-level and
  Pro parameters. Use this actor's filters instead, which do work.
- **Fiverr never really returns nothing.** A deliberately nonsensical keyword still came back with
  40 gigs, because the search falls back to loose matching. If your keyword is too narrow you get
  approximate results rather than an empty set, and those are real rows and are charged. Use
  specific keywords you would actually type into the site.
- **Prices depend on where the request came from.** Fiverr converts the page into a currency it
  picks from the requesting address, so `startingPrice` may arrive in EUR or ZAR. `startingPriceUsd`
  carries the US-dollar figure using the conversion rate Fiverr itself reported on that page. If you
  only care about one number, use that one.
- **`startingPrice` is the cheapest package.** It is not the average order value, and it is not what
  most buyers of that gig actually pay.
- **Promoted gigs are kept by default.** They are real gigs sitting in paid slots, flagged as
  `isPromoted`. Turn on `excludePromoted` if you only want organic results.
- Anything behind a Fiverr login is out of scope.

### Billing

Pay per gig. One charge per gig actually written to the dataset. The current rate is on the Pricing
tab next to the Input tab.

What is **free**:

- duplicate slots, where Fiverr served the same gig twice
- gigs dropped by your filters
- searches that come back empty or blocked, which write an explanatory row instead
- the sample row you get from an empty input
- a run that fails outright

So the most a run can cost you is `maxItems` gigs plus the run fee, and usually less.

Every failure writes a row saying what happened, with `charged: false` on it, rather than throwing.
A failed run would still bill the run fee, and nobody should pay to be told they left a field empty.

### Reliability, measured

Numbers from real runs on 19–20 September 2026:

- 20 varied keywords in one run (logo design, wordpress developer, seo audit, voice over, unity
  game development and fifteen others) returned **909 distinct gigs with no failed searches**.
- A deep run of 5 keywords × 21 pages returned **2,155 gigs from 104 of 105 pages**. The one page
  that came back without data wrote an uncharged row saying so.
- Price, rating, review count and delivery time were present on **100%** of those rows.

When Fiverr refuses a page, the actor tries
again before giving up. It also catches a specific thing Fiverr does that is easy to miss: answering
HTTP 200 with a short page holding eight slots, all of them advertising, where the same query
reported 187,000 matches a second earlier. That is not an empty result and it is not an error code,
so it is detected by the absence of organic listings and fetched again.

### FAQ

**Do I need a Fiverr account or cookies?**
No. It reads the pages Fiverr serves to a signed-out visitor.

**Can I scrape a whole category?**
Yes. Paste the category address into `startUrls`, for example
`https://www.fiverr.com/categories/graphics-design/creative-logo-design`, and set
`maxPagesPerSearch`. The 21-page ceiling applies to categories as well.

**Why did I get fewer gigs than pages × 48?**
Because about 20 of the 48 slots on each page are advertising, and the same gig often appears in
both an ad slot and an organic one. Those repeats are removed and not charged. Around 30 new gigs
per page is normal.

**How do I get only organic results?**
Set `excludePromoted` to true. Skipped ad slots are not charged.

**Why is `startingPrice` in euros?**
Fiverr localises the page by the requesting address. Read `startingPriceUsd` instead. It is
converted using the rate Fiverr reported on that same page.

**Can I filter by seller level or Pro status?**
Yes, through `sellerLevels` and `proOnly` on this actor. Do not put Fiverr's own filter parameters
into a pasted URL and expect them to work. Fiverr ignores them on this page, which was measured
rather than assumed.

**Can I sort by price or by newest?**
No, and no actor reading this page honestly can. Fiverr ignores the sort parameter here. Pull the
rows and sort them yourself.

**What happens if Fiverr blocks the run?**
You get a row with `errorCode: BLOCKED` explaining it, and you are not charged for that search.
Re-running a few minutes later usually works, since the limit is applied per address.

**Does it get gig descriptions, packages or reviews?**
No. This reads listing pages. Individual gig pages are a different job.

**Can I use my own proxies?**
Yes. Put them in `proxyConfiguration.proxyUrls` under Advanced and they are used exactly as given.

# Actor input Schema

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

What you would type into Fiverr's search box. One row per keyword. Each keyword is searched separately and the results are pooled.

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

Paste the address bar of any Fiverr listing page — a search like https://www.fiverr.com/search/gigs?query=voice%20over or a category like https://www.fiverr.com/categories/graphics-design/creative-logo-design. Any extra parameters in the address are passed back to Fiverr untouched, but be aware Fiverr ignores its own sort and filter parameters on the page it serves to a signed-out visitor — use the filters below instead. Through the API this field takes objects: \[{"url": "https://..."}].

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

Hard stop on how many gigs the run returns and charges for. Duplicates, filtered-out gigs and failed pages are never charged, so this is also the most you can spend.

## `maxPagesPerSearch` (type: `integer`):

Fiverr serves 48 slots per page and stops at page 21. Around 20 of those 48 slots are advertising, and the same gig often appears in both an ad slot and an organic one, so expect roughly 30 new gigs per page rather than 48.

## `excludePromoted` (type: `boolean`):

Fiverr marks paid placements as promoted. Leave this off to get everything the page shows; turn it on to keep only organic results. Skipped gigs are not charged.

## `proOnly` (type: `boolean`):

Keep only gigs from sellers Fiverr has vetted as Pro. This is a small pool — on one category page 282 of 229,525 gigs were Pro.

## `sellerLevels` (type: `array`):

Keep only these seller levels. Leave empty for all of them.

## `minRating` (type: `integer`):

Drop gigs rated below this, and gigs with no rating at all. Fiverr scores out of 5 and its scores are decimals, so 4 keeps everything from 4.0 up, and 5 keeps only gigs sitting at a flat 5.0.

## `minReviews` (type: `integer`):

Drop gigs with fewer reviews than this. Useful for skipping brand-new listings.

## `maxStartingPriceUsd` (type: `integer`):

Drop gigs whose cheapest package costs more than this, in US dollars.

## `maxDeliveryDays` (type: `integer`):

Drop gigs whose cheapest package takes longer than this to deliver.

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

Optional. Leave this alone unless you need the run to go out through a particular network. Your own proxy servers are used exactly as given.

## Actor input object example

```json
{
  "searchQueries": [
    "logo design",
    "wordpress developer"
  ],
  "startUrls": [],
  "maxItems": 50,
  "maxPagesPerSearch": 3,
  "sellerLevels": [],
  "minRating": 4,
  "minReviews": 10,
  "maxStartingPriceUsd": 100,
  "maxDeliveryDays": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One row per gig: title, gig URL and image, seller username, display name, level, country and Pro flag, the gig's star rating and review count, the seller's own rating and review count, starting price in the page currency and in US dollars, delivery days, package count, Fiverr's own facet tags, and whether the slot was an advertisement. An empty input writes a single uncharged sample row instead; blocked or empty searches write uncharged diagnostic rows.

# 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"
    ],
    "startUrls": [],
    "maxItems": 50,
    "maxPagesPerSearch": 3,
    "excludePromoted": false,
    "proOnly": false,
    "sellerLevels": [],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("dami_studio/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"],
    "startUrls": [],
    "maxItems": 50,
    "maxPagesPerSearch": 3,
    "excludePromoted": False,
    "proOnly": False,
    "sellerLevels": [],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("dami_studio/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"
  ],
  "startUrls": [],
  "maxItems": 50,
  "maxPagesPerSearch": 3,
  "excludePromoted": false,
  "proOnly": false,
  "sellerLevels": [],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call dami_studio/fiverr-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dami_studio/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/AqwHEkzK6MpM248OV/builds/96GtCib2L3rCfdz0u/openapi.json