# Behance Portfolios Scraper (`automation-lab/behance-creative-portfolio-search-scraper`) Actor

Search public Behance projects and enrich creator, creative-field, media, thumbnail, appreciation, and view data for creative-talent research.

- **URL**: https://apify.com/automation-lab/behance-creative-portfolio-search-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 90.9% 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Behance Portfolios Scraper

Search public **Behance portfolios** and turn project results into structured records for creative-talent research, agency sourcing, design-market analysis, and repeatable portfolio snapshots.

The Actor searches Behance projects by keyword, applies source-native creative-field and sort filters, follows public result cursors, and exports project IDs, titles, creators, thumbnails, appreciations, views, query, and rank. Optional detail enrichment adds creator IDs, creative fields, and bounded public project media URLs.

No Behance login or customer account is required. Authenticated hiring, messaging, and contact-discovery tools are intentionally outside this Actor's scope.

### What can Behance Portfolios Scraper do?

- Search public Behance projects with one or several real keywords.
- Filter searches by a Behance creative field such as Architecture, Branding, Photography, or UI/UX.
- Order projects by Behance recommendations, appreciations, views, comments, or recency.
- Start from public Behance project-search URLs or individual gallery URLs.
- Follow public cursor pagination up to a bounded `maxItems` limit.
- Deduplicate projects by stable Behance project ID across all inputs.
- Preserve the search query and one-based result rank for downstream comparison.
- Optionally open project pages for creator IDs, creative fields, and media URLs.
- Export results through Apify datasets in JSON, CSV, Excel, XML, RSS, or JSONL.

### Who is it for?

#### Recruiters and talent sourcers

Build a review queue of public creative work by specialty before visiting the creator's public profile. Search terms and ranking remain attached to every project.

#### Design and brand agencies

Research visible project work in branding, architecture, UI/UX, illustration, photography, and other Behance fields without manually copying cards into a spreadsheet.

#### Creative strategy teams

Capture a bounded snapshot of projects and public engagement indicators for a keyword. Schedule the same input later and compare datasets in your own database or workflow.

#### Data and research teams

Feed typed Behance project records into BI tools, notebooks, data warehouses, or enrichment pipelines through the Apify API.

### Why use this Actor?

Behance's public search page uses a JavaScript browser challenge and cursor-based result delivery. This Actor executes the public browser flow, waits for recognizable project data, blocks unnecessary media transfer, and normalizes the visible records.

Unlike a profile-only scraper, the primary result is a **ranked project-search record** with its originating query. Unlike a media downloader, the Actor returns media URLs as research metadata and does not download project assets.

Failures are explicit. A challenge page, unsupported URL, malformed limit, or missing project grid is reported as an error rather than silently returned as an empty successful result.

### What Behance data is extracted?

| Field | Meaning | Availability |
| --- | --- | --- |
| `projectId` | Stable Behance gallery identifier | Always |
| `title` | Public project title | Always |
| `url` | Canonical public gallery URL | Always |
| `creator.name` | Public creator display name | Search and enrichment |
| `creator.url` | Public Behance creator profile | When surfaced |
| `creator.id` | Public creator identifier | Detail enrichment |
| `creativeFields` | Behance fields attached to a project | Detail enrichment |
| `thumbnailUrl` | Public project cover image URL | When surfaced |
| `mediaUrls` | Bounded project-module image URLs | Detail enrichment |
| `appreciations` | Public appreciation count at scrape time | When surfaced |
| `views` | Public view count at scrape time | When surfaced |
| `query` | Search query associated with the result | Search inputs |
| `rank` | One-based accepted-result rank in the run | Always |
| `enriched` | Whether the detail page was opened | Always |
| `scrapedAt` | ISO 8601 extraction timestamp | Always |

Public counters can change after a run. Missing values mean Behance did not surface the field in the processed page shape.

### How to search Behance projects

1. Open the Actor in Apify Console.
2. Enter one or more values in **Search queries**.
3. Optionally select a creative field and sort order.
4. Set a small `maxItems` while testing your sourcing criteria.
5. Enable `enrichDetails` only when you need project-page fields.
6. Run the Actor and open the **Behance projects** dataset view.
7. Export or integrate the dataset after checking the sample rows.

