# Fiverr Scraper — Gigs, Sellers & Prices API (`logiover/fiverr-scraper`) Actor

Scrape Fiverr gigs by search, category or seller — no API key, no login. Extract titles, prices, packages, delivery times, ratings, reviews, seller level, country and badges. Export freelance-marketplace data to JSON, CSV or Excel for market research and lead generation.

- **URL**: https://apify.com/logiover/fiverr-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Lead generation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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.
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

## Fiverr Scraper — Gigs, Sellers, Prices, Packages & Reviews

Extract structured data from the **Fiverr** freelance marketplace at scale — no API key, no login, no cookies. Search gigs by keyword, browse any category, pull a seller's full profile and portfolio, or dig into a single gig's three-tier packages, FAQ, tags and reviews. Every row is clean, flat and export-ready (JSON, CSV, Excel, Google Sheets).

Fiverr has no public marketplace API — the seller API only lets *you* manage *your own* gigs. This Actor closes that gap. It reads the exact same server-rendered data that fiverr.com hands your browser, so you get real prices, real ratings and real delivery times for thousands of gigs in a single run.

### What does Fiverr Scraper do?

The Actor talks to Fiverr over plain HTTP using **`got-scraping`** (a real Chrome TLS + browser-header fingerprint) routed through **Apify Residential proxies**, rotating a fresh residential IP on every retry with polite delays. Because Fiverr is PerimeterX/Cloudflare-protected, this stealth transport — not a datacenter IP — is what keeps requests flowing.

Every Fiverr page (search, category, seller, gig) server-side-renders a large JSON blob into a `<script id="perseus-initial-props">` tag. The Actor fetches the HTML, extracts that blob, parses it, and reads the gig and seller objects straight out of it — no headless browser, no brittle CSS selectors, no wasted compute. Search and category listings paginate ~48 gigs per page, so hitting **hundreds to thousands of rows** per run is routine. Results stream to your dataset with numeric fields as real numbers, booleans as booleans, and a `_mode` tag on every row.

### Who is it for?

- **Freelancers & agencies** benchmarking their gigs against competitors — pricing, packaging, delivery times and positioning.
- **Market researchers & analysts** sizing niches, tracking price distributions and spotting demand trends across categories.
- **Lead-generation teams** building lists of vetted sellers (Pro, Top Rated) by skill, country and rating for outreach or recruiting.
- **Dropshippers, resellers & studios** sourcing services (design, dev, voice-over, video) and comparing hundreds of providers fast.
- **Data scientists & founders** feeding a gig-economy dataset into pricing models, dashboards, or an AI agent.

### Use cases

- **Competitor pricing audit** — scrape the top 500 "logo design" gigs, compare `priceFrom`, package tiers and delivery days, and price your own service to win.
- **Niche opportunity scan** — pull `best_selling` gigs in a subcategory and see which services have high demand but thin supply.
- **Seller lead list** — collect Top Rated / Pro sellers in "wordpress" with rating ≥ 4.9 and their response time, country and languages for recruiting.
- **Review & reputation mining** — extract review counts, ratings and buying-review breakdowns per gig for reputation analysis.
- **Trend dashboards** — schedule a daily run and chart how prices, ratings and Fiverr's Choice badges shift over time.

### Why use Fiverr Scraper?

- **Keyless** — no Fiverr account, no API key, no cookies. Just set a keyword and run.
- **60+ fields** — from prices and packages to seller level, country, languages, badges, gig metadata (logo style, file formats), review breakdowns and more.
- **Bulk & paginated** — thousands of gigs per run via real pagination; batch gig-detail lookups from a list of URLs.
- **Every filter is a dropdown** — sort, seller level, price bucket, delivery time and Pro-only are pick-lists, so you never mistype a value.
- **Clean, typed output** — numbers as numbers, booleans as booleans, flat rows ready for CSV/Excel/BI — plus four ready-made dataset views.
- **Export anywhere** — JSON, CSV, Excel, HTML, or push straight to Google Sheets, Slack, Zapier, Make and webhooks. Pay only for results you keep.

