# Dribbble Jobs Scraper (`parseforge/dribbble-jobs-scraper`) Actor

Hunt down active job listings from Dribbble Jobs with title, company, location, remote flag, posted date, salary when published and the direct apply link. Trusted by recruiters, agencies, aggregator sites and job hunters. Run on demand or on a recurring schedule and feed every row into your favou.

- **URL**: https://apify.com/parseforge/dribbble-jobs-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Jobs, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🎨 Dribbble Jobs Scraper

> 🚀 **Pull dribbble jobs records in seconds.** Structured data from Dribbble with clean fields ready for analysis.

> 🕒 **Last updated** 2026-05-27 · **📊 8 fields** per record · **Production-grade** · **Public data only**

Design and creative job listings from Dribbble with company, location and employment type. Built for analysts, researchers and product teams who need clean, structured records without writing custom scrapers.

This actor walks the public surface of Dribbble, follows pagination, and pushes one record per item to the Apify dataset. Records ship with stable field names, ISO timestamps, and predictable shapes for downstream analytics.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Analysts and researchers | Building reference datasets |
| Product teams | Competitive intelligence |
| Data engineers | Pipeline ingestion |
| Operations teams | Market and inventory tracking |

### 📋 What the Dribbble Jobs Scraper does

- Walks public Dribbble surfaces and follows pagination
- Pushes one clean record per item with stable field names
- Adds an ISO timestamp on every record
- Surfaces errors as records rather than failing the whole run
- Auto-limits free runs to 10 records (preview), paid runs up to 1,000,000

> 💡 **Why it matters** Structured records are easier to wire into dashboards, warehouses and notebooks than raw scraped pages.

### 🎬 Full Demo

🚧 Coming soon.

### ⚙️ Input

The actor accepts a small input object. Set `maxItems` to control run scale; provide source-specific filters where supported.

````

{
"maxItems": 10
}

```
```

{
"maxItems": 100
}

```

> ⚠️ **Good to Know** Only publicly accessible records are collected. Free users are limited to 10 records per run; upgrade to paid for up to 1,000,000.

### 📊 Output

Each record contains the following fields.

| Field | Description |
|---|---|
| 📌 Title `title` | Per-record field |
| Company `company` | Per-record field |
| Location `location` | Per-record field |
| EmploymentType `employmentType` | Per-record field |
| PostedAt `postedAt` | Per-record field |
| 🔗 Source `sourceUrl` | Per-record field |
| 🕒 `scrapedAt` | ISO 8601 collection timestamp |
| ❌ `error` | Error message if the record failed |

Sample record

```

{
"title": "sample",
"company": "sample",
"location": "sample",
"employmentType": "sample",
"postedAt": "sample",
"sourceUrl": "https://...",
"scrapedAt": "2026-05-27T12:00:00.000Z",
"error": null
}

````

### ✨ Why choose this Actor

| ✅ Feature | Why it matters |
|---|---|
| 🧱 Stable shapes | Predictable fields across runs |
| 🕒 ISO timestamps | Trivial to bucket by day or hour |
| 🛡️ Error-as-record | One bad row does not kill the run |
| ⚙️ Apify-native | Works with the full Apify integration stack |
| 🔓 Public data only | No accounts or logins required |

### 📈 How it compares to alternatives

| Approach | Setup time | Maintenance | Reliability |
|---|---|---|---|
| Hand-rolled scraper | Days | High | Variable |
| Generic web tool | Hours | Medium | Medium |
| This actor | Minutes | Low | High |

### 🚀 How to use

