# Behance Scraper - projects, profiles, keyword search, no login (`datagleaner/behance-scraper`) Actor

Scrape public Behance projects by keyword, project URL or creator profile: stats, creative fields, tools, tags, images, owner, location, availability. No login, no browser.

- **URL**: https://apify.com/datagleaner/behance-scraper.md
- **Developed by:** [Data Gleaner](https://apify.com/datagleaner) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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, designer search and freelancers, no login

A low-priced Behance scraper: **$3 per 1,000 projects, $3 per 1,000 creators, no start fee.** It covers projects by keyword, project URLs, creator profiles and Behance people / designer search, exported as clean JSON, CSV or Excel. You get appreciations, views, tags, tools, image URLs, location, followers and freelance availability.

It needs no Behance or Adobe account, no API key, no cookies and no browser. The Actor reads the same public endpoint the Behance website uses for anonymous visitors, so runs are fast and cheap. It works as a Behance API alternative for anyone who needs project and profile data in a spreadsheet or pipeline.

### What you can do with it

- **Behance people / designer search.** Put keywords in `creatorSearchQueries` (`ui designer`, `motion`) to get one profile row per creator, with location, creative fields, followers, availability for hire and top tools. Add `country` to narrow it, for example UI designers in Germany: `creatorSearchQueries: ["ui designer"]`, `country: "DE"`.
- **Finding Behance freelancers and creative talent.** Search a style or skill (`3D character`, `packaging design`), then pass the `ownerUrl` of the projects you like to `profileUrls` to get each creator's profile: location, occupation, followers and whether they are available for freelance or full-time work.
- **Trend and competitor research.** Rank projects by appreciations, views or recency for any keyword and see the creative fields, tools and tags that go with the winners.
- **Portfolio and asset monitoring.** Track a creator or studio's latest projects on a schedule.
- **Dataset building and AI pipelines.** Titles, descriptions, tags and image URLs are structured and ready for embedding, classification or image-model research (check licences before reuse).

### Input

| Field | Type | What it does |
|---|---|---|
| `searchQueries` | list of text | Keywords to search for projects. Prefilled with `logo design`. |
| `creatorSearchQueries` | list of text | Keywords for Behance people / designer search. Returns profile rows, charged as profiles. |
| `country` | text | Optional two-letter ISO code (`US`, `DE`, `JP`). Creator search: creators based there. Project search: projects with at least one owner based there, so `ownerCountry` (first owner only) can differ. |
| `sort` | choice | `recommended` (default), `appreciations`, `views`, `comments`, `published_date` (newest first), `featured_date`. Creator search honours only `recommended`, `appreciations` and `published_date`; other values fall back to `recommended`. |
| `maxItemsPerQuery` | number | Cap per keyword (projects or creators). Default 20, max 1000. |
| `maxItems` | number | Cap on all rows (projects plus profiles) for the whole run. Default 0 = no cap. One knob to bound cost. |
| `projectUrls` | list of text | Project URLs (`https://www.behance.net/gallery/243538069/...`) or numeric IDs. Returns full details with `imageUrls`. |
| `profileUrls` | list of text | Profile URLs or usernames. Returns the profile and, optionally, the creator's projects. |
| `includeProfileProjects` | true / false | Also return the projects of each creator in `profileUrls` (default on; creator-search rows do not include projects). Charged as projects. |
| `maxProjectsPerProfile` | number | Cap per profile. Default 12. |
| `sinceDate` | text | Optional. Skip projects published before `2026-10-01` (UTC). Use with `sort: published_date` so the run stops early. |
| `requestDelaySeconds` | number | Pause between requests, default 1 s (randomised up to 1.5x). |
| `proxyConfiguration` | object | Optional Apify Proxy. Default is no proxy. |

At least one of `searchQueries`, `creatorSearchQueries`, `projectUrls` or `profileUrls` is needed. A run started with empty input runs a built-in example of 5 projects for `logo design`.

```json
{
  "searchQueries": ["logo design", "packaging"],
  "sort": "appreciations",
  "maxItemsPerQuery": 100,
  "profileUrls": ["https://www.behance.net/uxpolly"],
  "maxProjectsPerProfile": 12
}
```

### Output

One dataset item per project or profile, told apart by `type`. Export as JSON, CSV, Excel or via the API.

**Project** (`type: "project"`)

| Field | Meaning |
|---|---|
| `id`, `url`, `title` | Project ID, link and title. |
| `ownerName`, `ownerUsername`, `ownerUrl`, `ownerLocation`, `ownerCountry`, `ownerCity`, `ownerIsCreatorPro` | The first owner. Projects with several owners list all of them in `owners`. |
| `publishedAt`, `modifiedAt` | ISO 8601 UTC. |
| `appreciations`, `views`, `comments` | Engagement counts. |
| `fields`, `tools`, `tags` | Creative fields, software tools and tags (lists of text). |
| `coverImageUrl`, `coverOriginalUrl`, `coverWebpUrl`, `dominantColor` | Cover image (808 px when available), original and WEBP covers, and the project's dominant colour as `#rrggbb`. |
| `description` | Project description, when the creator wrote one. |
| `imageUrls` | All image URLs of the project. Only for `projectUrls`. |
| `query` / `projectUrl` / `profileUrl` | The input the item came from. |
| `scrapedAt` | UTC time of collection. |

**Profile** (`type: "profile"`): `username`, `url`, `displayName`, `firstName`, `lastName`, `location`, `country`, `city`, `creativeFields`, `occupation`, `company`, `followers`, `following`, `appreciations`, `views`, `comments`, `website`, `webLinks`, `socialLinks` (service, username, url), `availableFullTime`, `availableFreelance`, `availabilityTimeline`, `hireable`, `isResponsiveToHiring`, `isFeaturedFreelancer`, `topTools`, `avatarUrl`, `isCreatorPro`, `memberSince`, `query` / `profileUrl`, `scrapedAt`. In `socialLinks`, `username` is a display name and LinkedIn links are Behance redirect URLs; this is how Behance serves them.

```json
{
  "type": "project",
  "id": 243538069,
  "url": "https://www.behance.net/gallery/243538069/LOGOFOLIO-VOL01-Selected-Logos-Marks",
  "title": "LOGOFOLIO VOL.01 / Selected Logos & Marks",
  "ownerName": "POLINA PRYKHODKO",
  "ownerUsername": "uxpolly",
  "ownerUrl": "https://www.behance.net/uxpolly",
  "ownerLocation": "Lviv, Ukraine",
  "publishedAt": "2026-02-04T18:15:27+00:00",
  "appreciations": 2192,
  "views": 54801,
  "comments": 169,
  "fields": ["Branding", "Graphic Design", "Logo Design"],
  "tools": ["Adobe Photoshop", "Adobe Illustrator", "Adobe InDesign"],
  "tags": ["Logotype", "Logo Design", "branding", "typography"],
  "coverImageUrl": "https://mir-s3-cdn-cf.behance.net/projects/808/8c9ace243538069.Y3JvcCwxNjE2LDEyNjQsMCww.png",
  "imageUrls": ["https://mir-s3-cdn-cf.behance.net/project_modules/disp/fa3e32243538069.6984cd1a98708.png"],
  "projectUrl": "https://www.behance.net/gallery/243538069/LOGOFOLIO-VOL01-Selected-Logos-Marks",
  "scrapedAt": "2026-10-08T15:20:00+00:00"
}
```

### Pricing

Pay per event: **$3 per 1,000 projects** (one `project` event, $0.003, for each project saved; this price applies from 21 October 2026) and **$3 per 1,000 profiles** (one `profile` event, $0.003; creator search rows are profiles too). You pay only for items you receive, nothing for failed requests or retries, and the run stops by itself when your **maximum total charge** is reached. Platform usage is included. Prices are final.

Example: 5 keywords at 200 projects each is 1,000 projects, so $3. Profiling 100 creators with their 12 latest projects each is 100 profiles ($0.30) plus 1,200 projects ($3.60), $3.90 in total.

### Limits

- **Search depth.** Behance may run out of results for a keyword before your limit is reached. For more coverage, split a topic into narrower keywords or run on a schedule with `sort: published_date` and `sinceDate`.
- **Public data only, no login.** Private, mature-gated and drafts content, messages, follower lists and the creator's email are not available. Some profiles have no website or company, so those fields are `null`.
- **Descriptions** are empty when the creator wrote none; `imageUrls` appear only in project-URL mode (it needs one extra request per project).
- Behance can change or throttle its public endpoint at any time. The Actor backs off and retries with a fresh session, but a run may return less than requested when Behance limits it. Raise `requestDelaySeconds` or enable a proxy if that happens.

### Use with Python

```python
## pip install apify-client
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("datagleaner/behance-scraper").call(
    run_input={"searchQueries": ["packaging design"], "sort": "appreciations", "maxItemsPerQuery": 10}
)
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item["title"], item["appreciations"], item["url"])
```

This run returns up to ten projects, so it costs at most $0.03.

### Use with JavaScript / Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('datagleaner/behance-scraper').call({
    searchQueries: ['packaging design'],
    sort: 'appreciations',
    maxItemsPerQuery: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const item of items) console.log(item.title, item.appreciations, item.url);
