# Behance Scraper - Projects, Creators & Designer Leads (`scrapesage/behance-scraper`) Actor

Scrape Behance projects, creators and creative jobs: portfolios, views/appreciations, tools, tags, plus designer leads with availability-for-hire, budget, social links, location and contact enrichment. Keyless, no browser, with a new-content monitor. Independent tool, not affiliated with Behance.

- **URL**: https://apify.com/scrapesage/behance-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** Social media, Lead generation, Agents
- **Features:** Limited permissions
- **Stats:** 31 total users, 15 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 projects

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Behance Scraper - Projects, Creators & Designer Leads

> **Disclaimer:** This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Adobe Inc. or any of its subsidiaries. All trademarks mentioned are the property of their respective owners. "Behance" is referenced only to describe the publicly available website this Actor collects data from.

Extract **Behance data** - design **projects** with stats, creative fields, tools, tags and descriptions; **creator profiles** that double as ready-to-use **designer leads** (availability for hire, budget, location, website, social links, About text and contact email); and the **creative jobs** board with full job descriptions. One actor covers projects, profiles and jobs.

It reads the same public data Behance's own website loads for every logged-out visitor: no login, no browser, clean JSON, and **up to 1,000 results per search** (Behance's own pages stop at 24).

### Why this Behance scraper?

This actor delivers each project **and** each creator's full record - including the **availability signal recruiters and agencies actually pay for**: who is open to freelance or full-time work, their minimum budget, whether they want remote, and how to reach them.

