Reference

API

Stronghold holds fonts, gradients, palettes, icons, textures, HDRIs, models, packs, patterns, audio, shaders, curves and LUTs. The API exists so they can leave the browser — converted into the formats your actual tools read, or bundled as one archive.

OpenAPI 3.1 spec Format catalog

Recipes

Find assets

curl 'https://stronghold.manganum.com/api/palettes?q=sunset&limit=5'

Every list endpoint takes q, page and limit. Icons, palettes, shaders and patterns also take sort=random with a stable seed.

A palette for Illustrator

curl -OJ 'https://stronghold.manganum.com/api/export/palettes/<id>?format=ase'

-OJ keeps the filename the server sends. Double-click the .ase to load it as a colour group.

A whole icon set as one sprite

curl -OJ 'https://stronghold.manganum.com/api/export/icons?format=bundle&iconSet=lucide&limit=500'

Gives you sprite.svg, a CSS mask sheet, an Iconify collection and every individual SVG.

Selected icons as React components

curl -OJ -X POST 'https://stronghold.manganum.com/api/export/icons' \
  -H 'content-type: application/json' \
  -d '{"format":"react","ids":["<id>","<id>"]}'

POST when the id list would overflow a URL. Up to 2000 ids per request.

A gradient as a colour-grading LUT

curl -OJ 'https://stronghold.manganum.com/api/export/gradients/<id>?format=cube'

A 33³ 3D LUT mapping input luma onto the gradient. Load it in Resolve, Premiere, Final Cut or OBS.

A complete font family

curl -OJ 'https://stronghold.manganum.com/api/export/fonts/<id>?format=zip'

Every weight, @font-face CSS pointing at the bundled files, and a specimen page you can open offline.

A mixed selection as a style kit

curl -OJ -X POST 'https://stronghold.manganum.com/api/export/kit' \
  -H 'content-type: application/json' \
  -d '{"name":"Landing page","items":[
    {"type":"fonts","id":"<id>"},
    {"type":"palettes","id":"<id>"},
    {"type":"gradients","id":"<id>"}
  ]}'

One archive with each asset in its native format, plus a combined kit.css and an index.html overview.

Use a font on any web page

<link rel="stylesheet" href="https://stronghold.manganum.com/api/fonts/css?ids=<id>">
<style>body { font-family: 'Family Name', sans-serif; }</style>

Ready-made @font-face rules; the font files answer any origin, so this works from any site.

A PBR material straight into Blender

curl -OJ 'https://stronghold.manganum.com/api/export/textures/<id>?format=blender&resolution=4k'
blender --python <the downloaded script>.py

The script fetches the maps from the source CDN and builds the node tree. three.js, Godot and Unity forms exist too — and `&dry=1` on any export URL validates without downloading.

Scripted access with an API key

curl 'https://stronghold.manganum.com/api/collections' \
  -H 'X-API-Key: ak_...' \
  -H 'X-Stronghold-User: <user uuid>'

An Alexandria key scoped to the stronghold app. The user header is only needed for per-user routes. Keys never grant admin.

Browsing

Endpoint	Notes
`GET /api/fonts`	`q`, `category`, `page`, `limit`
`GET /api/gradients`	`q`, `type`, `source`
`GET /api/palettes`	`q`, `source`, `colors`, `sort`, `seed`
`GET /api/icons`	`q`, `set`, `sort`, `seed`
`GET /api/shaders`	`q`, `source`, `type`, `language`, `sort`
`GET /api/patterns`	`q`, `type`, `tile`, `source`, `sort` (incl. `tile-asc`)
`GET /api/assets`	Counts of every type; with `?type=`, a page of the eight types that have no endpoint of their own
`GET /api/assets/{id}`	One asset, whichever type it belongs to
`GET /api/fonts/css?ids=`	`@font-face` rules, or an `@import` for Google-hosted families
`POST /api/upload`	Multipart image or font, private to you; the bytes decide the type
`GET /api/collections`	Requires a caller identity
`POST /api/collections/{id}`	One `{ assetType, assetId }`, or an `items` array of up to 200
`GET /api/collections/{id}/export`	The whole collection as one style kit