```

### Use it from n8n, Make, Zapier or an AI agent

Actor ID: `datagleaner/behance-scraper`

Minimal input:

```
{
  "searchQueries": ["logo design"],
  "maxItemsPerQuery": 10
}
```

Each tool below runs this Actor with your own Apify API token.

- **n8n:** add the **Apify** node (`@apify/n8n-nodes-apify`). On n8n Cloud you install it from the community node registry. Choose **Run an Actor and get dataset**, set Actor to `datagleaner/behance-scraper` and paste the input above.
- **Make:** use the Apify app's **Run an Actor** module, then **Get Dataset Items** to read the results. **Watch Actor Runs** can trigger a scenario when a run finishes.
- **Zapier:** use the Apify action **Run Actor**, then the search **Fetch dataset items**. The trigger **Finished Actor run** starts a Zap when a run ends.
- **AI agents (MCP):** connect to `https://mcp.apify.com?tools=datagleaner/behance-scraper`. In Claude Code:

  ```
  claude mcp add --transport http apify "https://mcp.apify.com?tools=datagleaner/behance-scraper"
  ```

  Then run `/mcp` to sign in to Apify in your browser. Without the `tools` parameter, an agent can still find this Actor with the `search-actors` tool and run it with `call-actor`. Claude Desktop and other clients that take an `mcpServers` config can run the server locally with `npx -y @apify/actors-mcp-server` and `APIFY_TOKEN` set. Then ask in plain words, for example: "Find the 20 most appreciated Behance projects for packaging design, then get the profiles of their creators and list the ones available for freelance work, with location and website."