| Data | This actor |
| --- | --- |
| Project title, cover, views, appreciations, comments | ✅ |
| Project **creative fields, tools used, tags, description, license** | ✅ |
| Creator name, username, avatar, stats | ✅ |
| Creator **occupation, company, location, About text** | ✅ |
| Creator **availability for hire** (freelance / full-time, remote, budget, timeline) | ✅ |
| Creator **social links** (LinkedIn, Instagram, Dribbble, X...) | ✅ when published |
| Creator **website + contact email** (from the profile and the creator's own site) | ✅ |
| Creator **work history, member-since, recent projects** | ✅ |
| Creative **jobs** with description, salary range, type, remote flag, company website and application link | ✅ |
| **Up to 1,000 results per search**, with filters applied to every row | ✅ |
| **0-100 lead score** per creator | ✅ |
| **Monitor mode** - only new content next run | ✅ |
| Projects, creators **and** jobs in one actor | ✅ |

### Use cases

- **Designer & creative lead generation** - find illustrators, UI/UX designers, brand designers, motion artists by field and location, filter to **available-for-hire only**, and export name, occupation, website, socials and email straight to your CRM.
- **Recruiting & talent sourcing** - target creators flagged open to full-time work, with their budget expectations, remote preference, hiring timeline and work history.
- **Agency & freelancer prospecting** - agencies pitching design services can find brands' in-house creatives; freelancers can scout competitors and rates.
- **Market & trend research** - track which tools (Figma, Blender, After Effects), styles and creative fields are trending, by appreciations and views.
- **Creative jobs intelligence** - monitor the Behance jobs board for new freelance, contract and full-time roles, with descriptions, salary ranges and remote flags.
- **Portfolio & inspiration feeds** - power galleries, newsletters and apps with structured project data.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) - the free plan is enough to try this actor.
2. Open the **Behance Scraper**, set a **search query** and/or **creative field**, choose your **content types** (Projects, Creators, Jobs), and add location or availability filters if you want targeted leads.
3. Click **Start** and watch results stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML, or RSS - or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "searchQueries": ["logo design"],
    "contentTypes": ["creators"],
    "creativeFields": ["branding"],
    "country": "DE",
    "availableForFreelance": true,
    "enrichContactEmails": true,
    "maxItemsPerQuery": 100,
    "maxItems": 100
}
```

- **searchQueries** - free-text searches (e.g. `logo`, `mobile app`, `3d character`).
- **contentTypes** *(default `["projects"]`)* - any of `projects`, `creators` (designer leads), `jobs`.
- **creativeFields** - Behance's own creative fields by name: `UI/UX`, `Branding`, `Illustration`, `Motion Graphics`, `Web Design`, `Photography`, `Logo Design`... Each field is combined with each query. A name Behance does not have is skipped and named on the run card, so you are never billed for unfiltered rows.
- **tools** - filter projects by software (`Figma`, `Photoshop`, `Blender`...). Each tool runs its own search.
- **sort** - `recommended`, `most_appreciated`, `most_viewed`, `most_recent`, `most_commented`.
- **timeframe** - Behance's own Today / This week / This month filter for projects: with the "most" sorts it ranks by activity in that window. It does not limit the publish date; for new work use `most_recent` or **publishedWithinDays**.
- **publishedWithinDays** - only keep projects published in the last N days.
- **country / state / city** - target creators and jobs by location (a two-letter code such as `US`, `GB`, `DE`, or an English name). A city given without a country is searched in the country most of its Behance members list.
- **availableForFreelance / availableForFullTime / availableForHireOnly** - narrow to in-market creators.
- **jobTypes / remoteOnly** - Freelance, Full-time, Contract; remote jobs only.
- **minFollowers / minAppreciations / minViews / withContactOnly** - row filters.
- **profileUrls / projectUrls / startUrls / urlsFromFile** - scrape specific profiles or projects, paste any Behance search or joblist link (its filters are kept), or import a list from a file or Google Sheet.
- **maxItemsPerQuery** *(default 24, up to 1,000)* - rows per search. When your filters drop results, the search reads further pages to fill it.
- **maxItems** *(default 200)* - cap for the whole run, shared fairly between searches.
- **includeProjectDetails** *(default true)* - description, tags, tools, license and module counts for every project, read with the search itself.
- **includeCreatorProfiles** *(default true)* - the full lead for every creator: website, web links, work history, About text and complete availability. For projects, the owner's lead is attached to each project.
- **includeJobDetails** *(default true)* - each job's description, posting and expiry dates, application link, company website and applicant count.
- **enrichContactEmails** *(default false)* - read each creator's own website for an email, phone numbers and social profiles they do not list on Behance.
- **monitorMode** *(default false)* - emit only NEW projects, creators or jobs versus previous runs.

### Output

Each row is tagged with a `type` (`project`, `creator`, or `job`). The **Overview** table lists every row with its name, a one-line summary and its link; the **Projects**, **Creators (leads)** and **Jobs** tables each show one record type's columns. In a run that mixes types, each of those tables pages through the whole dataset 50 items at a time; the first page of each search is kept small so every type shows on page 1, and if a type still starts later, the run's final message names the page it starts on. Through the API, `items?view=creators&clean=true` (or `projects` / `jobs`) returns all of one type's rows together; leave `limit` out or set it above the run's row count, because the API pages before it drops the other types' rows.

A creator lead (`type: "creator"`):

```json
{
    "type": "creator",
    "source": "behance",
    "id": 505386,
    "username": "mazakii",
    "displayName": "Jing Zhang",
    "occupation": "Illustration, infographic, craft, map",
    "location": { "full": "London, United Kingdom", "city": "London", "country": "United Kingdom", "countryCode": "GB" },
    "website": "https://www.mazakii.com",
    "socialLinks": [
        { "service": "Instagram", "url": "http://instagram.com/mrsjwignall", "verified": true },
        { "service": "Twitter", "url": "http://twitter.com/mazakiiz", "verified": false }
    ],
    "stats": { "views": 2725084, "appreciations": 181879, "followers": 104834, "following": 312 },
    "availability": {
        "forHire": true, "availableForFreelance": true, "availableForFullTime": false,
        "lookingForRemote": false, "openToRelocation": false,
        "availabilityTimeline": "within_next_few_weeks", "hiringTimeline": "now",
        "minBudgetUsd": 1000, "currency": "USD"
    },
    "availableForHire": true,
    "memberSince": "2011-06-20T15:46:48.000Z",
    "contact": {
        "emails": ["jing@mazakii.com"], "extraSocials": null, "phones": null,
        "crawledFrom": ["https://www.mazakii.com", "https://www.mazakii.com/About-Contact"]
    },
    "bestEmail": "jing@mazakii.com",
    "leadScore": 97,
    "locationText": "London, United Kingdom",
    "about": "illustrator who has love for cities, architecture, infographic, maps, information design, ...",
    "profileEmails": ["jing@mazakii.com"],
    "recentProjects": [{ "title": "The world underneath our skin", "url": "https://www.behance.net/gallery/194750677/The-world-underneath-our-skin" }],
    "scrapedAt": "2026-10-20T00:24:32.987Z"
}
```

(Abridged: the full row also carries `firstName`, `company`, `webLinks`, `workExperiences`, `isFeaturedFreelancer`, `canBeRecruited`, `creatorPro`, `freelanceStats`, `avatarUrl`, `bannerUrl`, `summary` and the table columns.)

A creator's `website` is always their own site. Many creators type an Instagram, Linktree, Dribbble or Behance link into Behance's website field; that link stays in `declaredWebsite` (and usually in `socialLinks`), and `website` falls back to an own site from their web links, or stays empty. Likewise `currentCompany` (the Creators table's Company column) is left empty when the company field holds an email, a social handle or a phone number; `company` keeps what the creator typed.

A project (`type: "project"`) carries `title`, `url`, `coverUrl`, `publishedOn`, `stats` (views, appreciations, comments), `owners`, `creativeFields`, plus (with `includeProjectDetails`) `description`, `tags`, `tools`, `license` and module/image counts, and (with `includeCreatorProfiles`) a `creatorLead` for its owner. A job (`type: "job"`) carries `title`, `company`, `location`, `isRemote`, `jobType`, `salary` (min, max, currency, timeframe), `hiringContact`, and with `includeJobDetails` its `description`, `postedOn`, `expiresOn`, `applicationUrl`, `companyWebsite` and `applicantCount`.

The table columns such as `projectTitle`, `profileUrl` or `jobTitle` are copies of the matching fields, so each table shows only its own record type.

#### What to expect (field coverage)

Behance is user-entered data, so some fields are filled only when the creator or employer published them. Measured on test runs on 2026-10-20:

| Entity | Always present | Usually present | Present when published |
|---|---|---|---|
| **Project** | title, URL, cover, stats, owner, creative fields, tags, module counts | tools ~95% | description ~55%, curated features ~35% |
| **Creator** | username, name, URL, stats, location, availability, About text | occupation ~95%, own website ~70%, socials ~90% | company ~65%, web links ~65%, work history ~50%, email (profile + website enrichment) |
| **Job** | title, type, URL, company, remote flag, description, posting and expiry dates, application link | salary range ~90% | company website, categories (freelance briefs) |

A blank field means the creator or employer did not publish it - not that scraping failed.

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

This Actor uses Apify's **pay-per-event** pricing: you pay for the results it delivers, with no monthly rental. From 4 November 2026 each run also carries Apify's standard run-start fee of $0.002 (once per GB of run memory, so once at the default 512 MB); until then there is no start fee. The events it can charge are:

- **Project** - One Behance project record: title, URL, cover & images, dates, views/appreciations/comments, premium & mature flags, curated features, owners, plus (with details on) description, tags, tools, creative fields and module counts.
- **Creator lead** - One Behance creator/designer lead: name, occupation, company, location, website & web links, social links, stats, availability-for-hire (freelance/full-time, remote, budget), work history, member-since and a 0-100 lead score.
- **Job** - One Behance creative job: title, company, location, remote flag, job type, salary/budget range and currency, apply link and hiring contact.
- **Contact enrichment** - A creator's own website (home, contact and about pages) read for an email, phone numbers and social profiles they do not list on Behance. Charged only when the website gives new contact data.
- **Actor Start** (from 4 November 2026) - Charged by Apify when a run starts: one event per GB of run memory (minimum one), so $0.002 for a run at the default 512 MB.

The current price of each event is shown on the **Pricing** tab of this page. Set a maximum total charge on the run if you want a hard cap on spend (the actor then delivers only whole rows that fit it), and use the input limits to control how much it fetches.

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** - start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** - official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** - run it daily or weekly with **monitor mode** to capture newly published projects, new creators in a field or location, or fresh job posts.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** - trigger downstream actions (CRM import, Slack alert, email sequence) the moment a run finishes.

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/behance-scraper').call({
    searchQueries: ['logo design'],
    contentTypes: ['creators'],
    country: 'DE',
    availableForFreelance: true,
    enrichContactEmails: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} creator leads`);
