# MakerWorld Model Scraper (`axiomworks/makerworld-models-scraper`) Actor

Get MakerWorld model metadata from search results, creator profiles or model URLs and IDs. Each row can include the title, description, image URLs, license, remix permission, creator information, tags and engagement counts. Model ID inputs use a direct detail request rather than browser discovery.

- **URL**: https://apify.com/axiomworks/makerworld-models-scraper.md
- **Developed by:** [Axiom Works](https://apify.com/axiomworks) (community)
- **Categories:** Other
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.82 / 1,000 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/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

**Returns:** one row per MakerWorld 3D model with `title`, `url`, `imageUrls`, `license`, `creatorName`, `downloadCount`, `likeCount` and `tags`.
**Input:** `{"searchTerms": ["desk organizer"], "maxItems": 50}`
**Best for:** finding popular printable models in a niche, tracking a creator's catalogue, and building model galleries with license info.

```json
{
  "modelId": 1616690,
  "title": "Mid Century Planter with built in drip tray",
  "url": "https://makerworld.com/en/models/1616690-mid-century-planter-with-built-in-drip-tray",
  "license": "Standard Digital File License",
  "creatorName": "K0nur’s Things",
  "downloadCount": 4607,
  "likeCount": 3376,
  "imageCount": 16
}
```

### What does MakerWorld Models Scraper do?

MakerWorld Models Scraper is a MakerWorld scraper that collects public 3D model listings from makerworld.com, the 3D printing model library run by Bambu Lab. Give it search keywords, MakerWorld search URLs, creator profile URLs, model URLs or plain model IDs, and it returns one structured row per model: title, full description text, cover image, gallery image URLs, print profile image URLs, tags, categories, license, remix permission, creator details and engagement counts such as likes, downloads, prints, collections and comments.

It works like an unofficial MakerWorld API for model metadata. No MakerWorld account or login is needed, and the Actor never downloads model files or images: it returns the image URLs and the license of each model, so you can decide what you are allowed to do with them.

Typical jobs it is built for:

- ranking models in a niche by `downloadCount`, `likeCount` or `printCount`
- keeping a list of a creator's published models with `creatorHandle` and `createdAt`
- building a gallery or research set from `coverUrl` and `imageUrls`, with the `license` and `allowRemix` flag next to each model

### What data can you get from MakerWorld?

Every row has the same fields. Lists are empty (`[]`) when the model has none, and a value is `null` only when MakerWorld doesn't provide it.

| Field | Description | Example |
|---|---|---|
| `id` | MakerWorld model ID as a string (same as `modelId`) | `"1616690"` |
| `modelId` | MakerWorld design ID | `1616690` |
| `url` | Link to the model page | `https://makerworld.com/en/models/1616690-mid-century-planter-with-built-in-drip-tray` |
| `title` | Model title | `Mid Century Planter with built in drip tray` |
| `description` | Full model description as plain text (HTML removed) | `Newest planter design avalible here! ...` |
| `coverUrl` | Cover image URL | `https://makerworld.bblmw.com/makerworld/model/.../2025-07-18_701fce879e7a7.jpg` |
| `imageUrls` | Gallery image URLs, in page order | `["https://makerworld.bblmw.com/..."]` |
| `realPhotoUrls` | Photos of real prints added by the creator (often empty) | `[]` |
| `profileImageUrls` | Unique images of the model's print profiles | `["https://makerworld.bblmw.com/.../instance/..."]` |
| `imageCount` | Number of image URLs returned (gallery + real photos + profile images) | `16` |
| `tags` | Tags the creator added | `["plant", "pot", "planter"]` |
| `categories` | MakerWorld categories | `["Decor", "Household"]` |
| `license` | License of the model files | `Standard Digital File License` |
| `allowRemix` | Whether the creator allows remixes | `false` |
| `creatorName` | Creator display name | `K0nur’s Things` |
| `creatorHandle` | Creator handle (after @ in the profile URL) | `K0nur` |
| `creatorId` | Creator user ID | `4094046673` |
| `creatorUrl` | Creator profile link | `https://makerworld.com/en/@K0nur` |
| `likeCount` | Likes | `3376` |
| `collectionCount` | Times saved to a collection | `15686` |
| `downloadCount` | Downloads | `4607` |
| `printCount` | Prints reported on MakerWorld | `3825` |
| `commentCount` | Comments | `283` |
| `printProfileCount` | Number of print profiles | `5` |
| `isExclusive` | MakerWorld exclusive model | `true` |
| `isStaffPicked` | Picked by MakerWorld staff | `false` |
| `createdAt` | Publication time (ISO 8601, UTC) | `2025-07-18T11:36:09Z` |
| `updatedAt` | Last update of the model record (ISO 8601, UTC) | `2026-10-05T00:25:23Z` |
| `searchTerm` | Keyword that found the model, `null` for other inputs | `planter` |
| `scrapedAt` | When the row was collected | `2026-10-05T00:31:32.990Z` |
| `sourceUrl` | Model page the row was collected for | `https://makerworld.com/en/models/1616690-...` |

### How to use MakerWorld Models Scraper

1. Open MakerWorld Models Scraper in Apify Console and go to the Input tab.
2. Add what you want to scrape: MakerWorld URLs (model pages, search result pages or creator pages, in any language version of the site), search keywords one per line (for example `desk organizer`), or model IDs (the number after `/models/` in a model URL, for example `1400373`). You can mix all three in one run.
3. Set **Maximum results** to the number of models you want across all inputs.
4. Click **Start**. Results appear in the Output tab while the run is going, and you can export them as JSON, CSV, Excel, XML or RSS, or read them through the API.

Tips:

Model URLs and model IDs are the fastest and cheapest input, because each model is read directly without opening a browser. Searches and creator pages open MakerWorld in a headless browser, read the first page of results and scroll for more until they have enough models.

MakerWorld search is semantic and always shows something, even for a keyword with no real matches. To keep results on topic, the Actor keeps a search result only when one word of your keyword appears in the model's title or tags. A keyword that matches nothing therefore returns 0 rows and a status message saying so, instead of a list of unrelated models. Keywords in other languages work too, but models whose titles and tags are only in English won't match a German or Japanese keyword.

The run stops as soon as **Maximum results** models are saved. The same model is returned only once per run, even if two inputs find it.

The default proxy (Apify Proxy, datacenter) works for MakerWorld. If MakerWorld blocks a browser session, the Actor retries on a new proxy IP automatically.

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `startUrls` | array of URLs | One of the three target fields | MakerWorld model, search or creator URLs, e.g. `https://makerworld.com/en/@Meyui/upload`. |
| `searchTerms` | array of strings | One of the three target fields | Keywords to search on MakerWorld, e.g. `desk organizer`. |
| `modelIds` | array of strings | One of the three target fields | MakerWorld model IDs, e.g. `1400373`. |
| `maxItems` | integer | No | Maximum number of models to return across all inputs, 1-5000, default 50. |
| `proxyConfiguration` | object | No | Proxy settings. Default: Apify Proxy (datacenter). |

Give at least one of `startUrls`, `searchTerms` or `modelIds`. A run with none of them ends straight away with 0 results and a status message.

```json
{
    "startUrls": [
        { "url": "https://makerworld.com/en/models/1400373-self-watering-seed-starter-with-modular-grow-kit" },
        { "url": "https://makerworld.com/en/@Meyui/upload" },
        { "url": "https://makerworld.com/en/search/models?keyword=planter" }
    ],
    "searchTerms": ["desk organizer"],
    "modelIds": ["3043752"],
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": true }
}
```

### Output

Each model is one row in the dataset. This is a real row from a search for `planter` (lists and the description shortened here):

```json
[
    {
        "id": "1616690",
        "modelId": 1616690,
        "url": "https://makerworld.com/en/models/1616690-mid-century-planter-with-built-in-drip-tray",
        "title": "Mid Century Planter with built in drip tray",
        "description": "Newest planter design avalible here! https://makerworld.com/en/models/2724679-scalloped-planter-with-built-in-drip-tray#profileId-3018885 Thank you for all the ...",
        "coverUrl": "https://makerworld.bblmw.com/makerworld/model/US72d88bc02b0c1f/design/2025-07-18_701fce879e7a7.jpg",
        "imageUrls": [
            "https://makerworld.bblmw.com/makerworld/model/US72d88bc02b0c1f/design/2025-07-18_8baef36a8a258.jpg",
            "https://makerworld.bblmw.com/makerworld/model/US72d88bc02b0c1f/design/d398c48990979feb.jpeg"
        ],
        "realPhotoUrls": [],
        "profileImageUrls": [
            "https://makerworld.bblmw.com/makerworld/model/US72d88bc02b0c1f/355576714/instance/2025-07-18_b170d81e39682.jpg",
            "https://makerworld.bblmw.com/makerworld/model/US72d88bc02b0c1f/644705136/instance/b1be347eb5acd530.jpeg"
        ],
        "imageCount": 16,
        "tags": ["plant", "pot", "mcm", "tray", "modern", "planter", "decore", "fuzzy", "render", "home", "garden", "fancy", "water"],
        "categories": ["Decor", "Household"],
        "license": "Standard Digital File License",
        "allowRemix": false,
        "creatorName": "K0nur’s Things",
        "creatorHandle": "K0nur",
        "creatorId": 4094046673,
        "creatorUrl": "https://makerworld.com/en/@K0nur",
        "likeCount": 3376,
        "collectionCount": 15686,
        "downloadCount": 4607,
        "printCount": 3825,
        "commentCount": 283,
        "printProfileCount": 5,
        "isExclusive": true,
        "isStaffPicked": false,
        "createdAt": "2025-07-18T11:36:09Z",
        "updatedAt": "2026-10-05T00:25:23Z",
        "searchTerm": "planter",
        "scrapedAt": "2026-10-05T00:31:32.990Z",
        "sourceUrl": "https://makerworld.com/en/models/1616690-mid-century-planter-with-built-in-drip-tray"
    }
]
```

The Overview table in the Output tab shows the cover image, title, link, creator, license, image count and the main counts. The "All fields" view shows every field.

A short summary of each run (inputs, models found per input, failures and the reason for an empty run) is saved as `RUN_SUMMARY` in the run's key-value store.

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

MakerWorld Models Scraper is charged per result. You pay only for the models returned, and **Maximum results** (`maxItems`) caps how many that can be, so it also caps the charge. Removed models, unrelated search hits and duplicates are never returned or charged. See the Pricing tab for the current price.

Model URLs and IDs use the least compute because no browser is started. Searches and creator pages need a browser for the list of models, so they take longer per run.

### Use with AI agents (MCP)

Connect MakerWorld Models Scraper to Claude, Cursor or any MCP client through the Apify MCP server:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/?tools=axiomworks/makerworld-models-scraper"
        }
    }
}
```

Example prompts:

1. "Find the 20 most downloaded MakerWorld models for 'desk organizer' and list their titles, licenses and download counts."
2. "Get all models published by the MakerWorld creator @Meyui and tell me which ones allow remixes."
3. "Look up MakerWorld model 1400373 and give me its gallery image URLs, tags and print profile count."

The agent sees the input fields and their descriptions, so it can pick `searchTerms`, `startUrls` or `modelIds` on its own.

### Integrations and API

Run MakerWorld Models Scraper from your own code with the Apify API. Use your Apify API token, and send it in the `Authorization` header, never in the URL.

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("axiomworks/makerworld-models-scraper").call(run_input={"searchTerms": ["desk organizer"], "maxItems": 50})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["downloadCount"], item["license"])
```

