# DesignCrowd Scraper \[Only $4/1K💰] | Contests | Designers (`ahmed_jasarevic/designcrowd-scraper`) Actor

Scrape DesignCrowd design contests and designer profiles — prize budgets, deadlines, briefs, ratings, rankings and earnings. No browser, flat $0.004 per record.

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

## Pricing

from $3.85 / 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/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

## DesignCrowd Scraper

Scrape **DesignCrowd contest and designer data** — design contests/jobs with prize budgets, deadlines, full briefs and entries, plus designer profiles with ratings, rankings, locations and earnings. No browser: every field is extracted from DesignCrowd's server-rendered HTML on a plain GET, so runs are fast and cheap at a flat **$0.004 per record**.

Covers **266,811 contests/jobs across 7 categories** and **~1.34 M designers** browsable by type and by country/city.

### Main Use Cases

- **Design contest research** — track open and awarded contests, prize amounts and deadlines across logo, web, print and packaging design
- **Freelance designer leads** — build designer databases with location, rating, positive-feedback score, earnings and portfolio for talent sourcing
- **Logo design pricing benchmarks** — historical prize data for logo design contests and other design project types
- **Creative market research** — understand design contest volume, category mix and prize budgets over time
- **Competitor/agency research** — monitor what projects competitors are running and who is winning them

### How It Works

DesignCrowd is an ASP.NET Core MVC app with no embedded JSON state, no search backend and no JSON API — the data is server-rendered HTML. The actor uses a **CheerioCrawler** that parses the listing pages (`/jobs/{open|closed}/<category>/<subtype>/<page>/` and `/designers/<type>/<country>/<page>/`) and detail pages (`/jobs/job/<id>` and `/designer/<id>/<slug>/about`) directly. Detail fetches run in parallel (default concurrency 50), rates are capped with a token bucket (default 1200 req/min), and the actor auto-back-offs on soft rate-limit pages.

### Build Designer Databases Without an Official API

DesignCrowd has no public API for contest or designer data. This actor reads the same public pages a visitor sees and delivers structured JSON: contest records carry `recordType: "contest"` with `prizeBudget`, `deadline`, `brief`, `payments`, `entriesDesigns`, `entriesDesigners` and winner data; designer records carry `recordType: "designer"` with `rank`, `rating`, `positiveFeedbackScore`, `earnings`, `submissions` and portfolio. Sitemaps (`sitemap-contest-ids-1.xml` … `sitemap-designer-id-name-1.xml`) can be passed via `startUrls` for full-dataset enumeration.

### Collect Design Contest Data — Input

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `mode` | string | No | `contests` | `contests` | `designers` | `both` |
| `startUrls` | array | No | *(empty)* | Explicit listing/detail/profile/sitemap URLs; overrides the built-in defaults below |
| `contestStatus` | string | No | `open` | `open` | `closed` | `both` (266,811 total when `closed`) |
| `contestCategories` | array | No | 12 popular pairs | e.g. `corporateidentity/logo`, `webdesign/web`, `printdesign/poster`, `merchandisedesign/tshirt` |
| `designerTypes` | array | No | 10 popular types | e.g. `logo`, `tshirt`, `web`, `flyer` |
| `includeContestDetail` | boolean | No | `true` | Fetch `/jobs/job/<id>` for the full brief, exact deadline and prize breakdown |
| `includeDesignerProfile` | boolean | No | `true` | Fetch each profile for city, feedback score, submissions and portfolio |
| `includeEntries` | boolean | No | `true` | Keep the per-submission `entries[]` array |
| `maxItems` | integer | No | `200` | Hard cap on dataset rows (free users auto-capped at 10) |
| `maxConcurrency` | integer | No | `50` | Parallel requests — the main speed knob |
| `requestsPerMinute` | integer | No | `1200` | Sustained request-rate ceiling (`0` = no throttle) |
| `maxRequestsPerCrawl` | integer | No | auto | Hard cap on HTTP requests (`0` = auto-size to `maxItems`) |
| `proxy` | object | No | off | Standard Apify proxy picker |

### Output — Designer Portfolios and Contest Briefs

One dataset row per record, discriminated by `recordType`.

#### `recordType: "contest"`

