# DeviantArt Scraper (`maximedupre/deviantart-scraper`) Actor

Scrape DeviantArt artwork search, gallery/profile artwork, popular pieces, and public creator emails. Export artwork URLs, titles, images, creators, dates, and contact snippets when visible.

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

## Pricing

from $2.70 / 1,000 scraped 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### 🎨 DeviantArt scraper for artwork and creator contacts

DeviantArt Scraper collects public artwork and creator data from [DeviantArt](https://www.deviantart.com/). Use it to scrape DeviantArt search results, gallery/profile artwork, popular artwork, exact artwork URLs, and public creator email leads in one Apify dataset.

Start with a plain search term such as `fantasy art`, a DeviantArt search URL, a creator username such as `nanchoart`, or an artwork URL. The Actor returns clean rows with artwork URLs, deviation IDs, titles, image and thumbnail URLs, creator usernames, creator names, avatars, publish dates when shown, and public email/contact snippets when visible.

For a quick first run, keep **Artwork search**, leave the prefilled `fantasy art` target, and keep **Maximum rows** at `512`. You do not need a DeviantArt login, cookies, API key, or browser setup from your side.

### ✅ What this Actor does

- Scrapes public DeviantArt artwork search results from plain keywords or DeviantArt search URLs.
- Scrapes a creator gallery from a DeviantArt username, handle, profile URL, or gallery-style target.
- Scrapes popular or trending public artwork, with an optional category term for supported artwork sources.
- Scrapes exact DeviantArt artwork URLs when you already know the page.
- Finds public creator emails when they are visible in the source text and match your domain filters.
- Saves one dataset row per accepted artwork or creator contact result.
- Keeps the submitted target on each row so batch runs are easy to trace.
- Charges only for saved results.

The Actor focuses on public DeviantArt data. It does not scrape private, login-only, mature-gated, paywalled, or unavailable content. It also does not download image files; it returns source-backed image and thumbnail URLs.

### 📦 Data you can export

Each dataset row can include:

- `target` - the search term, URL, username, handle, or source label that produced the row.
- `rank` - the row position within the target when there is a meaningful order.
- `deviationId` and `deviationUrl` - DeviantArt artwork identity and source URL.
- `title`, `description`, and `publishedAt` - artwork or profile text when DeviantArt exposes it.
- `category` - a source-exposed category when available. Many rows leave this `null`.
- `imageUrl` and `thumbnailUrl` - public media preview URLs.
- `creatorUsername`, `creatorName`, and `creatorAvatarUrl` - creator identity fields.
- `emails`, `emailDomains`, and `profileBio` - public contact data found in the row text.

Fields can be `null` or empty when DeviantArt does not expose that value for a specific row. The dataset does not contain error rows or diagnostic rows.

### 🚀 How to run it

1. Choose **What to collect**.
2. Add one or more **Targets** when the selected source type uses targets.
3. Set **Maximum rows** for the whole run.
4. Optionally choose an **Artwork category** for artwork search or popular/trending runs.
5. For public email leads, add a location or niche and the email domains you want.
6. Run the Actor and open the dataset.

Good first inputs:

```json
{
  "sourceType": "artworkSearch",
  "targets": ["fantasy art"],
  "maxItems": 512
}
````

For creator gallery scraping:

```json
{
  "sourceType": "gallery",
  "targets": ["nanchoart"],
  "maxItems": 25
}
```

For public email leads:

```json
{
  "sourceType": "emailLeads",
  "targets": ["commissions gmail"],
  "location": "Germany",
  "emailDomains": ["@gmail.com"],
  "maxItems": 25
}
```

### ⚙️ Input options

`sourceType` controls the run mode:

- `artworkSearch` searches public DeviantArt artwork from keywords, search URLs, or exact artwork URLs.
- `gallery` collects public artwork for a DeviantArt creator username, handle, or profile URL.
- `popular` collects popular/trending public artwork. Targets can be empty.
- `emailLeads` searches for public creator contact rows and filters visible emails by domain when you provide domains.

`targets` accepts plain search terms, DeviantArt search URLs, profile URLs, artwork URLs, usernames, and handles. For popular/trending runs, you can leave targets empty and use the category filter instead.

`maxItems` caps saved rows across the whole run. The public input allows up to `10000`, but source availability, repeated results, and filters can make a run finish with fewer rows.

`category` narrows artwork search or popular/trending source results. The Actor does not copy the input category into output rows unless DeviantArt exposes a category for that row.

`location` and `emailDomains` are mainly for public email lead runs. Use location or niche text such as `Germany`, `book cover`, or `commissions`; use domains such as `@gmail.com` or `@protonmail.com`.

### 📄 Output example

```json
{
  "target": "fantasy art",
  "rank": 1,
  "deviationId": "1336702744",
  "deviationUrl": "https://www.deviantart.com/nanchoart/art/Phoenix-Dawn-1336702744",
  "title": "Phoenix Dawn",
  "description": null,
  "publishedAt": "2026-05-24T09:35:20.000Z",
  "category": null,
  "imageUrl": "https://images-wixmp.example/full.jpg",
  "thumbnailUrl": "https://images-wixmp.example/thumb.jpg",
  "creatorUsername": "nanchoart",
  "creatorName": "NanchoArt",
  "creatorAvatarUrl": "https://a.deviantart.net/avatars-big/n/a/nanchoart.jpg",
  "emails": [],
  "emailDomains": [],
  "profileBio": null
}
```

You can export the dataset as JSON, CSV, Excel, XML, RSS, or HTML, call it through the Apify API, schedule repeat runs, or connect it to webhooks and integrations.

### 💳 Pricing

This Actor uses pay-per-result pricing. You are charged for saved public DeviantArt results, not for failed targets or empty searches.

Each saved result is charged as one `deviantart-result` event, with tiered pricing from `$0.00445` per result on the FREE tier down to `$0.00270` per result on GOLD, PLATINUM, and DIAMOND tiers.

### ⚠️ Limits and caveats

- The Actor works with public DeviantArt data only.
- Some rows do not include descriptions, categories, dates, avatars, or emails because the source does not always expose them.
- The `category` input can shape artwork search or popular/trending results, but per-row `category` is only filled when the source exposes it.
- Public emails are returned only when visible in the scraped source text. The Actor does not verify deliverability.
- Image fields are URLs to public media previews, not downloaded image files.
- Empty or invalid targets are handled without saving error rows.

### ❓ FAQ

#### 🔐 Do I need a DeviantArt account?

No. The Actor is built for public DeviantArt data and does not ask you for DeviantArt cookies, a login, or an API key.

#### 🖼️ Can this replace a DeviantArt image downloader?

Not if you need binary image files saved for you. This Actor returns image and thumbnail URLs with artwork and creator metadata. It does not download or store the images.

#### 🧭 Why is `category` sometimes null?

DeviantArt does not expose a reliable per-row category for every source item. The Actor keeps `category` empty instead of guessing or repeating the input filter.

#### 📧 Can I use it for creator outreach?

Yes, when public email addresses are visible in DeviantArt source text. Use `emailLeads`, add niche terms, and set `emailDomains` to focus the results.

### 📝 Changelog

- 0.0: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~deviantart-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Behance Dribbble Scraper ↗](https://apify.com/maximedupre/behance-dribbble-scraper) - collect public designer profiles, projects, and shots for creative research.
- [Instagram Profile Stats Scraper ↗](https://apify.com/maximedupre/instagram-profile-stats-scraper) - export public Instagram profile stats, bios, contact hints, and recent content previews.
- [Pinterest Keyword Scraper ↗](https://apify.com/maximedupre/pinterest-keyword-scraper) - collect Pinterest autocomplete keyword ideas for visual content planning.
- [Tumblr Media Downloader ↗](https://apify.com/maximedupre/tumblr-media-downloader) - extract public Tumblr media URLs and post context from posts, blogs, and archives.
- [SoundCloud Scraper ↗](https://apify.com/maximedupre/soundcloud-scraper) - scrape public SoundCloud tracks, artists, playlists, albums, and comments.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `sourceType` (type: `string`):

Choose the DeviantArt source for this run.

## `targets` (type: `array`):

Use search terms, DeviantArt search URLs, profile URLs, artwork URLs, usernames, or handles.

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

Limit successful rows across the whole run.

## `category` (type: `string`):

Narrow artwork search or popular/trending rows by DeviantArt category.

## `location` (type: `string`):

Focus public email lead searches with a location, style, or niche.

## `emailDomains` (type: `array`):

Focus public email lead rows on addresses from these domains.

## Actor input object example

```json
{
  "sourceType": "artworkSearch",
  "targets": [
    "fantasy art"
  ],
  "maxItems": 512,
  "category": "",
  "location": "Germany",
  "emailDomains": [
    "@gmail.com",
    "@protonmail.com"
  ]
}
```

# Actor output Schema

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

Download or inspect the saved DeviantArt results.

# 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 = {
    "sourceType": "artworkSearch",
    "targets": [
        "fantasy art"
    ],
    "maxItems": 512,
    "category": "",
    "location": "Germany",
    "emailDomains": [
        "@gmail.com",
        "@protonmail.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/deviantart-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 = {
    "sourceType": "artworkSearch",
    "targets": ["fantasy art"],
    "maxItems": 512,
    "category": "",
    "location": "Germany",
    "emailDomains": [
        "@gmail.com",
        "@protonmail.com",
    ],
}

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

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

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

```

## CLI example

```bash
echo '{
  "sourceType": "artworkSearch",
  "targets": [
    "fantasy art"
  ],
  "maxItems": 512,
  "category": "",
  "location": "Germany",
  "emailDomains": [
    "@gmail.com",
    "@protonmail.com"
  ]
}' |
apify call maximedupre/deviantart-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "DeviantArt Scraper",
        "description": "Scrape DeviantArt artwork search, gallery/profile artwork, popular pieces, and public creator emails. Export artwork URLs, titles, images, creators, dates, and contact snippets when visible.",
        "version": "0.0",
        "x-build-id": "JokxKvCKUzCgCcdUi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~deviantart-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-deviantart-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/maximedupre~deviantart-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-deviantart-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/maximedupre~deviantart-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-deviantart-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "sourceType"
                ],
                "properties": {
                    "sourceType": {
                        "title": "What to collect",
                        "enum": [
                            "artworkSearch",
                            "gallery",
                            "popular",
                            "emailLeads"
                        ],
                        "type": "string",
                        "description": "Choose the DeviantArt source for this run.",
                        "default": "artworkSearch"
                    },
                    "targets": {
                        "title": "Targets",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Use search terms, DeviantArt search URLs, profile URLs, artwork URLs, usernames, or handles.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "maxItems": {
                        "title": "Maximum rows",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Limit successful rows across the whole run.",
                        "default": 512
                    },
                    "category": {
                        "title": "Artwork category",
                        "enum": [
                            "",
                            "digitalart",
                            "traditional",
                            "photography",
                            "fanart",
                            "literature",
                            "film",
                            "designs"
                        ],
                        "type": "string",
                        "description": "Narrow artwork search or popular/trending rows by DeviantArt category.",
                        "default": ""
                    },
                    "location": {
                        "title": "Location or niche",
                        "type": "string",
                        "description": "Focus public email lead searches with a location, style, or niche."
                    },
                    "emailDomains": {
                        "title": "Email domains",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Focus public email lead rows on addresses from these domains.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```