A useful first input is:

```json
{
  "searchQueries": ["branding designer"],
  "maxItems": 10,
  "enrichDetails": false
}
```

### Input parameters

| Input | Type | Default | Description |
| --- | --- | --- | --- |
| `searchQueries` | string array | none | Up to 20 public project-search phrases. |
| `startUrls` | URL array | none | Up to 100 public `/search/projects` or `/gallery/<id>` Behance URLs. |
| `creativeField` | string | none | Source-native creative-field filter applied to generated and explicit search URLs. |
| `sort` | string | `recommended` | `recommended`, `appreciations`, `views`, `comments`, or `published_date`. |
| `maxItems` | integer | `50` | Maximum unique projects saved, from 1 to 1,000. |
| `enrichDetails` | boolean | `false` | Opens each project page for richer public fields. |
| `maxMediaUrls` | integer | `20` | Maximum media URLs retained per enriched project, from 0 to 100. |

Provide at least one search query or start URL. Only public HTTPS URLs on `behance.net` are accepted.

### Search filters and explicit URLs

Search filters are applied consistently to generated keyword searches and explicit Behance search URLs. For example:

```json
{
  "startUrls": [
    { "url": "https://www.behance.net/search/projects?search=architecture%20portfolio" }
  ],
  "creativeField": "Architecture",
  "sort": "appreciations",
  "maxItems": 25
}
```

A public `/gallery/<projectId>/...` URL is treated as one exact project. Search-only filters do not alter an exact project URL.

### Detail enrichment

Set `enrichDetails` to `true` when the search card is not enough for your workflow.

The Actor then opens each accepted public project page and can add:

- public creator ID;
- attached Behance creative fields;
- project-module media URLs up to `maxMediaUrls`;
- engagement values available in public structured data.

Enrichment is deliberately bounded and sequential within the browser session. It is slower and costs more compute than search-only extraction. It does not download files, reveal private contact information, or interact with creators.

### Output example

A search-only run returns records shaped like this:

```json
{
  "projectId": "200140581",
  "title": "\"ANIVASI\" a non fiction film",
  "url": "https://www.behance.net/gallery/200140581/ANIVASI-a-non-fiction-film",
  "creator": {
    "name": "Shailendra Sathe",
    "url": "https://www.behance.net/Shailendra-Sathe"
  },
  "creativeFields": [],
  "thumbnailUrl": "https://mir-s3-cdn-cf.behance.net/projects/404/6f4732200140581.Y3JvcCwyODc2LDIyNTAsNjMzLDA.png",
  "mediaUrls": [],
  "appreciations": 0,
  "views": 0,
  "query": "branding designer",
  "rank": 1,
  "enriched": false,
  "scrapedAt": "2026-08-03T04:58:41.364Z"
}
```

This example reflects public source data at one point in time. Current search order and engagement values may differ.

### How much does it cost to search Behance portfolios?

The Actor uses pay-per-event pricing:

- one `start` event for each run;
- one `item` event for each validated project saved to the default dataset.

No item event is charged for a rejected, duplicate, failed, or empty record. Detail enrichment is included in the same item event; it does not create a separate charged record type.

The one-time start event is **$0.005**. The BRONZE item price is **$0.003464 per saved project**; the other active item tiers are FREE $0.0039836, SILVER $0.0027019, GOLD $0.0020784, PLATINUM $0.0013856, and DIAMOND $0.00096992.

At BRONZE, estimated event charges are about **$0.0085 for 1 project**, **$0.0223 for 5**, **$0.0396 for 10**, **$0.0916 for 25**, and **$0.3514 for 100**. These are Actor event charges; platform usage and the tier attached to your Apify plan may differ. Check the live pricing panel before a large run.

### Tips for efficient runs