**JavaScript**

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

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('axiomworks/makerworld-models-scraper').call({ modelIds: ['1400373', '3043752'], maxItems: 10 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/axiomworks~makerworld-models-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls": [{"url": "https://makerworld.com/en/@Meyui/upload"}], "maxItems": 25}'
```

The Integrations tab connects the Actor to Make, Zapier, n8n, Google Sheets, Slack and webhooks, so new results can flow into your own tools. You can also schedule runs in Apify Console, for example to refresh download and like counts every day.

### FAQ

**Does it download model files (3MF, STL) or images?**
No. MakerWorld requires a login to download model files, and this Actor never logs in. Images are returned as URLs only; nothing is downloaded or re-hosted.

**Why did my search return fewer models than MakerWorld shows?**
MakerWorld search mixes in loosely related models. The Actor keeps only results whose title or tags contain a word from your keyword, which removes off-topic hits. Use a broader keyword, or more than one keyword, to get more rows.

**Why did a run return 0 results?**
The status message and `RUN_SUMMARY` say why: no models matched the keyword, the model ID doesn't exist (removed models return nothing), the creator handle doesn't exist, or MakerWorld kept blocking the browser after several retries on new IPs. In the last case, run it again or pick a residential proxy group in the proxy settings.

**Which URL formats are accepted?**
Model pages (`/models/<id>` with or without the slug and with any language prefix such as `/en/` or `/de/`), search pages (`/search/models?keyword=...`) and creator pages (`/@<handle>` or `/@<handle>/upload`). Plain model IDs also work in the URL list.

**How fresh is the data?**
Every row is read from MakerWorld at run time, so counts are current to the minute. `scrapedAt` records when the row was collected, and `updatedAt` shows when MakerWorld last updated the model record.

**Can I get the models of several creators or keywords in one run?**
Yes. Add several URLs, keywords and IDs; they are processed in order until `maxItems` models are saved, and duplicates are returned once.

**Is the description complete?**
Yes. `description` is the full model description with HTML tags removed and whitespace collapsed; it isn't shortened.

### Is it legal to scrape MakerWorld?

MakerWorld Models Scraper collects only data that MakerWorld shows publicly without a login: model listings and public creator names and handles. It does not access private content and does not download model files or images. Each row includes the model's `license` and `allowRemix` value so you can respect the creator's terms; the default Standard Digital File License, for example, does not allow redistributing the files.

Creator names and handles are personal data in some jurisdictions, so make sure you have a legitimate reason to process them, for example under the GDPR. Check MakerWorld's terms of use for your use case; this is not legal advice. This Actor is an independent tool and is not affiliated with, endorsed by or connected to MakerWorld or Bambu Lab.

### Feedback

Found a bug or need a field that isn't here? Open an issue on the Issues tab and we'll look at it.

# Actor input Schema

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

MakerWorld URLs to scrape: model pages (https://makerworld.com/en/models/1400373-...), search pages (https://makerworld.com/en/search/models?keyword=planter) or creator pages (https://makerworld.com/en/@Meyui/upload). Any language prefix works.

## `searchTerms` (type: `array`):

Keywords to search on MakerWorld, one per line, e.g. 'desk organizer'. Only results whose title or tags contain a keyword word are kept, so a keyword that matches nothing returns no rows.

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

MakerWorld model IDs to scrape, e.g. '1400373' (the number after /models/ in a model URL). The fastest input: no browser is needed.

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

Maximum number of models to return across all inputs, 1-5000, default 50. The run stops as soon as this many models are saved, and you are charged only for models returned.

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

Proxy for all requests, default Apify Proxy (datacenter), which works for MakerWorld. Residential proxies are optional and only worth trying if runs get blocked.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://makerworld.com/en/models/1400373-self-watering-seed-starter-with-modular-grow-kit"
    },
    {
      "url": "https://makerworld.com/en/models/3043752-module-desk-organizer"
    }
  ],
  "searchTerms": [],
  "modelIds": [],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset with one item per model, in the order found.

# 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 = {
    "startUrls": [
        {
            "url": "https://makerworld.com/en/models/1400373-self-watering-seed-starter-with-modular-grow-kit"
        },
        {
            "url": "https://makerworld.com/en/models/3043752-module-desk-organizer"
        }
    ],
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("axiomworks/makerworld-models-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 = {
    "startUrls": [
        { "url": "https://makerworld.com/en/models/1400373-self-watering-seed-starter-with-modular-grow-kit" },
        { "url": "https://makerworld.com/en/models/3043752-module-desk-organizer" },
    ],
    "maxItems": 10,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("axiomworks/makerworld-models-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 '{
  "startUrls": [
    {
      "url": "https://makerworld.com/en/models/1400373-self-watering-seed-starter-with-modular-grow-kit"
    },
    {
      "url": "https://makerworld.com/en/models/3043752-module-desk-organizer"
    }
  ],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call axiomworks/makerworld-models-scraper --silent --output-dataset

```

## MCP server setup

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