1. [Create a free Apify account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. Open the actor page
3. Set `maxItems` and any supported filters
4. Click **Start**
5. Open the dataset tab to view records

### 💼 Business use cases

#### Market intelligence
Track changes in the Dribbble surface over time to spot trends and opportunities.

#### Lead and partner discovery
Build a reference set of entities, vendors or contributors for outreach.

#### Competitive analysis
Compare offerings, tags and metadata across the catalog.

#### Pipeline ingestion
Feed clean records into BigQuery, Snowflake, Postgres or any warehouse via Apify integrations.

### 🔌 Automating Dribbble Jobs Scraper

- **Make** trigger runs on a schedule and route records to Sheets, Airtable, Notion
- **Zapier** chain runs with CRMs and messaging tools
- **Slack** post run summaries to channels
- **Airbyte** pipe records into your warehouse
- **GitHub Actions** schedule runs from your repo
- **Google Drive** archive records to Sheets or Drive folders

### 🌟 Beyond business use cases

#### Research
Track public-data catalogs for academic projects and reproducible studies.

#### Personal projects
Build personal dashboards over your favorite data sources.

#### Non-profit
Help mission-driven teams keep up with sector data without engineering overhead.

#### Experimentation
Prototype ML features and embeddings over a clean, structured corpus.

### 🤖 Ask an AI assistant about this scraper

- **ChatGPT** "How should I structure a weekly run of the Dribbble Jobs actor and ingest the results into BigQuery?"
- **Claude** "Draft a Make scenario that runs the Dribbble Jobs actor and posts new records to Slack."
- **Perplexity** "Compare the Dribbble Jobs actor with manual scraping approaches."
- **Copilot** "Show me Python code that reads the latest Apify dataset for this actor."

### ❓ Frequently Asked Questions

#### 🛡️ Is this scraper legal to use?
It collects only publicly available data and respects the source's public surface.

#### 💸 Is there a free tier?
Yes. Free runs are limited to 10 records as a preview. Paid plans unlock up to 1,000,000.

#### ⏱️ How long does a run take?
Most runs finish in minutes. Large jobs scale with `maxItems`.

#### 🧹 Does the actor deduplicate?
The actor emits one record per item from the source. Apify dataset views can be used to deduplicate downstream.

#### 🌍 Does it support regional records?
Where the source exposes regional surfaces, the input schema includes filters for them.

#### 🧠 Can I run this from my own code?
Yes. Trigger runs over the Apify API and read the dataset programmatically.

#### 🔁 Can I schedule it?
Yes. Use Apify schedules or any integration tool listed above.

#### 🧾 What about rate limits?
The actor uses Apify proxies and built-in retry logic to stay within polite limits.

#### 🛠️ Can I customize fields?
Use Apify dataset views and transformations to project the columns you need.

#### 🆘 Where do I get help?
Open the contact form at the bottom of this page.

### 🔌 Integrate with any app

Connect via Apify's native integrations with Make, Zapier, Slack, Airbyte, Google Drive, Google Sheets, GitHub, Webhooks and the Apify API.

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [ParseForge OurAirports Scraper](https://apify.com/parseforge/ourairports-scraper) | Global airport reference dataset |
| [ParseForge Crossref Funders Scraper](https://apify.com/parseforge/crossref-funders-registry-scraper) | Research funder registry |
| [ParseForge OpenAlex Institutions Scraper](https://apify.com/parseforge/openalex-institutions-scraper) | Research institution metadata |

> 💡 **Pro Tip** browse the complete [ParseForge collection](https://apify.com/parseforge) for more public-data actors.

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer** independent tool, not affiliated with Dribbble. Only publicly available data collected.

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "maxItems": 10
}
````

# Actor output Schema

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

Scraped records.

# 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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/dribbble-jobs-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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/dribbble-jobs-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 '{
  "maxItems": 10
}' |
apify call parseforge/dribbble-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Dribbble Jobs Scraper",
        "description": "Hunt down active job listings from Dribbble Jobs with title, company, location, remote flag, posted date, salary when published and the direct apply link. Trusted by recruiters, agencies, aggregator sites and job hunters. Run on demand or on a recurring schedule and feed every row into your favou.",
        "version": "0.1",
        "x-build-id": "ihgAOaOBOT1xnXnvO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~dribbble-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-dribbble-jobs-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/parseforge~dribbble-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-dribbble-jobs-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/parseforge~dribbble-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-dribbble-jobs-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": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```