- Begin with 5–20 results while tuning a query.
- Use `creativeField` to reduce irrelevant projects before enabling enrichment.
- Keep `enrichDetails` off if search-card fields satisfy your workflow.
- Reduce `maxMediaUrls` when only creator and creative-field metadata matters.
- Combine related queries in one run so project-ID deduplication works across them.
- Use stable schedules and store each dataset ID if you compare snapshots over time.
- Avoid very broad one-word queries when a role, specialty, or deliverable is known.

### Connection behavior

The Actor uses a resource-blocked browser session to execute Behance's public JavaScript challenge. It does not expose an automatic paid residential fallback: measured residential transfer varied enough to make small runs uneconomic at competitive per-project prices.

A missing recognizable project grid therefore fails explicitly. Retry later after a transient source interruption rather than paying for an unpredictable hidden proxy path.

### Scheduling portfolio snapshots

Apify schedules can rerun the same task daily, weekly, or monthly. A practical monitoring workflow is:

1. save a tested Actor input as an Apify Task;
2. schedule the Task;
3. send each completed dataset to your database or webhook;
4. compare `projectId`, engagement counters, and rank with the prior snapshot;
5. review newly observed IDs or meaningful changes.

The Actor creates snapshots. It does not maintain a hidden cross-run database, calculate diffs, or send alerts by itself.

### Spreadsheet and data-pipeline exports

Open the run dataset and choose JSON, CSV, Excel, XML, RSS, or JSONL. You can also request selected fields through the dataset API.

Common pipelines include:

- Behance project search to Google Sheets through Make;
- scheduled datasets to Airtable or a CRM review queue;
- JSONL export to a warehouse or vector-index preparation job;
- creator profile URLs passed to a separate, authorized enrichment process;
- rank and counter snapshots analyzed in Python or a BI tool.

### Run with the Apify API using cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~behance-creative-portfolio-search-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQueries": ["architecture portfolio"],
    "creativeField": "Architecture",
    "maxItems": 20,
    "enrichDetails": false
  }'
```

The response contains the run and default dataset IDs. Keep tokens in environment variables rather than source code.

### Run with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const { defaultDatasetId } = await client
  .actor('automation-lab/behance-creative-portfolio-search-scraper')
  .call({
    searchQueries: ['mobile app UX designer'],
    creativeField: 'UI/UX',
    maxItems: 25,
    enrichDetails: true,
    maxMediaUrls: 10,
  });

const { items } = await client.dataset(defaultDatasetId).listItems();
console.log(items);
```