Responses are { items, total, page, limit, pages }. limit is capped at 100. sort=random is seeded, so paging a shuffled list never repeats or skips an item — pass back the seed from filters to keep the same shuffle.

Exporting

Endpoint	Notes
`GET /api/export/formats`	The catalog. Read this instead of hard-coding format ids.
`GET /api/export/{type}/{id}?format=`	One asset
`GET /api/export/{type}?format=&ids=`	Several assets merged into one file
`GET /api/export/icons?format=&iconSet=`	A whole icon set, without listing ids
`POST /api/export/{type}`	Same as GET, for id lists too long for a URL
`POST /api/export/kit`	A mixed selection as one style-kit archive
`GET /api/collections/{id}/export`	A saved collection as a style kit

Raster and sampling parameters: width and height for PNG targets, steps when a gradient is reduced to discrete swatches. At most 2000 assets per request. Formats marked batch below can merge a selection; the rest handle one asset at a time.

Formats

Palettes

Design tools

format	file	what it is	reads it	batch
`ase`	.ase	Swatch group for the Adobe apps	Illustrator, Photoshop, InDesign, Affinity	yes
`aco`	.aco	Named swatches for the Swatches panel	Photoshop	yes
`act`	.act	Indexed-colour table, capped at 256 entries	Photoshop, GIF pipelines	yes
`gpl`	.gpl	Drop into the palettes folder	GIMP, Inkscape, Krita, MyPaint	yes
`pal`	.pal	Classic pixel-art palette format	Paint Shop Pro, Aseprite, GrafX2	yes
`soc`	.soc	Custom colour table for the Office suite	LibreOffice, OpenOffice	yes
`sketchpalette`	.sketchpalette	For the Sketch Palettes plugin	Sketch	yes
`procreate`	.swatches	Splits into palettes of 30, the Procreate limit	Procreate	yes

Code

format	file	what it is	reads it	batch
`css`	.css	Custom properties plus an all-stops list	—	yes
`scss`	.scss	Variables plus a Sass map	—	yes
`tailwind`	.js	theme.extend.colors block	Tailwind CSS 3	yes
`tailwind4`	.css	@theme block with --color-* tokens	Tailwind CSS 4	yes
`tokens`	.json	W3C design-tokens draft format	Tokens Studio, Style Dictionary	yes
`swift`	.swift	Color extension	Xcode	yes
`kotlin`	.kt	Jetpack Compose Color values	Android Studio	yes

Image

format	file	what it is	reads it	batch
`svg`	.svg	Labelled grid, for presentations	—	—
`png`	.png	Proportional bands, no text	—	—

Data

format	file	what it is	reads it	batch
`json`	.json	Hex, RGB, HSB and Lab for every colour	—	yes
`txt`	.txt	One hex value per line	—	yes

Gradients

Design tools

format	file	what it is	reads it	batch
`ggr`	.ggr	Segment-based, keeps midpoints and alpha	GIMP, Inkscape, Krita	—
`ase`	.ase	Sampled into discrete swatches	Illustrator, Photoshop	yes
`gpl`	.gpl	Sampled into 16 swatches	GIMP, Krita	yes
`cube`	.cube	3D LUT mapping luma onto the gradient	DaVinci Resolve, Premiere, Final Cut, OBS	—

Code

format	file	what it is	reads it	batch
`css`	.css	Custom property plus a utility class	—	yes
`tailwind`	.css	v4 @theme entry, with the v3 config in a comment	Tailwind CSS	yes
`blender`	.py	Script that builds the node, in linear colour	Blender	—
`swiftui`	.swift	Gradient stops plus the matching shape	Xcode	—
`glsl`	.glsl	vec3 ramp(float t) for shaders	Shadertoy, TouchDesigner, WebGL	—
`android`	.xml	Shape drawable with start/center/end	Android Studio	—

Image

format	file	what it is	reads it	batch
`svg`	.svg	Vector gradient, editable after import	Figma, Illustrator, Inkscape	—
`png`	.png	Rendered raster, exact at both ends	—	—

Data

format	file	what it is	reads it	batch
`json`	.json	Stops, angle, interpolation space and CSS	—	yes

Icons

Code