```

When you read a single table through the API (`items?view=creators`), add `clean=true` so rows of the other record types are left out.

### Integrate with any app

Connect the dataset to 5,000+ apps - no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** - multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** - push new designer leads straight into your CRM.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** - get notified when a monitored field or location adds new creators or jobs.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** - auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** - pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** - trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. Call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** - ask your assistant to "find UI/UX designers in Berlin who are available for freelance, with their website and email" and let it run the scraper for you.

### Agent-ready: autonomous payments (x402 & Skyfire)

This actor is **agent-ready**: AI agents can discover it, run it, and **pay for it autonomously**, with no Apify account and no human in the loop. It uses [pay-per-event](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) pricing and [limited permissions](https://docs.apify.com/platform/actors/development/permissions), so it qualifies for Apify's agentic-payment standards:

- **[x402](https://docs.apify.com/platform/integrations/x402)**: an open, HTTP-native payment protocol. Agents pay per run in USDC on the Base network directly through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp), with no account and no API key.
- **[Skyfire](https://docs.apify.com/platform/integrations/skyfire)**: agent-to-service payments for fully autonomous AI-agent workflows.

Building an AI agent, MCP tool, or autonomous data pipeline? This scraper is ready to plug in and pay as it goes.

### More scrapers from scrapesage

Build a complete **creator, talent & lead-gen stack**:

- **[GitHub Scraper](https://apify.com/scrapesage/github-scraper)** - repos, developers and contact leads.
- **[Hugging Face Scraper](https://apify.com/scrapesage/hugging-face-scraper)** - AI models, datasets, Spaces and creator leads.
- **[Product Hunt Scraper](https://apify.com/scrapesage/product-hunt-scraper)** - launches, makers and leads.
- **[Linktree Scraper](https://apify.com/scrapesage/linktree-scraper)** - creator bio links, emails and leads.
- **[YouTube Scraper](https://apify.com/scrapesage/youtube-scraper)** - channels, videos and creator leads.
- **[LinkedIn Jobs Scraper](https://apify.com/scrapesage/linkedin-jobs-scraper)** - job postings as hiring-intent signals.
- **[Website Contact Scraper](https://apify.com/scrapesage/website-contact-scraper)** - emails, phones and socials from any site.

### Tips

- **For leads, scrape `creators`** with a `creativeField` plus `country`/`city` and turn on `availableForHireOnly` - you get a clean, contactable, in-market list.
- **Add `enrichContactEmails`** to read each creator's own website. Many designers publish their email there; the profile's own email (when they typed one in) is used too.
- **Go deep**: raise `maxItemsPerQuery` (up to 1,000) for one big search, or combine several queries, creative fields and sort orders for breadth.
- **Projects also yield leads**: with `includeCreatorProfiles` on, every project carries its owner's lead; set `emitProjectOwners` to output those as their own rows.
- **Recurring monitoring**: combine [Schedules](https://docs.apify.com/platform/schedules) with `monitorMode` to watch a field, a location, or the jobs board for new entries.

### FAQ

**Does it need the Behance/Adobe API or a key?** No. Behance's old public API was retired; this actor reads the same public data Behance's own website loads for every logged-out visitor - no key or login needed.

**How many results per search?** Up to 1,000 per search (set `maxItemsPerQuery`). For more, combine several search queries, creative fields, sorts and locations, or pass specific profiles and projects directly.

**Where do availability and budget come from?** From each creator's own Behance "available for work" settings - whether they are open to freelance or full-time, want remote, their minimum budget and hiring timeline. Fields are blank when the creator has not set them.

**Where do emails come from?** Behance shows no emails to logged-out visitors. The actor takes any email a creator typed into their own profile, and (with `enrichContactEmails`) reads the creator's own linked website, where many designers list a contact email. Addresses of other parties (platforms, web agencies, no-reply mailboxes) are left out.

**Can I export to Google Sheets, CSV, or Excel?** Yes - one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**How do I monitor a field or location for new creators or jobs?** Turn on `monitorMode` and create a [Schedule](https://docs.apify.com/platform/schedules); optionally add a [webhook](https://docs.apify.com/platform/integrations/webhooks) or [Zapier zap](https://docs.apify.com/platform/integrations/zapier) to push new records into your CRM as they appear.

**A field is empty - why?** Some creators do not publish a website, socials or availability; some projects have no description. Fields are blank only when the data was not published - never because the scraper skipped it.

**Is scraping Behance legal?** This actor collects publicly available data only. You are responsible for using the data in compliance with applicable laws (e.g. GDPR/CCPA for personal data) and Behance's terms.

### Data & lawful use

This Actor reads only what Behance publishes to logged-out visitors: it does not log in, create accounts, use anyone's credentials, or reach anything behind a sign-in. Like any logged-out browser, it accepts the anonymous visitor cookies and the anonymous visitor token Behance issues to every visitor, because Behance's public pages and data feeds answer only requests that carry them; they identify no person and are discarded when the run ends. With "Enrich contact emails" on, it also reads the public home, contact and about pages of the websites creators link from their Behance profiles. Names, handles, bios and engagement figures are public, but they relate to identifiable people, so treat the output as personal data. If you are in the EU or UK you are the data controller for what you do with it: have a lawful basis (usually legitimate interest for research, marketing analytics or B2B prospecting), honour access and deletion requests, and do not use the output for spam or unsolicited messaging.

Under [Apify's Standard Actor Contract](https://docs.apify.com/legal/standard-actor-contract), which governs your use of this Actor, you are the controller of any personal data in your input and output and scrapesage acts only as your processor: that data is processed solely to run your job, written only to your own Apify storage, never used for any other purpose and never shared onward. If you need help with a data-subject request that involves this Actor's output, open an issue on the Issues tab.

### Disclaimer

**This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Adobe Inc. or any of its subsidiaries. All trademarks mentioned are the property of their respective owners.**

"Behance" and any related marks are the property of their respective owners and are used here only in a descriptive, nominative sense - to identify the publicly accessible website from which this Actor collects data. This Actor is not an official Behance product, is not authorised or certified by Adobe Inc., and does not distribute Behance software. It collects only publicly available information; you are responsible for ensuring your use of that data complies with applicable laws, regulations and the terms of the source website.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome - this actor is actively maintained.

# Actor input Schema

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

Free-text searches run on Behance for each selected content type (e.g. "logo", "mobile app", "3d character"). Each search returns up to "Max items per search" results, and Behance serves up to 1,000 per search. Combine with creative fields, tools, sort and location.

## `contentTypes` (type: `array`):

What to scrape: design Projects, Creators (designer profiles = leads), and/or creative Jobs. Searches, fields and filters apply to each selected type.

## `creativeFields` (type: `array`):

Limit results to one or more of Behance's creative fields, by name (e.g. UI/UX, Branding, Illustration, Motion Graphics, Web Design, Photography, Logo Design). Each field is combined with each search query. A name Behance does not have is skipped and named on the run card, so no unfiltered rows are billed for it.

## `tools` (type: `array`):

Filter projects by the software used, e.g. Figma, Photoshop, Illustrator, Blender, After Effects. Each tool runs its own search, so you get projects made with any of them.

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

Sort order for searches. Different sorts surface different results, widening coverage.

## `timeframe` (type: `string`):

Behance's own time filter for project searches. With Most appreciated, Most viewed or Most commented it ranks projects by their activity in that window (what is popular today, this week or this month); it does not limit the publish date. For newly published work use Sort = Most recent, or "Published within (days)".

## `publishedWithinDays` (type: `integer`):

Only keep projects published in the last N days. Leave empty for no limit. Pairs well with Sort = Most recent.

## `country` (type: `string`):

Country to target creators and jobs by location: a two-letter code (US, GB, DE, FR, IN, BR) or an English name (Germany). Jobs keep on-site jobs there and remote jobs open to it.

## `state` (type: `string`):

State or region to target creators by location, used with Country (e.g. California or CA for the US).

## `city` (type: `string`):

City to target creators and jobs by location, e.g. Berlin, London, New York. Best used with Country; a city given alone is searched in the country most of its Behance members list.

## `availableForFreelance` (type: `boolean`):

Only return creators who flag themselves as available for freelance work.

## `availableForFullTime` (type: `boolean`):

Only return creators who flag themselves as available for full-time work.

## `jobTypes` (type: `array`):

Filter jobs by type. Behance uses Freelance, Full-time and Contract.

## `remoteOnly` (type: `boolean`):

Only return jobs flagged as remote.

## `minFollowers` (type: `integer`):

Only keep creators with at least this many followers. 0 = no filter.

## `minAppreciations` (type: `integer`):

Only keep creators/projects with at least this many appreciations (likes). 0 = no filter.

## `minViews` (type: `integer`):

Only keep creators/projects with at least this many views. 0 = no filter.

## `availableForHireOnly` (type: `boolean`):

Drop creators who are not open to freelance or full-time work - keep only contactable, in-market leads.

## `withContactOnly` (type: `boolean`):

Only keep creator leads that have at least one of: website, social link, or enriched email.

## `profileUrls` (type: `array`):

Direct Behance profiles to pull as full creator leads, e.g. https://www.behance.net/uxpolly or just "uxpolly".

## `projectUrls` (type: `array`):

Direct Behance project (gallery) pages or numeric ids, e.g. https://www.behance.net/gallery/243538069/My-Project or 243538069.

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

Optional mixed list of behance.net URLs - profiles, gallery projects, or /search and /joblist result pages. Each is auto-classified, and a pasted search link keeps every filter it carries.

## `urlsFromFile` (type: `string`):

Paste a list of URLs (one per line), OR one link to a .txt/.csv file, Google Sheet or Google Drive file containing them. Lets you import many Start URLs at once instead of typing each. Google Sheet/Drive share links are handled automatically.

## `includeProjectDetails` (type: `boolean`):

Adds each project's description, tags, tools used, license and module/image counts. They come with the search itself (no extra page per project); turn off for leaner rows.

## `includeCreatorProfiles` (type: `boolean`):

The full lead for each creator: occupation, company, website, web links, work history, About text and complete availability/budget. For projects, attaches the primary owner's lead to each project. Turn off for leaner rows.

## `includeJobDetails` (type: `boolean`):

Adds each job's description, posting and expiry dates, application link, company website, creative fields and applicant count (one small extra request per job).

## `enrichContactEmails` (type: `boolean`):

Read each creator's own website (home + contact/about pages) for an email, phone numbers and social profiles they do not list on Behance. Behance shows no emails to logged-out visitors, so this is the way to get them. Charged as Contact enrichment only when the website gives new contact data.

## `emitProjectOwners` (type: `boolean`):

When scraping projects, also output a separate creator-lead record for each project's owner (deduplicated), not just the summary attached to the project.

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

Global cap on the total number of records (projects + creators + jobs) scraped across all searches and inputs. Searches take turns, so the cap is shared fairly between them.

## `maxItemsPerQuery` (type: `integer`):

Rows each search delivers (Behance serves up to 1,000 results per search). When your filters drop results, the search reads further pages to fill it. In monitor mode it is the number of top results checked per search.

## `deduplicateCreators` (type: `boolean`):

Emit each creator only once per run even if they appear across multiple searches or projects.

## `monitorMode` (type: `boolean`):

Remember project/creator/job ids returned in previous runs (in a named key-value store) and emit only NEW ones next time. Pair with an Apify Schedule to watch a field, a search, or a location for fresh portfolios, creators or jobs. The schedule decides WHEN to run; monitor mode decides WHAT is new.

## `monitorStoreName` (type: `string`):

Name of the key-value store that holds the monitor's memory. Use different names to track different watches independently. Lowercase letters, digits and hyphens only.

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

How many detail requests (job details, creator websites) run in parallel.

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

Proxy settings. Apify Residential (US) is the default and the recommended choice; a fresh session is used whenever Behance refuses one. Creators' own websites are always read over Apify datacenter proxies.

## Actor input object example

```json
{
  "searchQueries": [
    "logo design",
    "mobile app"
  ],
  "contentTypes": [
    "projects"
  ],
  "creativeFields": [
    "ui/ux",
    "branding",
    "illustration"
  ],
  "tools": [
    "Figma"
  ],
  "sort": "recommended",
  "timeframe": "all",
  "availableForFreelance": false,
  "availableForFullTime": false,
  "remoteOnly": false,
  "minFollowers": 0,
  "minAppreciations": 0,
  "minViews": 0,
  "availableForHireOnly": false,
  "withContactOnly": false,
  "profileUrls": [
    "https://www.behance.net/uxpolly"
  ],
  "projectUrls": [
    "https://www.behance.net/gallery/243538069/x"
  ],
  "urlsFromFile": "",
  "includeProjectDetails": true,
  "includeCreatorProfiles": true,
  "includeJobDetails": true,
  "enrichContactEmails": false,
  "emitProjectOwners": false,
  "maxItems": 200,
  "maxItemsPerQuery": 24,
  "deduplicateCreators": true,
  "monitorMode": false,
  "monitorStoreName": "behance-monitor",
  "maxConcurrency": 6,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

All scraped records in the default dataset.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchQueries": [
        "logo design"
    ],
    "urlsFromFile": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/behance-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQueries": ["logo design"],
    "urlsFromFile": "",
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/behance-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "logo design"
  ],
  "urlsFromFile": ""
}' |
apify call scrapesage/behance-scraper --silent --output-dataset

```

## MCP server setup

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