### What data can you extract?

In **search** and **category** modes each row is a gig card. In **gigDetail** mode you get a deep object with all package tiers, description, FAQ, tags and gallery. In **seller** mode you get one profile row plus every public gig. Here are the main fields:

| Field | Type | Description |
|---|---|---|
| `gigId` | number | Fiverr's numeric gig ID |
| `title` | string | Gig title |
| `url` | string | Absolute gig URL |
| `sellerName` | string | Seller username |
| `sellerDisplayName` | string | Seller display name |
| `sellerLevel` | string | New Seller / Level 1 / Level 2 / Top Rated Seller |
| `isPro` | boolean | Vetted Fiverr Pro seller |
| `isOnline` | boolean | Seller currently online |
| `sellerCountry` | string | ISO country code of the seller |
| `sellerImage` | string | Seller avatar URL |
| `rating` | number | Seller rating score (0–5) |
| `reviewsCount` | number | Seller review count |
| `buyingReviewRating` | number | Gig-level buying review rating |
| `buyingReviewsCount` | number | Gig-level review count |
| `priceFrom` | number | Starting price in USD |
| `currency` | string | Currency code (USD) |
| `recommendedPackage` | object | `{ price, deliveryDays, tier, extraFast }` |
| `packages` | array | (gigDetail) All tiers: `{ tier, price, deliveryDays, revisions, features, description }` |
| `numOfPackages` | number | How many package tiers the gig offers |
| `category` / `subcategory` | number/string | Category & subcategory (IDs on cards, names on detail) |
| `badges` | array | e.g. `Pro`, `Fiverr's Choice`, `Featured` |
| `isFiverrChoice` | boolean | Carries the Fiverr's Choice badge |
| `isFeatured` | boolean | Featured/promoted gig |
| `hasRecurringOption` | boolean | Offers subscription/recurring orders |
| `recurringDiscountPct` | number | Discount % on recurring orders |
| `imageUrl` / `images` | string/array | Gig thumbnail(s) |
| `portfolioImages` | array | Delivered-work portfolio previews |
| `hasVideo` | boolean | Gig has a video asset |
| `gigMetadata` | object | Service attributes, e.g. `{ style, logo_type, file_format }` |
| `sellerLanguages` | array | `{ code, level }` per language |
| `tags` | array | (gigDetail) Gig tags |
| `faq` | array | (gigDetail) `{ question, answer }` |
| `description` | string | (gigDetail) Gig description text |
| `ordersInQueue` | number | (gigDetail) Orders currently in queue |
| `gallery` | array | (gigDetail) Gallery image/video URLs |
| `memberSince` | string | (seller) Join date `YYYY-MM-DD` |
| `responseTimeHours` | number | (seller) Avg response time in hours |
| `completedOrdersCount` | number | (seller) Completed orders |
| `approvedGigsCount` | number | (seller) Active gigs |
| `hourlyRate` | number | (seller) Hourly rate if offered |
| `skills` / `certifications` / `educations` | array | (seller) Structured profile data |
| `scrapedAt` | string | ISO timestamp of extraction |
| `_mode` | string | Which mode produced the row |

#### Real output example (search mode)