format	file	what it is	reads it	batch
`datauri`	.txt	Percent-encoded, for CSS url()	—	—
`datauri-base64`	.txt	For tools that reject percent-encoding	—	—
`css`	.css	One class per icon, recoloured by currentColor	—	yes
`css-bg`	.css	Keeps the icon’s own colours, for logos	—	yes
`react`	.zip	One .tsx per icon plus a barrel index	React, Next.js	yes
`svelte`	.zip	One .svelte per icon plus a barrel index	Svelte 5	yes
`vue`	.zip	One SFC per icon plus a barrel index	Vue 3, Nuxt	yes

Image

format	file	what it is	reads it	batch
`svg`	.svg	Single normalized icon	Figma, Illustrator, Sketch	—

Bundles

format	file	what it is	reads it	batch
`sprite`	.svg	<symbol> sheet for <use href="#id">	—	yes
`zip`	.zip	Individual files, grouped by set	—	yes
`bundle`	.zip	Sprite, CSS, Iconify JSON and every SVG	—	yes

Data

format	file	what it is	reads it	batch
`iconify`	.json	Collection JSON with shared dimensions	Iconify, unplugin-icons, Figma Iconify	yes

Fonts

Code

format	file	what it is	reads it	batch
`css`	.css	Points at this server; @import for Google families	—	yes

Bundles

format	file	what it is	reads it	batch
`zip`	.zip	Every weight, @font-face CSS and a specimen	—	yes
`specimen`	.html	Self-contained weights and sizes preview	—	—

Data

format	file	what it is	reads it	batch
`json`	.json	Metadata, weights, axes and file list	—	yes

Shaders

Design tools

format	file	what it is	reads it	batch
`isf`	.fs	Interactive Shader Format with a JSON header	VDMX, Resolume, CoGe, Millumin	—

Code

format	file	what it is	reads it	batch
`frag`	.frag	Stored code with a provenance header	—	—
`standalone`	.frag	Uniform block and a real main()	glslViewer, Bonzomatic, WebGL	—
`shadertoy`	.glsl	Paste-ready; host uniforms stripped	Shadertoy	—

Bundles

format	file	what it is	reads it	batch
`html`	.html	WebGL harness with no dependencies	—	—
`zip`	.zip	Every host format plus a preview page	—	—

Data

format	file	what it is	reads it	batch
`json`	.json	Code plus declared uniforms	—	yes

patterns

Code

format	file	what it is	reads it	batch
`css`	.css	Tile inlined as a data URI, recoloured by currentColor	—	yes
`tailwind`	.css	v4 @theme background-image entry	Tailwind CSS	yes

Image

format	file	what it is	reads it	batch
`svg`	.svg	Real <pattern> element, so it stays a repeat after import	Figma, Illustrator, Inkscape	—
`tile`	.svg	One tile at its natural size, to build a pattern fill from	Figma, Illustrator, Sketch	—

Bundles

format	file	what it is	reads it	batch
`sheet`	.html	Every pattern tiling, with a colour picker	—	yes
`zip`	.zip	Tiles, tiling SVGs, CSS and a review sheet	—	yes

Data

format	file	what it is	reads it	batch
`json`	.json	Tile size, markup and ready-made CSS	—	yes

curves

Design tools

format	file	what it is	reads it	batch
`blender`	.py	Script that sets the keyframe Bezier handles	Blender	—
`aftereffects`	.jsx	Evaluates the real curve; AE influences cannot	After Effects	—

Code

format	file	what it is	reads it	batch
`css`	.css	Custom property, or @keyframes for a spring	—	yes
`tailwind`	.css	@theme --ease-* token	Tailwind CSS	yes
`js`	.ts	Standalone easing function, no dependencies	—	—
`swiftui`	.swift	timingCurve, or an exact interpolatingSpring	Xcode	—
`flutter`	.dart	Cubic, or an exact SpringDescription	Flutter	—
`unity`	.cs	Keyframe tangents derived from the control handles	Unity	—
`glsl`	.glsl	Shader-friendly, fixed iteration count	Shadertoy, TouchDesigner, WebGL	—

Image

format	file	what it is	reads it	batch
`svg`	.svg	The curve drawn in its unit box, for docs	—	—

Bundles

format	file	what it is	reads it	batch
`sheet`	.html	Every selected curve plotted side by side	—	yes
`zip`	.zip	Every dialect plus a plot and a readme	—	—

