# Sketchfab 3D Model Scraper (`crawlerbros/sketchfab-scraper`) Actor

Scrape Sketchfab.com - search or browse 3D models by keyword, category, license, price and more. Get titles, authors, licenses, pricing, view/like counts, polygon counts, thumbnails and download info, no login required.

- **URL**: https://apify.com/crawlerbros/sketchfab-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Sketchfab 3D Model Scraper

Search and browse [Sketchfab.com](https://sketchfab.com) — the largest platform for publishing and finding 3D, AR, and VR content — without logging in. Get model titles, authors, license and pricing info, view/like/comment counts, polygon counts, categories, tags, thumbnails, and model page URLs. Powered directly by Sketchfab's own public search API, so results are always live and accurate.

### What this actor does

- **Five modes:** `search` (keyword), `byCategory` (taxonomy browse), `byUser` (all models by an author), `staffPicks` (Sketchfab editorial picks), `byIds` (exact model lookup)
- **Filters:** category, license type, downloadable-only, animated-only, staff-picked-only, sort order
- **Price & download detail:** optionally enriches every model with its exact price (for paid Sketchfab Store items), download count, protection status, sound/texture/material counts, PBR material type, and last-update timestamp
- **No login, no cookies, no proxy required** — all data comes from Sketchfab's public REST API
- **Empty fields are always omitted** — you only ever see fields with real data

### Output per model

| Field | Description |
|---|---|
| `modelId` | Sketchfab's 32-character model ID |
| `title`, `description` | Model name and description |
| `authorName`, `authorUsername`, `authorUrl` | Model creator |
| `licenseType`, `licenseSlug`, `licenseUrl` | License (only set for downloadable models) |
| `isFree` | `true` for downloadable/CC models, `false` for paid Sketchfab Store models |
| `priceUsd` | Exact USD price (only present for paid Store models) |
| `isDownloadable` | Whether the model can be downloaded |
| `downloadCount` | Total downloads (when price/detail enrichment is on) |
| `viewCount`, `likeCount`, `commentCount` | Engagement metrics |
| `isAnimated`, `animationCount` | Whether the model has animations |
| `isStaffPicked`, `staffPickedAt` | Sketchfab editorial staff pick status |
| `faceCount`, `vertexCount` | Polygon/mesh complexity |
| `isAgeRestricted` | Age-restriction flag |
| `isProtected` | Whether the model has extra copy protection (detail enrichment) |
| `hasSound`, `soundCount` | Whether the model has embedded sound, and how many sound clips (detail enrichment) |
| `textureCount`, `materialCount` | Number of textures / materials used by the model (detail enrichment) |
| `pbrType` | PBR material workflow, e.g. `metalness` (detail enrichment, when set) |
| `updatedAt` | Last-modified timestamp (detail enrichment) |
| `category`, `categories[]` | Sketchfab taxonomy category |
| `tags[]` | Free-text tags |
| `thumbnailUrl` | Largest available thumbnail image |
| `modelUrl`, `embedUrl` | Model viewer page / embeddable iframe URL |
| `publishedAt`, `createdAt` | Timestamps |
| `sourceUrl` | Canonical model page URL |
| `recordType`, `scrapedAt` | Always `"model"` and the scrape timestamp |

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | select | `search` | `search` / `byCategory` / `byUser` / `staffPicks` / `byIds` |
| `searchQuery` | string | `dragon` | Keyword(s) (mode=`search`) |
| `category` | select | – | One of Sketchfab's 18 taxonomy categories |
| `username` | string | – | Exact Sketchfab username (mode=`byUser`) |
| `modelIds` | array | – | Exact 32-char model IDs (mode=`byIds`) |
| `licenseType` | select | – | CC Attribution, CC0, Editorial, etc. |
| `sortBy` | select | `relevance` | `relevance` / `likes` / `views` / `recent` |
| `downloadableOnly` | boolean | `false` | Only downloadable models |
| `animatedOnly` | boolean | `false` | Only models with animation |
| `staffPickedOnly` | boolean | `false` | Only staff-picked models |
| `riggedOnly` | boolean | `false` | Only models with a rig (skeleton), ready for animation/posing |
| `minFaceCount` | integer | – | Only models with at least this many polygon faces |
| `maxFaceCount` | integer | – | Only models with at most this many polygon faces (good for finding low-poly/lightweight models) |
| `fetchPricing` | boolean | `true` | Fetch exact price/download-count/protection status per model (1 extra request/model) |
| `maxItems` | integer | `30` | Maximum models to return (1–500) |

#### Example: keyword search

```json
{ "mode": "search", "searchQuery": "dragon", "maxItems": 30 }
```

#### Example: browse a category, downloadable + CC0 only

```json
{
  "mode": "byCategory",
  "category": "cars-vehicles",
  "downloadableOnly": true,
  "licenseType": "cc0",
  "maxItems": 50
}
```

#### Example: everything by one author

```json
{ "mode": "byUser", "username": "stanislavpotlov", "maxItems": 100 }
```

#### Example: exact model lookup

```json
{ "mode": "byIds", "modelIds": ["14ec4c0460c64065af1c6fd31f104344"] }
```

### Use cases

- **Game & VR/AR development** — discover free CC-licensed assets for prototyping
- **3D asset marketplaces** — track pricing and popularity of Sketchfab Store items
- **Content research** — analyze category trends, tag usage, or staff-pick criteria
- **Creator analytics** — monitor an author's full portfolio and engagement over time
- **Digital heritage / education** — pull cultural-heritage and science models by category

### FAQ

**Do I need a Sketchfab account or API key?** No. This actor uses Sketchfab's public search API, which returns full model metadata without any authentication.

**What does `isFree` mean?** Downloadable models on Sketchfab are always released under a Creative Commons license and are free to use under that license's terms. `isFree: false` with a `priceUsd` means the model is a paid Sketchfab Store item (view-only preview, purchase required to download). Some models are simply "Standard" license (view-only, not for sale, not downloadable) — for those, neither `isFree` nor `priceUsd` is set because Sketchfab does not publish a definitive free/paid signal for that state.

**Why do I need `fetchPricing` for prices?** Sketchfab's search results endpoint doesn't include price/download-count data — only each model's individual detail endpoint does. Turning `fetchPricing` off skips this extra per-model request for faster runs when you only need search-listing fields.

**What are the valid category slugs?** The 18 top-level categories Sketchfab exposes: Animals & Pets, Architecture, Art & Abstract, Cars & Vehicles, Characters & Creatures, Cultural Heritage & History, Electronics & Gadgets, Fashion & Style, Food & Drink, Furniture & Home, Music, Nature & Plants, News & Politics, People, Places & Travel, Science & Technology, Sports & Fitness, Weapons & Military.

**Does this include Sketchfab's paid Store catalog?** Yes — Store items appear in search/category/user results like any other model; if `fetchPricing` is on, their price is included.

**How much data can I get in one run?** Up to 500 models per run. Sketchfab paginates at 24 results per request; the actor automatically follows pagination until `maxItems` is reached or results are exhausted.

**Is polygon/vertex count always available?** Yes for regular models — `faceCount`/`vertexCount` are part of Sketchfab's own metadata and are populated whenever the model has finished processing.

# Actor input Schema

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

search = keyword text search (default). byCategory = browse a taxonomy category. byUser = list all models by an author's username. staffPicks = Sketchfab editorial staff picks. byIds = look up exact models by their Sketchfab model ID (the 32-char hex code in the model URL).

## `searchQuery` (type: `string`):

Keyword(s) to search for, e.g. 'dragon', 'low poly car', 'medieval castle'. Required when mode=search.

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

Restrict results to a Sketchfab taxonomy category. Combine with searchQuery in mode=search, or use alone in mode=byCategory.

## `username` (type: `string`):

Exact Sketchfab username to list models for (from a profile URL like sketchfab.com/<username>). Required when mode=byUser.

## `modelIds` (type: `array`):

Exact Sketchfab model IDs to look up (the code at the end of a model's URL -- either the modern 32-character hex ID, e.g. 14ec4c0460c64065af1c6fd31f104344, or the legacy 27-character case-sensitive ID used by older models, e.g. hliAt7xc6YU2XjXh5G4lzmQwFmR). Required when mode=byIds.

## `licenseType` (type: `string`):

Only return models under this license. Only CC-licensed models are downloadable on Sketchfab.

## `sortBy` (type: `string`):

Result order. Not applicable to mode=byIds.

## `downloadableOnly` (type: `boolean`):

Only return models that can be downloaded (always free, CC-licensed).

## `animatedOnly` (type: `boolean`):

Only return models that contain at least one animation.

## `staffPickedOnly` (type: `boolean`):

Only return models that were featured as a Sketchfab staff pick. Always on for mode=staffPicks.

## `riggedOnly` (type: `boolean`):

Only return models with a rig (skeleton), ready for animation/posing. Not applicable to mode=byIds.

## `minFaceCount` (type: `integer`):

Only return models with at least this many polygon faces (see the output `faceCount` field). Useful for finding higher-detail models.

## `maxFaceCount` (type: `integer`):

Only return models with at most this many polygon faces. Useful for finding lightweight/low-poly models suitable for real-time rendering or games.

## `fetchPricing` (type: `boolean`):

Fetch each model's detail page to populate exact price (for paid Sketchfab Store models), download count, and protection status. Adds one extra request per model. Turn off for faster runs when pricing detail isn't needed.

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

Maximum number of models to return.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "dragon",
  "category": "",
  "modelIds": [],
  "licenseType": "",
  "sortBy": "relevance",
  "downloadableOnly": false,
  "animatedOnly": false,
  "staffPickedOnly": false,
  "riggedOnly": false,
  "fetchPricing": true,
  "maxItems": 30
}
```

# Actor output Schema

## `models` (type: `string`):

Dataset containing all scraped Sketchfab 3D models.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "mode": "search",
    "searchQuery": "dragon",
    "modelIds": [],
    "sortBy": "relevance",
    "downloadableOnly": false,
    "animatedOnly": false,
    "staffPickedOnly": false,
    "riggedOnly": false,
    "fetchPricing": true,
    "maxItems": 30
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "mode": "search",
    "searchQuery": "dragon",
    "modelIds": [],
    "sortBy": "relevance",
    "downloadableOnly": False,
    "animatedOnly": False,
    "staffPickedOnly": False,
    "riggedOnly": False,
    "fetchPricing": True,
    "maxItems": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/sketchfab-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 '{
  "mode": "search",
  "searchQuery": "dragon",
  "modelIds": [],
  "sortBy": "relevance",
  "downloadableOnly": false,
  "animatedOnly": false,
  "staffPickedOnly": false,
  "riggedOnly": false,
  "fetchPricing": true,
  "maxItems": 30
}' |
apify call crawlerbros/sketchfab-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/TKwUS31DqCRvG6wpZ/builds/mb309nU1IYBi8XX2C/openapi.json