- **LangChain (Python):**

```python
## pip install langchain-apify, then set APIFY_TOKEN in your environment
import json
from langchain_apify import ApifyActorsTool
tool = ApifyActorsTool("datagleaner/behance-scraper")
result = tool.invoke({"run_input": json.loads('{"searchQueries": ["logo design"], "maxItemsPerQuery": 10}')})
```

### FAQ

**How do I scrape Behance?** Enter keywords, project URLs or profile URLs in the input, start the run, and download the dataset as JSON, CSV or Excel, or read it through the Apify API.

**Is there a Behance API I can use instead?** This Actor gives you Behance project and profile data as JSON through the Apify API, with no Behance API key needed.

**Can I find Behance freelancers with it?** Yes. Search a skill, then scrape the creators' profiles: `availableFreelance`, `availableFullTime` and `hireable` show their availability, next to `location`, `occupation` and `website`. `hireable` is `true` when either availability switch is on.

**Does it get creators' email addresses?** No. Behance does not show emails publicly. Profiles include `website`, `webLinks` and `socialLinks` when the creator added them.

**Do I need a Behance or Adobe account, or a proxy?** No account. A proxy is not usually needed; try Apify Proxy if you see repeated "request failed" warnings.

### Responsible use

This Actor collects only publicly visible data. Respect Behance's terms and keep the request rate low (the default pacing is deliberately polite). Projects are creators' copyrighted work: image URLs are links, not a licence to reuse the images. Profiles are personal data: **you** are responsible for having a lawful basis and meeting your obligations under GDPR, CCPA and any other law that applies to your use, including retention and deletion requests. This is not legal advice.

# Actor input Schema

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

Keywords to search for Behance projects (for example logo design, packaging, 3D character). Each keyword returns up to the limit below.

## `creatorSearchQueries` (type: `array`):

Keywords to search for Behance creators (people search, for example ui designer, packaging, motion). Returns one profile row per creator, up to the per-keyword limit below, with location, creative fields, followers, availability for hire, links and top tools. Charged as profiles.

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

Behance project URLs such as https://www.behance.net/gallery/243538069/LOGOFOLIO-VOL01 (or just the numeric ID). Returns full details including all image URLs.

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

Creator profiles such as https://www.behance.net/uxpolly or a username. Returns profile info and, optionally, the creator's projects.

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

How keyword search results are ordered. Creator search supports only Recommended, Most appreciated and Most recent; Most viewed, Most commented and Recently featured silently fall back to Recommended there.

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

Upper bound on projects (or creators) for each keyword.

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

Optional cap on all rows (projects plus profiles) for the whole run, across every keyword and URL. 0 means no cap. A single knob to bound the cost of a run.

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

Optional two-letter ISO country code (for example US, DE, JP). Limits creator search to creators based in that country, and project search to projects with at least one owner based there.

## `includeProfileProjects` (type: `boolean`):

For every profile URL, also return the creator's latest projects (charged as projects).

## `maxProjectsPerProfile` (type: `integer`):

Upper bound on projects returned for each profile when the option above is on.

## `sinceDate` (type: `string`):

Skip projects published before this date (YYYY-MM-DD or ISO 8601, UTC if no timezone). Combine with the Most recent sort so the run can stop early.

## `requestDelaySeconds` (type: `number`):

Base pause between requests; the actual pause is randomised up to 1.5x. Raise it if you see throttling.

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

Optional. Works without a proxy from Apify datacenter IPs; enable if Behance starts blocking your runs.

## Actor input object example

```json
{
  "searchQueries": [
    "logo design"
  ],
  "sort": "recommended",
  "maxItemsPerQuery": 20,
  "maxItems": 0,
  "includeProfileProjects": true,
  "maxProjectsPerProfile": 12,
  "requestDelaySeconds": 1,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `projects` (type: `string`):

No description

## `profiles` (type: `string`):

No description

## `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 = {
    "searchQueries": [
        "logo design"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("datagleaner/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"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("datagleaner/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"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call datagleaner/behance-scraper --silent --output-dataset

```

## MCP server setup

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