### Run with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor(
    "automation-lab/behance-creative-portfolio-search-scraper"
).call(run_input={
    "searchQueries": ["editorial illustration"],
    "maxItems": 20,
    "enrichDetails": False,
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use with Apify MCP and Claude Code

Add this Actor to Claude Code through Apify MCP:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/behance-creative-portfolio-search-scraper"
```

For **Claude Desktop**, **Cursor**, and **VS Code**, add the equivalent HTTP MCP server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/behance-creative-portfolio-search-scraper"
    }
  }
}
```

Example prompts:

- “Search Behance for 15 architecture portfolio projects and return creator links.”
- “Collect five enriched UI/UX projects with no more than ten media URLs each.”
- “Run my Behance branding portfolio task and summarize the highest-viewed results.”

### Integrations

The default dataset works with Apify webhooks, schedules, Make, Zapier, Google Sheets, Slack, cloud storage, and custom API clients.

For repeat workflows, create an Apify Task with fixed filters and let the integration consume the new run's dataset ID. Do not read from a fixed named dataset, because per-run datasets provide a clean snapshot boundary.

### Limitations

- Behance can change its public page structure, filters, cursor behavior, or challenge flow.
- Search order and engagement counters are source-controlled and can change between runs.
- Public search can be broad; source-native filtering does not guarantee professional suitability.
- The Actor does not access authenticated hiring tools, private profiles, private contact data, or messages.
- It does not download media files or grant reuse rights for project assets.
- `maxItems` is a ceiling, not a promise that every query currently has that many distinct public projects.
- Detail enrichment is slower and may surface fewer fields on unusual project layouts.
- A zero-result query is valid only when Behance renders a recognizable empty-result state.

### Troubleshooting

#### The run reports that no project grid appeared

Check the query or URL in a normal browser and retry later if Behance is temporarily unavailable. Keep the test limit small while diagnosing. Persistent challenge changes are reported as failures rather than misleading empty output.

#### My search URL was rejected

Use a public HTTPS URL on `www.behance.net` beginning with `/search/projects` or `/gallery/<numeric-id>`. Profile URLs, hiring pages, Adobe account pages, and arbitrary external URLs are intentionally rejected.

#### Some enriched fields are empty

Behance does not expose every field on every project. Confirm that `enrichDetails` is true, then inspect the public gallery page. Empty arrays indicate that the expected public detail was not surfaced in the processed page shape.

#### Why are there fewer rows than requested?

The Actor deduplicates by project ID across all queries and stops when Behance's public cursor is exhausted. Overlapping queries can therefore produce fewer unique records than their raw card totals.

### Responsible and legal use

This Actor accesses public Behance pages. You are responsible for ensuring that your use complies with applicable laws, Behance and Adobe terms, copyright, privacy obligations, and the rights of creators.

Use the output for legitimate research and sourcing. Do not republish project media without permission, infer sensitive traits, create abusive outreach, circumvent access controls, or treat public portfolio data as consent for unrelated contact.

Store only what you need, apply appropriate retention controls, and honor valid deletion or correction requests in downstream systems.

### FAQ

#### Does the Actor require a Behance login?

No. It processes public search and gallery pages without customer credentials.

#### Can it find creator emails or contact people?

No. Authenticated hiring, messaging, and contact extraction are outside the supported product.

#### Can it scrape one known project?

Yes. Add its public `/gallery/<numeric-id>/...` URL to `startUrls`. The Actor enriches an explicit project URL so the returned record remains useful.

#### Can I search several specialties in one run?

Yes. Add up to 20 queries. Results are deduplicated by project ID while retaining the query that first accepted each project.

#### Does it monitor changes automatically?

The Actor returns timestamped snapshots. Use an Apify Task and schedule, then compare run datasets in your own workflow.

#### Does it download Behance images?

No. It returns public thumbnail and bounded project media URLs. It does not download or license the assets.

#### What happens when Behance blocks a route?

The Actor detects missing recognizable data and keeps navigation bounded. Persistent failure produces a failed run rather than misleading empty output or an unpredictable paid-proxy charge.

### Related workflows

Combine this Actor with Apify schedules, webhooks, datasets, and your authorized CRM or analytics destination. No currently public automation-lab Actor is listed as a Behance-specific companion; this avoids linking buyers to an unavailable or unrelated product.

# Actor input Schema

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

Keywords to search across public Behance projects, such as branding, architecture portfolio, or UI/UX designer.

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

Optional public behance.net /search/projects or /gallery/<id> URLs. Search filters below are also applied to search URLs.

## `creativeField` (type: `string`):

Optional Behance creative-field filter, for example Architecture, Branding, Graphic Design, Photography, or UI/UX.

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

Ordering requested from Behance.

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

Maximum unique project records saved across all queries and URLs.

## `enrichDetails` (type: `boolean`):

Open each public project page to add creator ID, creative fields, and bounded project media URLs. This is slower than search-only extraction.

## `maxMediaUrls` (type: `integer`):

Maximum public project-module image URLs retained when detail enrichment is enabled.

## Actor input object example

```json
{
  "searchQueries": [
    "branding designer"
  ],
  "sort": "recommended",
  "maxItems": 20,
  "enrichDetails": false,
  "maxMediaUrls": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

Open the run's default dataset in the Behance projects view.

# 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": [
        "branding designer"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/behance-creative-portfolio-search-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": ["branding designer"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/behance-creative-portfolio-search-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": [
    "branding designer"
  ],
  "maxItems": 20
}' |
apify call automation-lab/behance-creative-portfolio-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/behance-creative-portfolio-search-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/P0i9hct0cPUULU7w3/builds/NCJbToGU8Y0JVITMf/openapi.json