```json
{
  "_mode": "search",
  "gigId": 278023626,
  "title": "design a modern business logo",
  "url": "https://www.fiverr.com/martinkokes/design-a-modern-worldclass-logo",
  "sellerName": "martinkokes",
  "sellerDisplayName": "Martin Kokes",
  "sellerLevel": "Top Rated Seller",
  "isPro": true,
  "isOnline": false,
  "sellerCountry": "CZ",
  "rating": 4.9,
  "reviewsCount": 148,
  "buyingReviewRating": 4.9,
  "buyingReviewsCount": 139,
  "priceFrom": 290,
  "currency": "USD",
  "recommendedPackage": { "price": 290, "deliveryDays": 7, "tier": "cheapest", "extraFast": false },
  "numOfPackages": 3,
  "badges": ["Pro"],
  "isFiverrChoice": false,
  "hasRecurringOption": true,
  "recurringDiscountPct": 15,
  "imageUrl": "https://fiverr-res.cloudinary.com/.../original/fa75966b...png",
  "gigMetadata": { "style": ["modern"], "logo_type": ["monogram", "wordmark", "abstract"], "file_format": ["ai", "jpg", "pdf", "png", "eps", "svg"] },
  "sellerLanguages": [{ "code": "en", "level": "Fluent" }, { "code": "cs", "level": "Native/Bilingual" }],
  "scrapedAt": "2026-07-23T10:40:00.000Z"
}
````

### How to use

#### Option A — Search gigs by keyword (highest volume)

1. Set **Mode** to `search`.
2. Type a **Search query** (e.g. `logo design`, `wordpress`, `voice over`).
3. Optionally pick **Sort**, **Seller level**, **Price range**, **Delivery time** or **Fiverr Pro only**.
4. Set **Max results** (e.g. `600`) and click **Start**.

```json
{ "mode": "search", "query": "logo design", "sort": "best_selling", "maxResults": 600 }
```

#### Option B — Scrape a category, a seller, or a specific gig

- **Category:** set **Mode** to `category` and provide a `category` slug (`graphics-design`) with an optional `subcategory` (`creative-logo-design`), or paste a full **Category URL**.
- **Seller:** set **Mode** to `seller` and enter a `seller` username or profile URL — you get profile stats + every public gig.
- **Gig details:** set **Mode** to `gigDetail` and paste one **Gig URL** or a batch in **Gig URLs**.

```json
{ "mode": "gigDetail", "gigUrls": ["https://www.fiverr.com/martinkokes/design-a-modern-worldclass-logo"] }
```

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | string (enum) | `search` | `search`, `category`, `seller`, or `gigDetail` |
| `query` | string | `logo design` | Keyword for search mode |
| `category` | string | — | Category slug (category mode) |
| `subcategory` | string | — | Subcategory slug (optional) |
| `categoryUrl` | string | — | Full Fiverr category/search URL (overrides slugs) |
| `seller` | string | — | Seller username or profile URL (seller mode) |
| `gigUrl` | string | — | Single gig URL (gigDetail mode) |
| `gigUrls` | array | `[]` | Batch of gig URLs (gigDetail mode) |
| `sort` | string (enum) | `relevance` | `relevance`, `best_selling`, `newest`, `rating` |
| `sellerLevel` | string (enum) | — | `new_seller`, `level_one`, `level_two`, `top_rated_seller`, `pro` |
| `priceBucket` | string (enum) | — | `under_50`, `50_100`, `100_500`, `500_1000`, `over_1000` |
| `deliveryTime` | string (enum) | — | `24h`, `3days`, `7days` |
| `proOnly` | boolean | `false` | Fiverr Pro gigs only |
| `maxResults` | integer | `200` | Upper bound on rows |
| `proxyConfiguration` | object | Residential | Proxy settings (Residential recommended) |

Full input JSON:

```json
{
  "mode": "search",
  "query": "logo design",
  "sort": "best_selling",
  "sellerLevel": "top_rated_seller",
  "priceBucket": "100_500",
  "deliveryTime": "3days",
  "proOnly": false,
  "maxResults": 600,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

### Output example (gigDetail mode, abbreviated)

```json
{
  "_mode": "gigDetail",
  "gigId": 278023626,
  "title": "design a modern business logo",
  "category": "Graphics & Design",
  "subcategory": "Logo Design",
  "priceFrom": 290,
  "numOfPackages": 3,
  "rating": 4.9,
  "reviewsCount": 139,
  "ordersInQueue": 2,
  "packages": [
    { "tier": "Basic Package", "price": 290, "deliveryDays": 7, "revisions": 2, "features": ["Number of concepts included", "Logo transparency", "Vector file"] }
  ],
  "tags": ["logo creation", "modern logo design"],
  "faq": [{ "question": "Can I have special requests?", "answer": "Of course! ..." }],
  "sellerName": "martinkokes",
  "sellerLevel": "Top Rated Seller",
  "sellerRating": 4.9,
  "sellerCountry": "CZ"
}
```

### Tips for best results

- **Start broad, then filter.** Run a plain keyword first to see the field shape, then add `sellerLevel`, `priceBucket` or `deliveryTime` to narrow.
- **Fiverr caps deep pagination** at roughly 20 pages (~1000 gigs) per query. For more coverage, split by subcategory or by several related keywords.
- **Use `best_selling` or `rating` sort** for lead lists — you'll surface the strongest sellers first.
- **`priceFrom` on cards is in dollars**; gig-detail package prices are normalised from cents automatically. Numbers are always real numbers.
- **Residential proxy is on by default** — keep it. Datacenter/local IPs get challenged by PerimeterX and return zero rows.
- **Keep `maxResults` sensible.** 500–1000 is plenty for most analyses and finishes well inside the time budget.
- **Batch gig details** by pasting many gig URLs from a prior search run into `gigUrls` — great for a two-step pipeline (search → detail).
- **Seller pages** occasionally rotate a bad IP; the Actor retries with a fresh IP automatically. If a specific username returns nothing, it may be inactive or on vacation.
- **Schedule daily/weekly** to build a time series of prices and ratings.
- **De-duplicate on `gigId`** if you merge multiple runs.

### Integrations

Connect Fiverr Scraper to your stack with Apify's built-in integrations:

- **Google Sheets** — append every run's gigs to a sheet.
- **Slack / email** — get notified when a run finishes.
- **Zapier & Make** — trigger 6000+ downstream apps.
- **Webhooks** — POST results to your own API on completion.
- **Schedule** — run hourly/daily/weekly with no code.
- **Airbyte / any BI tool** — pull the dataset via the Apify API.

### API usage

Run the Actor and fetch results programmatically. Get your token from **Settings → Integrations** in the Apify Console.

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/logiover~fiverr-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "mode": "search", "query": "logo design", "maxResults": 600 }'
```

**Node.js**

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('logiover/fiverr-scraper').call({
  mode: 'search',
  query: 'wordpress',
  sort: 'best_selling',
  maxResults: 500,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")

run = client.actor("logiover/fiverr-scraper").call(run_input={
    "mode": "seller",
    "seller": "martinkokes",
    "maxResults": 200,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

### Use with AI agents (MCP)

Fiverr Scraper works as a tool for LLM agents through the **Apify MCP server**. Point your agent (Claude, ChatGPT, LangChain, CrewAI…) at the Apify MCP endpoint and it can call this Actor on demand.

> Example prompt: *"Use the Fiverr scraper to find the 50 best-selling 'explainer video' gigs under $200 with Top Rated sellers, and give me a table of title, price, delivery days and rating."*

### FAQ

#### Do I need a Fiverr account or API key?

No. The Actor is fully keyless — it reads the same public data Fiverr renders to any visitor. You never log in or supply cookies.

#### How many gigs can I get per run?

Search and category modes paginate ~48 gigs per page up to Fiverr's practical limit of ~20 pages (about 1000 gigs) per query. Split by subcategory or multiple keywords for broader coverage. A single run easily returns hundreds to a thousand rows.

#### Does an empty input work?

Yes. With no fields set, the Actor searches the broad, always-populated query `logo design`, bounded by `maxResults`. You'll get data immediately.

#### Why does it use Residential proxies?

Fiverr is protected by PerimeterX/Cloudflare, which challenge datacenter and local IPs. Residential proxies plus a real browser fingerprint let the Actor fetch pages reliably. This is the default and strongly recommended.

#### Are prices in dollars or cents?

The Actor normalises everything to whole-currency units. Search-card `priceFrom` is already in dollars; gig-detail package prices (stored by Fiverr in cents) are converted to dollars, and durations (stored in hours) to days. All are real numbers.

#### Can I get all three package tiers (Basic/Standard/Premium)?

Yes — use `gigDetail` mode with the gig URL. Search cards only expose the recommended (cheapest) package; the detail page returns the full `packages` array with features, revisions and delivery days per tier.

#### Can I scrape a specific seller's gigs?

Yes. Use `seller` mode with a username or profile URL. You'll get one profile row (level, rating, response time, country, languages, skills, member-since) plus every public gig.

#### Are there null fields?

Fiverr doesn't populate every attribute for every gig (e.g. video, recurring options, some metadata). Missing values are returned as `null` rather than omitted, so your schema stays consistent.

#### What export formats are supported?

JSON, CSV, Excel, HTML and RSS via the Apify API or Console, plus direct pushes to Google Sheets, Slack, Zapier, Make and webhooks.

#### How fast is it?

A 500–1000 gig search typically finishes in a couple of minutes. The Actor uses polite delays and a ~4-minute time budget, pushing everything collected before exiting successfully.

#### How often is the data updated?

It's scraped live at run time — you always get Fiverr's current prices, ratings and availability. Schedule the Actor to build a historical series.

#### The run returned fewer rows than maxResults — why?

Either the query has fewer matches than requested, Fiverr's pagination cap was reached, or a filter was very restrictive. Broaden the keyword, drop a filter, or split across subcategories.

### Is it legal?

This Actor collects only **publicly available** information that Fiverr serves to any visitor — no login, no private data, no personal data beyond what sellers publish on their public profiles. Scraping public web data is broadly lawful, but you are responsible for how you use it: review Fiverr's Terms of Service and applicable laws (including data-protection rules like GDPR/CCPA) before scraping at scale, and use the data ethically — for research, analytics and lead generation, not spam or harassment. This tool is not affiliated with or endorsed by Fiverr.

### Related scrapers

- **Upwork / freelance marketplace scrapers** — compare gig-economy platforms side by side.
- **LinkedIn / company scrapers** (by logiover) — enrich seller leads with company data.
- **Google / Bing SERP scrapers** — find where gigs and sellers rank in search.
- **Website Content & Contact scrapers** (by logiover) — turn seller profiles into outreach-ready leads.

# Actor input Schema

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

Which Fiverr endpoint to scrape.

• **search** — search gigs by keyword and paginate (~48 gigs/page → thousands). Highest volume.
• **category** — list gigs under a Fiverr category / subcategory slug, or a pasted category URL.
• **seller** — full profile + all public gigs of one seller username.
• **gigDetail** — deep detail for one or more gig URLs: 3-tier packages, description, FAQ, tags, gallery and seller stats.

## `query` (type: `string`):

Keyword for **search** mode — a service, skill or niche (e.g. `logo design`, `wordpress`, `voice over`, `video editing`). Fiverr caps a single query at ~380 gigs; for more, add several terms in **Search queries** below. Empty input browses popular services.

## `queries` (type: `array`):

Optional list of keywords to scrape in one run (results de-duplicated by gig ID). A single Fiverr query tops out around ~380 gigs, so use several complementary terms to collect thousands. Overrides/extends the single query above.

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

Fiverr category slug for **category** mode, e.g. `graphics-design`, `programming-tech`, `digital-marketing`, `writing-translation`, `video-animation`, `music-audio`, `business`, `data`, `ai-services`. Taken from a Fiverr category URL: fiverr.com/categories/**graphics-design**.

## `subcategory` (type: `string`):

Optional subcategory slug under the category, e.g. `creative-logo-design`, `website-development`, `social-media-marketing`. From fiverr.com/categories/graphics-design/**creative-logo-design**.

## `categoryUrl` (type: `string`):

Alternatively, paste a full Fiverr category or search URL and the scraper will paginate it directly. Overrides the category/subcategory slugs above.

## `seller` (type: `string`):

For **seller** mode — a Fiverr username (e.g. `martinkokes`) or a full profile URL (`https://www.fiverr.com/martinkokes`). Returns the seller's profile stats plus every public gig.