Data

format	file	what it is	reads it	batch
`json`	.json	Definition, CSS value and sampled points	—	yes
`csv`	.csv	64 x,y pairs for spreadsheets and scripts	—	—

textures

Design tools

format	file	what it is	reads it	batch
`blender`	.py	Builds the node graph, with correct colour spaces	Blender	—

Code

format	file	what it is	reads it	batch
`three`	.js	MeshStandardMaterial with the maps loaded	three.js	—
`godot`	.tres	StandardMaterial3D resource	Godot 4	—
`unity`	.cs	Editor script that sets import settings too	Unity	—

Bundles

format	file	what it is	reads it	batch
`download`	.sh	curl with resume and checksum verification	—	yes
`zip`	.zip	Every engine, the download script and a readme	—	—

Data

format	file	what it is	reads it	batch
`markdown`	.md	Maps, sizes, colour spaces and credits	—	—
`json`	.json	Canonical map names and download URLs	—	yes

luts

Design tools

format	file	what it is	reads it	batch
`cube`	.cube	33³ by default; verified in ffmpeg, and what every NLE reads	DaVinci Resolve, Premiere, Final Cut, OBS, ffmpeg	—

Image

format	file	what it is	reads it	batch
`hald`	.png	512×512 image describing a 64³ cube	ffmpeg, ImageMagick	—
`preview`	.png	Reference image, ungraded above and graded below	—	—

Bundles

format	file	what it is	reads it	batch
`sheet`	.html	Every selected LUT applied to the same inputs	—	yes
`zip`	.zip	Cube, 3DL, Hald, preview, recipe and a readme	—	—

Data

format	file	what it is	reads it	batch
`json`	.json	The operation stack, for computing the cube yourself	—	yes

hdris

Design tools

format	file	what it is	reads it	batch
`blender`	.py	World node graph with rotation and strength exposed	Blender	—

Code

format	file	what it is	reads it	batch
`three`	.js	Right loader, equirectangular mapping, scene.environment	three.js	—
`godot`	.tres	Environment with a panorama sky, lighting and reflections on	Godot 4	—
`unity`	.cs	Editor script: import settings, skybox material, ambient source	Unity	—

Bundles

format	file	what it is	reads it	batch
`download`	.sh	curl with resume and checksum verification	—	yes
`zip`	.zip	Every engine, the download script and a readme	—	—

Data

format	file	what it is	reads it	batch
`markdown`	.md	Resolutions, dynamic range, white balance and credits	—	—
`json`	.json	Every resolution and format, with download URLs	—	yes

models

Design tools

format	file	what it is	reads it	batch
`blender`	.py	Right operator per format; .blend is appended, not imported	Blender	—

Code

format	file	what it is	reads it	batch
`three`	.js	GLTFLoader, added to the scene, shadows enabled	three.js	—
`godot`	.tscn	Node3D with the imported model instanced under it	Godot 4	—
`unity`	.cs	Editor script: FBX scale, normal maps, URP material	Unity	—

Bundles

format	file	what it is	reads it	batch
`download`	.sh	Rebuilds the exact file tree the model references	—	yes
`zip`	.zip	Every engine, the download script and a readme	—	—

Data

format	file	what it is	reads it	batch
`markdown`	.md	Formats, polycount, real-world size and the file list	—	—
`json`	.json	Every format and resolution, with relative paths	—	yes

packs

Design tools

format	file	what it is	reads it	batch
`blender`	.py	3D kits: imports every model, laid out in a grid	Blender	—

Code

format	file	what it is	reads it	batch
`unity`	.cs	Fixes scale, point filtering and colour space across the pack	Unity	—
`three`	.js	3D kits: load a piece by name, cloned and cached	three.js	—

Bundles

format	file	what it is	reads it	batch
`download`	.sh	Fetches, unpacks, and prints an inventory of what arrived	—	yes
`zip`	.zip	Everything that applies to this pack, plus a readme	—	—

Data

format	file	what it is	reads it	batch
`markdown`	.md	Contents, layout and what to watch for per category	—	—
`json`	.json	Metadata and the archive URL	—	yes

audio

Bundles