`contestId, url, title, category, status, isOpen, prizeBudget, prizeBudgetAmount, prizeCurrency, entriesDesigns, entriesDesigners, deadline, deadlineIso, deadlineRelative, brief, briefSnippet, logoText, styleAttributes[], payments[], guaranteed, featured, bundled, private, winner, entries[], language, postedDate`

#### `recordType: "designer"`

`designerId, name, url, profileUrl, location, country, city, rank, rating (0-5), positiveFeedbackScore, reviews, earnings, earningsAmount, earningsCurrency, submissions, lastOnline, availableForWork, headline, portfolio { categories, items[], totalDesigns }`

> **Note on `reviews`:** DesignCrowd only exposes the aggregate positive-feedback score (a % of satisfied clients), so `reviews` reports that score verbatim and `positiveFeedbackScore` carries the raw number — no invented review counts.

### Example Input

Open logo contests with full briefs:

```json
{ "mode": "contests", "contestStatus": "open", "contestCategories": ["corporateidentity/logo"], "maxItems": 200 }
```

Cheap listing-only sweep (1 request per 20 contests):

```json
{ "mode": "contests", "contestStatus": "closed", "includeContestDetail": false, "maxItems": 1000 }
```

Top designers in two countries:

```json
{ "mode": "designers", "startUrls": ["https://www.designcrowd.com/designers/all/united-states", "https://www.designcrowd.com/designers/logo/india"] }
```

### Example Output — Contest Record

```json
{
  "recordType": "contest",
  "contestId": "4118897",
  "url": "https://www.designcrowd.com/jobs/job/4118897",
  "title": "Independent Mortgage Agent",
  "category": "Logo Design",
  "status": "open",
  "prizeBudget": "C$150",
  "prizeBudgetAmount": 150,
  "prizeCurrency": "CAD",
  "entriesDesigns": 77,
  "entriesDesigners": 40,
  "deadlineIso": "2026-10-02T22:54:26.000Z",
  "deadlineRelative": "6 days left",
  "brief": "A circular logo for a property called Juneberry Hollow.",
  "payments": [{ "place": "1st place", "amount": "US$150" }, { "place": "Total", "amount": "US$150" }],
  "private": false
}
```

### Design Market Research at $0.004 Per Record

**$0.004 per dataset record, flat** — the same price whether a row is a listing card or a fully-enriched contest brief with detail page. No per-detail fee, unlike the closest competitor. Free Apify accounts get a 10-record preview.

Measured throughput: 200 contests with full briefs run in ~21 s at 2 GB / concurrency 60 (~$0.01), or ~7 s at 4 GB / concurrency 100. The bottleneck is the actor's own CPU, not the site.

### Integrations & Automation

- **API** — run and fetch via the Apify REST API, or call it from AI agents through the Apify MCP server
- **Scheduling** — weekly runs keep designer and contest databases current
- **Webhooks** — trigger downstream pipelines when a run finishes
- **Export** — JSON, CSV, Excel, XML, HTML

**Recommended schedule**: weekly for open contest tracking; monthly for closed-contest prize history; quarterly for full designer sweeps.

### Related Actors