## `gigUrl` (type: `string`):

A single Fiverr gig URL for **gigDetail** mode, e.g. `https://www.fiverr.com/username/gig-slug`. For many gigs at once, use the batch field below.

## `gigUrls` (type: `array`):

Array of Fiverr gig URLs for batch **gigDetail** lookups. Paste gig links (one per line).

## `sort` (type: `string`):

Result ordering for search / category modes.

## `sellerLevel` (type: `string`):

Only include gigs from sellers of this level (search / category).

## `priceBucket` (type: `string`):

Filter gigs by starting price bucket (search / category).

## `deliveryTime` (type: `string`):

Only gigs that deliver within this timeframe (search / category).

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

When enabled, restrict search / category results to vetted Fiverr Pro gigs.

## `maxResults` (type: `integer`):

Upper bound on rows returned. For search / category this drives pagination (~48 per page). For seller it caps the seller's gig list. Default 200.

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

Fiverr is bot-protected, so the scraper uses Apify **Residential** proxies by default (strongly recommended — leave as is). You may override the proxy group here if you know what you're doing.

## Actor input object example

```json
{
  "mode": "search",
  "query": "logo design",
  "queries": [
    "logo design",
    "website design",
    "wordpress"
  ],
  "category": "graphics-design",
  "subcategory": "creative-logo-design",
  "categoryUrl": "https://www.fiverr.com/categories/graphics-design/creative-logo-design",
  "seller": "martinkokes",
  "gigUrl": "https://www.fiverr.com/martinkokes/design-a-modern-worldclass-logo",
  "gigUrls": [],
  "sort": "relevance",
  "proOnly": false,
  "maxResults": 200,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Full results dataset. Use the Gigs view for search/category, Gig details for gigDetail mode, and Sellers for seller profiles.

# 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",
    "query": "logo design",
    "queries": [
        "logo design",
        "website design",
        "wordpress"
    ],
    "sort": "relevance",
    "maxResults": 200,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/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 = {
    "mode": "search",
    "query": "logo design",
    "queries": [
        "logo design",
        "website design",
        "wordpress",
    ],
    "sort": "relevance",
    "maxResults": 200,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/fiverr-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",
  "query": "logo design",
  "queries": [
    "logo design",
    "website design",
    "wordpress"
  ],
  "sort": "relevance",
  "maxResults": 200,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call logiover/fiverr-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Fiverr Scraper — Gigs, Sellers & Prices API",
        "description": "Scrape Fiverr gigs by search, category or seller — no API key, no login. Extract titles, prices, packages, delivery times, ratings, reviews, seller level, country and badges. Export freelance-marketplace data to JSON, CSV or Excel for market research and lead generation.",
        "version": "1.0",
        "x-build-id": "m5uUjxZ7KO8AFLPcu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~fiverr-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-fiverr-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/logiover~fiverr-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-fiverr-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/logiover~fiverr-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-fiverr-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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "category",
                            "seller",
                            "gigDetail"
                        ],
                        "type": "string",
                        "description": "Which Fiverr endpoint to scrape.\n\n• **search** — search gigs by keyword and paginate (~48 gigs/page → thousands). Highest volume.\n• **category** — list gigs under a Fiverr category / subcategory slug, or a pasted category URL.\n• **seller** — full profile + all public gigs of one seller username.\n• **gigDetail** — deep detail for one or more gig URLs: 3-tier packages, description, FAQ, tags, gallery and seller stats.",
                        "default": "search"
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Keyword for **search** mode — a service, skill or niche (e.g. `logo design`, `wordpress`, `voice over`, `video editing`). Fiverr caps a single query at ~380 gigs; for more, add several terms in **Search queries** below. Empty input browses popular services."
                    },
                    "queries": {
                        "title": "Search queries (multi, high volume)",
                        "type": "array",
                        "description": "Optional list of keywords to scrape in one run (results de-duplicated by gig ID). A single Fiverr query tops out around ~380 gigs, so use several complementary terms to collect thousands. Overrides/extends the single query above.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "category": {
                        "title": "Category slug",
                        "type": "string",
                        "description": "Fiverr category slug for **category** mode, e.g. `graphics-design`, `programming-tech`, `digital-marketing`, `writing-translation`, `video-animation`, `music-audio`, `business`, `data`, `ai-services`. Taken from a Fiverr category URL: fiverr.com/categories/**graphics-design**."
                    },
                    "subcategory": {
                        "title": "Subcategory slug (optional)",
                        "type": "string",
                        "description": "Optional subcategory slug under the category, e.g. `creative-logo-design`, `website-development`, `social-media-marketing`. From fiverr.com/categories/graphics-design/**creative-logo-design**."
                    },
                    "categoryUrl": {
                        "title": "Category URL (optional)",
                        "type": "string",
                        "description": "Alternatively, paste a full Fiverr category or search URL and the scraper will paginate it directly. Overrides the category/subcategory slugs above."
                    },
                    "seller": {
                        "title": "Seller username or profile URL",
                        "type": "string",
                        "description": "For **seller** mode — a Fiverr username (e.g. `martinkokes`) or a full profile URL (`https://www.fiverr.com/martinkokes`). Returns the seller's profile stats plus every public gig."
                    },
                    "gigUrl": {
                        "title": "Gig URL",
                        "type": "string",
                        "description": "A single Fiverr gig URL for **gigDetail** mode, e.g. `https://www.fiverr.com/username/gig-slug`. For many gigs at once, use the batch field below."
                    },
                    "gigUrls": {
                        "title": "Gig URLs (batch)",
                        "type": "array",
                        "description": "Array of Fiverr gig URLs for batch **gigDetail** lookups. Paste gig links (one per line).",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "sort": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "best_selling",
                            "newest",
                            "rating"
                        ],
                        "type": "string",
                        "description": "Result ordering for search / category modes.",
                        "default": "relevance"
                    },
                    "sellerLevel": {
                        "title": "Seller level",
                        "enum": [
                            "new_seller",
                            "level_one",
                            "level_two",
                            "top_rated_seller",
                            "pro"
                        ],
                        "type": "string",
                        "description": "Only include gigs from sellers of this level (search / category)."
                    },
                    "priceBucket": {
                        "title": "Price range (USD)",
                        "enum": [
                            "under_50",
                            "50_100",
                            "100_500",
                            "500_1000",
                            "over_1000"
                        ],
                        "type": "string",
                        "description": "Filter gigs by starting price bucket (search / category)."
                    },
                    "deliveryTime": {
                        "title": "Delivery time",
                        "enum": [
                            "24h",
                            "3days",
                            "7days"
                        ],
                        "type": "string",
                        "description": "Only gigs that deliver within this timeframe (search / category)."
                    },
                    "proOnly": {
                        "title": "Fiverr Pro only",
                        "type": "boolean",
                        "description": "When enabled, restrict search / category results to vetted Fiverr Pro gigs.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Upper bound on rows returned. For search / category this drives pagination (~48 per page). For seller it caps the seller's gig list. Default 200.",
                        "default": 200
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Fiverr is bot-protected, so the scraper uses Apify **Residential** proxies by default (strongly recommended — leave as is). You may override the proxy group here if you know what you're doing.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```