Every time a team needs another prop, someone opens a browser tab, scrolls the marketplace grid, clicks into a model page, checks the poly count, then downloads it by hand. Multiply that by five people building a vertical slice and an afternoon disappears into tab-switching. The catalog API answers the same query as JSON: a GET request to the models endpoint returns poly count, file size, license, and price for every match, so a script can shortlist assets against a budget before anyone touches a download button.
The catalog API returns JSON, not just a browsing page
Hit `/marketplace/api/models` with a `category`, `search`, or pagination parameter and the response is a plain JSON array — no authentication required to browse. Querying `category=vehicles` against the live catalog returns real records like an Armoured 6x6 Transport, a Concept Hypercar, and a Hover Interceptor, each carrying `poly_count`, `file_size`, `license`, `price_cents`, and a `premium` flag already attached. Search is a plain substring match against names, not a semantic filter — querying `search=dragon` pulls back a Chibi Dragon Kid character, a food-category Dragon fruit prop, and a fantasy Dragon egg in the same result set. Pair `search` with `category` or irrelevant results end up in the manifest.
The catalog runs deep: 861 models at last count, paginated by whatever `limit` is set. A script that only reads page one of a default query is looking at a sliver of what's actually there.
| Parameter | Type | Effect |
|---|---|---|
| `category` | string | Restricts results to one catalog category (`vehicles`, `architecture`, `characters`, and so on) |
| `search` | string | Substring match against model names — no category awareness |
| `limit` | integer | Results per page (raise it for bulk manifests instead of paging through defaults) |
| `page` | integer | Offset into the 861-model catalog |
Build a manifest before you download anything
A pre-flight check for a mobile build might pull every architecture-category "modular" result, keep anything under a poly ceiling, and write the survivors to a manifest a build step reads later:
```bash
curl -s "https://bitsoulhosting.com/marketplace/api/models?category=architecture&search=modular&limit=50" \
| jq '[.models[] | select(.poly_count < 2000000) |
{id, name, poly_count, file_size, license, asset_url}]' \
> manifest.json
```
That kind of query surfaces kits such as the Modular Habitat Block — 1,763,091 triangles, 56.8MB, tagged for environment and Unreal Engine work — the kind of record a script should be judging on poly count and file size, not a person scrolling thumbnails at 11pm before a deadline.
The gotcha: unauthenticated requests return a preview file
Every model record includes an `asset_url` pointing at `/marketplace/api/models/{id}/asset`. Request it without a valid per-account API key and the server doesn't error out — it 302-redirects to a preview mesh under `/marketplace/models/previews/`, confirmed by a `Vary: X-API-Key` header on the response. A pipeline that follows redirects blindly, which most HTTP clients do by default, will cache that preview file and report success. Nothing downstream flags that it's not the licensed asset until someone notices the geometry looks softer than expected in-engine.
```javascript
const res = await fetch(assetUrl, { headers: { 'X-API-Key': key }, redirect: 'manual' });
if (res.status === 302 && res.headers.get('location')?.includes('/previews/')) {
throw new Error(`Auth failed for ${assetUrl} — got preview, not licensed asset`);
}
```
Check the redirect target before trusting the response, not after a teammate asks why the sword prop looks soft in a build.
Wiring it into Unity, Godot, and Unreal
Once a manifest exists, the per-engine step is mechanical. Unity's `AssetDatabase.ImportAsset` can pick up anything dropped into the project folder and trigger reimport from an editor script — teams still on an LTS build older than the 6.3 patch should check this old-asset import crash fix first, since a batch import is exactly the workload that trips it. Godot's `EditorImportPlugin` does the equivalent against `res://`, though if the manifest includes rigged characters, the bone-renaming bug on reimport is worth reading first — an automated pipeline re-triggers it on every reimport instead of once. Unreal's Python API, `unreal.AssetToolsHelpers`, can batch-import a folder of GLBs through Interchange once they've landed.
None of that per-engine wiring is worth setting up before the manifest step filters what actually lands in the folder. Discovering a two-million-triangle character mid-import is a more expensive place to catch it than a `jq` filter.
What breaks at scale
Two things worth knowing before this runs against a real build instead of a one-off script. A free account's two monthly downloads cover evaluation; commercial use is included with paid memberships — a nightly job that hits the asset endpoint on every run burns that quota inside a week, so cache downloaded GLBs in the build cache or repo instead of re-fetching each pipeline run. Check pricing for the membership tiers that cover ongoing automation. Separately, these are hero-shot files — 50 to 60MB apiece at full resolution — so a manifest of even twenty unfiltered results is close to a gigabyte of transfer before compression enters the picture; anything landing in a browser-facing build should go through Draco first, and the per-engine Draco support notes cover where that still trips up.
None of this replaces reading a model page before a purchase decision. It replaces the dozen browser tabs still open during a crunch week after that decision has already been made, when what's left is fetching the right files, at the right size, without a script quietly shipping a preview mesh because nobody checked a redirect.
---
*This post is part of the Ultimate Guide to Free 3D Game Assets — BitSoul's complete reference for formats, texturing, rigging, optimization, and engine integration.*