- [Designcrowd Scraper](https://apify.com/crawlerbros/designcrowd-scraper) — `crawlerbros/designcrowd-scraper` — the main DesignCrowd competitor; $0.00433/contest list item + $0.005/contest detail
- [99designs Scraper](https://apify.com/ahmed_jasarevic/99designs-scraper) — `ahmed_jasarevic/99designs-scraper` — same author, sibling platform, $0.00289/record

### FAQ

#### Why use this actor instead of the official DesignCrowd API?

DesignCrowd has no public API for contest or designer data. This actor reads the same publicly served pages the website renders, with no browser needed, and at a flat $0.004/record — cheaper than the closest competitor's $0.00433 + $0.005 detail fee.

#### What are alternatives to this actor / to DesignCrowd data?

For contest data: [crawlerbros/designcrowd-scraper](https://apify.com/crawlerbros/designcrowd-scraper) ($0.00433/list item + $0.005/detail). For the sibling crowdsourcing platform: [ahmed_jasarevic/99designs-scraper](https://apify.com/ahmed_jasarevic/99designs-scraper). For designer talent databases, pair DesignCrowd designer records with LinkedIn or Dribbble scrapers for wider coverage.

#### How much do design contests pay?

Contest records include the full prize breakdown — `prizeBudget` (e.g. `C$150`), `prizeBudgetAmount`/`prizeCurrency` normalized (e.g. `150`/`CAD`), and `payments[]` with per-place amounts. Closed-contest history (`contestStatus: "closed"`) gives you actual awarded prize data for benchmarking.

#### How can I find freelance designers by country?

Set `mode: "designers"` and pass designer-listing URLs per country (e.g. `https://www.designcrowd.com/designers/all/united-states`) via `startUrls`, or use `designerTypes` with the default built-in geography lists. Profiles carry `city`, `country`, `rank`, `rating`, `positiveFeedbackScore`, `earnings` and `portfolio`.

#### Why is `brief` null but `private: true`?

The customer marked the contest brief private — it is login-gated on DesignCrowd's side. The actor resolves the correct contest URL and flags the record with `private: true` plus a `briefSnippet` explaining the gate, instead of silently dropping or mis-linking it.

#### What are the known limitations?

Individual contest entries (`entries[]`) only fill when a gallery page (`/<category>/contest/<id>`) is passed explicitly via `startUrls` — the default flow parses `entriesDesigns`/`entriesDesigners`/`winner` instead. `styleAttributes` and `payments` render only on awarded/closed contest detail pages. No client review text exists publicly — only the aggregate positive-feedback score.

### For AI Agents & LLM Apps

- **Purpose**: given a mode (`contests`/`designers`) or explicit URLs, returns one structured row per DesignCrowd contest or designer, including prize budgets, deadlines, briefs, ratings, earnings and portfolio.
- **Minimal working input**:

```json
{ "mode": "contests", "contestStatus": "open", "maxItems": 20 }
```

- **Variant inputs**: designers — `{ "mode": "designers", "maxItems": 20 }`; both — `{ "mode": "both", "maxItems": 50 }`; explicit URLs — `{ "startUrls": ["https://www.designcrowd.com/sitemap-contest-ids-1.xml"], "maxItems": 500 }`.
- **Output fields** — contests: `contestId, title, category, status, prizeBudgetAmount, prizeCurrency, deadlineIso, brief, payments, entriesDesigns, entriesDesigners, winner, private`; designers: `designerId, name, location, city, rank, rating, positiveFeedbackScore, earningsAmount, earningsCurrency, submissions, portfolio`.
- **Behaviors an agent should know**: `startUrls` overrides the built-in defaults. `includeContestDetail` is on by default — it costs ~1 extra request per contest; turn it off for cheap listing-only sweeps (the listing card already contains exact deadline, budget and entry counts). `maxItems` caps all dataset rows; free users are capped at 10 regardless. `maxRequestsPerCrawl` should stay `0` to auto-size to `maxItems` (detail mode needs ~1 request per record). `requestsPerMinute` is a plain ceiling — a soft-limit page briefly drops the rate to 25%, not a failure. `maxConcurrency` needs matching memory (~5 MB per in-flight request); keep the default 50 with a 2 GB run. Gated contests come back as `private: true` with a brief snippet — do not retry them.
- **Billing**: pay-per-result — $0.004 per dataset row (plus Apify's per-start and compute charges on paid plans).

### Legal & Compliance Disclaimer

This actor is an independent tool and is not affiliated with, endorsed by, or sponsored by DesignCrowd (designcrowd.com). It accesses only publicly available pages; it does not log in, bypass registration gates, or access private customer briefs. You are responsible for complying with DesignCrowd's Terms of Service and applicable law when using the data. Personal data in designer records (names, locations) must not be used for unsolicited commercial outreach in violation of applicable law (e.g. CAN-SPAM, GDPR, CCPA).

### SEO Keywords

designcrowd scraper, design contest data, designcrowd api alternative, designer portfolio data, freelance designer leads, design contest prize amounts, designcrowd vs 99designs, logo design contest prices, graphic design pricing trends, talent sourcing design agencies, creative briefs data, designcrowd winner data, design market research, design trend analysis, freelance design rates, logo design cost benchmarks, creative crowdsourcing data, graphic designer database, designcrowd contest alerts, competition research design

# Actor input Schema

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

Which DesignCrowd data to collect. `contests` = design contests/jobs (title, category, prize budget, entries, deadline, brief). `designers` = designer profiles (name, location, rating, reviews, portfolio, earnings). `both` = contests and designers.

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

Explicit listing, detail, profile or sitemap URLs. Leave empty to use the built-in category/type lists. Accepts contest list pages (/jobs/open/corporateidentity/logo/), contest details (/jobs/job/4118535), designer listings (/designers/logo), designer profiles (/designer/1434790/teepousultan) and sitemaps (https://www.designcrowd.com/sitemap-contest-ids-1.xml).

## `contestStatus` (type: `string`):

Which contests to collect. `open` = currently running, `closed` = historical, `both` = everything.

## `contestCategories` (type: `array`):

Category/subtype pairs from the DesignCrowd jobs board, e.g. `corporateidentity/logo`, `webdesign/web`, `printdesign/poster`, `merchandisedesign/tshirt`, `graphicdesign/graphic`, `artandillustration/illustration`. Leave empty for the built-in default list.

## `designerTypes` (type: `array`):

DesignCrowd designer-listing slugs, e.g. `logo`, `tshirt`, `web`, `flyer`, `brochure`, `poster`, `stationery`, `packaging`, `graphic`, `illustration`. Leave empty for the built-in default list.

## `includeContestDetail` (type: `boolean`):

Fetch each contest's detail page (/jobs/job/<id>) to get the COMPLETE brief text, the exact project deadline, prize payment breakdown, logo text and the customer's style attributes. When disabled, only the listing card is scraped (truncated brief snippet, faster but less complete).

## `includeDesignerProfile` (type: `boolean`):

Fetch each designer's profile page to get their city, positive-feedback score, total submissions and full portfolio. When disabled, only the listing card is scraped (name, rating, rank, country, earnings).

## `includeEntries` (type: `boolean`):

Include the per-entry detail (designer name/URL, design URL) for each contest. Turn off for a much smaller dataset.

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

Hard cap on the number of records pushed to the dataset. Free users are automatically capped at 10.

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

How many HTTP requests may be in flight at the same time. This is the main speed knob — the default (50, or 60 with a proxy) overlaps the detail-page fetches instead of doing them one at a time. Roughly 5 MB of memory per concurrent request. Keep it high: throughput is this value divided by the response time, so fewer parallel requests means a proportionally slower crawl. Measured at 100: 200 records in 7 s, 0 failures.

## `requestsPerMinute` (type: `integer`):

Sustained request-rate ceiling applied across all parallel requests, so raising the parallelism does not turn into an unbounded flood. 0 disables throttling. DesignCrowd serves bursts from a single IP without blocking (1,800 req/min measured, 0 failures), so this is a safety rail rather than a real restriction; the actual limit is the container's CPU, so raise maxMemoryMbytes before raising this. The actor still cuts the rate to 25 % for 30 s if the site ever answers with a soft rate-limit page.

## `maxRequestsPerCrawl` (type: `integer`):

Maximum number of HTTP requests the crawler may make. Keeps runs bounded and compute cost predictable. Leave at 0 to auto-size it to maxItems (one request per record is needed when the detail/profile toggles are on).

## `proxy` (type: `object`):

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "mode": "contests",
  "startUrls": [],
  "contestStatus": "open",
  "contestCategories": [],
  "designerTypes": [],
  "includeContestDetail": true,
  "includeDesignerProfile": true,
  "includeEntries": true,
  "maxItems": 200,
  "maxConcurrency": 50,
  "requestsPerMinute": 1200,
  "maxRequestsPerCrawl": 0,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# 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": "contests",
    "startUrls": [],
    "contestStatus": "open",
    "contestCategories": [],
    "designerTypes": [],
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/designcrowd-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": "contests",
    "startUrls": [],
    "contestStatus": "open",
    "contestCategories": [],
    "designerTypes": [],
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/designcrowd-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 '{
  "mode": "contests",
  "startUrls": [],
  "contestStatus": "open",
  "contestCategories": [],
  "designerTypes": [],
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/designcrowd-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/designcrowd-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/8e5YymCkerezXCUUF/builds/cN2EtOxsrOhazc4B1/openapi.json