format	file	what it is	reads it	batch
`download`	.sh	curl with resume, and writes the credits beside the files	—	yes
`convert`	.sh	Mono OGG and WAV at 44.1 kHz, which is what engines want	ffmpeg, Unity, Godot	yes
`zip`	.zip	Credits, scripts, playlist and manifest — no audio	—	yes

Data

format	file	what it is	reads it	batch
`credits`	.md	Title, creator, licence and source per track — what CC-BY requires	—	yes
`attribution`	.txt	One line per track, for a credits screen or a video description	—	yes
`m3u`	.m3u	Streams from the source; titles are the credit lines	VLC	yes
`json`	.json	Metadata, stream URLs and the composed credit line	—	yes

Integrating

The read surface is built to be consumed by other software — editors, engines, build steps, plugins, agents. Three properties make that dependable:

Open to any origin: Every public read — listings, single assets, files, exports, this spec — answers cross-origin requests with an uncredentialed Access-Control-Allow-Origin: *, so a browser-based tool calls the API directly from its own origin. A cross-origin caller is always anonymous; per-user routes and every write stay same-origin.
Validate before downloading: Any export URL plus &dry=1 runs the full server-side validation and answers 204 — or the readable error — without the body. Use it before handing a URL to a download manager, or to check a model really has the FBX its Unity export needs.
Machine-readable everything: The OpenAPI 3.1 description and the format catalogue are generated from the same definitions the endpoints use, and contract tests hold them together. Format ids and response shapes are stable; new ones are added without renaming existing ones.
MCP for agents: POST /api/mcp speaks the Model Context Protocol: search_assets, get_asset, list_export_formats, export_asset, list_collections, export_collection. Text exports come back inline; binaries as a download link. Anonymous callers search and export the public library; an API key adds collections.

Authentication

Browsing is public. Anything belonging to a user — collections, favourites — needs a caller identity. Three credentials work:

Session cookie: Alexandria SSO. Sign in at /login; the jwt cookie is verified locally against Alexandria's JWKS. Access also requires an assignment to the stronghold app.
API key: An Alexandria ak_… key scoped to stronghold, for scripts, CI and MCP clients. Send it as X-API-Key or Authorization: Bearer ak_…. Add X-Stronghold-User: <uuid> for per-user routes. An API key never grants admin, so scraper control stays session-only.
Alexandria JWT: Your own Alexandria JWT as Authorization: Bearer <jwt>, for a service acting on behalf of a signed-in user. It is scoped exactly like the cookie.

A key that is present but invalid returns 401 rather than falling back to anonymous access, so a broken credential surfaces instead of quietly degrading.

Uploading

Two shelves accept your own files: Images and Fonts. Both need a caller identity. A session cookie always has one. An API key only does where the deployment enables X-Stronghold-User; otherwise POST /api/upload answers 401, because an upload has to belong to somebody.

Everything else — textures, HDRIs, models, packs, palettes, gradients, icons, shaders, patterns, curves, LUTs, audio — is either scraped from a source with a stated licence or generated here (the cosine gradients, the easing curves, the generated patterns and LUTs). Neither has an upload path, and that is deliberate: every row in the public library has a licence someone can point at. A licence you type on the upload form is recorded as given — trimmed, never checked and never guessed — which is why an upload stays private to you instead of joining that library. Leave the field empty and it is recorded as Unknown (uploaded).

Limits: 25 MB per image, 8 MB per font file, 250 MB and 200 font files per account. The declared content type is ignored; the leading bytes decide what a file is, and an SVG is sanitised before it is stored.
No detail page: Images is deliberately a flat shelf: a plain image has no maps, weights, stops or code to inspect, so there is no /images/{id} route the way every other shelf has one. The card shows the file's dimensions and format, and the API serves the full record at /api/assets/{id}.
Visibility: Uploads are private, and /api/files/uploads/… serves them only to their owner. They appear on your shelves and can go into collections. An uploaded font exports like any other — a style kit carries its files and @font-face rules. An uploaded image does not: plain images have no export format, so one sits in a collection without adding anything to the kit.

Licensing

Assets carry their own licenses, and the API reports them per asset. Font bundles and icon bundles include the license text in their README.md. Check it before shipping: it governs embedding, modification and redistribution, and it varies from CC0 to non-commercial-only across the sources.