canonical: https://jentic.com/apis/creatica.app/creatica

# Creatica App Creatica Backgrounds API

The Creatica Backgrounds API generates deterministic procedural SVG and PNG backgrounds on demand from 59 structure generators and curated palettes. The same structure, options, and seed always render the same image, and each structure publishes a machine-readable parameter schema and a style card so a caller can build a valid generate request. It also ranks structures for a natural-language brief and serves cacheable image URLs with width, seed, and colour options.

## For AI agents

Generate deterministic procedural SVG and PNG backgrounds from 59 structures and curated palettes, read each structure's parameter schema, and rank structures for a brief. An optional bearer token authenticates calls across 9 operations.

## Scope

Does not handle photo editing, raster upload transforms, or text-to-photo generation. Use for rendering deterministic procedural SVG and PNG backgrounds only.

## Capabilities

- List the 59 background structures and read each one's parameter schema
- Browse built-in palettes with mood tags
- Rank structures for a natural-language brief with the suggest endpoint
- Render a deterministic SVG or PNG background from a structure, seed, and colours
- Serve a cacheable image URL with width, seed, and colour options

## Use cases

### On-Demand Background Generation

A design tool renders a background for a card or hero section on demand. The agent picks a structure, reads its parameter schema, and calls generate with a seed and colours, getting back a deterministic SVG or PNG that renders identically on every repeat so layouts stay stable.

Example prompt: Call GET `/v1/backgrounds/{name}/schema` to read the parameters, then POST `/v1/generate` with a seed and colours

### Brief-Driven Structure Selection

Given a short natural-language brief, an agent asks the suggest endpoint to rank the available structures and pairs the top match with a palette whose mood tags fit. It then renders the chosen structure, turning a plain description into a usable background without a human picking from the catalogue.

Example prompt: Call GET `/v1/suggest` with the brief, read GET `/v1/palettes` for a matching palette, then POST `/v1/generate`

### AI Agent Integration via Jentic

An AI agent reaches the Creatica Backgrounds API through Jentic and discovers the right structure by intent. It receives the generate operation and its input schema, supplies a seed and colours, and executes with the optional token injected at run time, embedding the returned image URL directly in its output.

Example prompt: Search Jentic for 'render a procedural background', load the POST `/v1/generate` schema, and execute it with Jentic-managed credentials

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/v1/backgrounds` | List structures |
| GET | `/v1/backgrounds/{name}` | Describe a structure |
| GET | `/v1/backgrounds/{name}/schema` | JSON Schema of a generate request |
| GET | `/v1/palettes` | Built-in palettes with mood tags |
| GET | `/v1/suggest` | Rank structures for a natural-language brief |
| POST | `/v1/generate` | Render a background |
| GET | `/v1/render/{file}` | Fetch a cacheable rendered image |

## Key resources

- **Backgrounds** — List structures and read each one's description and parameter schema
- **Palettes** — Browse built-in palettes with mood tags via `/v1/palettes`
- **Generate and Render** — Render a background and fetch a cacheable image URL via `/v1/generate` and `/v1/render`

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 41 / 100
- **Maturity:** Foundational
- **Dimensions:**
  - Foundational Compliance: 100 / 100
  - Developer Experience & Jentic Compatibility: 58 / 100
  - AI-Readiness & Agent Experience: 18 / 100
  - Agent Usability: 94 / 100
  - Security: 60 / 100
  - AI Discoverability: 51 / 100
- **View full report:** https://jentic.com/apis/creatica.app/creatica/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring Creatica by hand means handling its optional bearer token, reading each structure's parameter schema, and assembling seed and colour options for every render yourself. Through Jentic you install once, import Creatica from the API Directory, store any token once, and your agent calls it.
- **Permission scoping:** Most operations are read-only catalogue and schema lookups, so a rule can allow those plus the single generate call the agent needs. You choose the operation set, so it renders backgrounds and reads structures without reaching anything else.
- **Credential handling:** Any Creatica token is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'render a procedural background' or 'suggest a structure for a brief', and Jentic returns the matching Creatica operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Stability AI** — Diffusion image generation from text prompts
- **Leonardo AI** — Generative image creation with style controls
- **fal** — Hosted inference for running image models

## FAQ

### What authentication does the Creatica Backgrounds API use?

The Creatica Backgrounds API declares a bearer token scheme in its OpenAPI spec, and calls may be made with or without it depending on the structure and plan. Through Jentic any token is stored encrypted by your own Jentic One instance and injected at execution time, so it never enters the agent's context.

### Are the generated backgrounds reproducible with the Creatica Backgrounds API?

Yes. The same structure, options, and seed always render the same image, so an agent can regenerate an identical background later from the same inputs. Each structure also publishes a parameter schema so the agent can build a valid generate request.

### Can I pick a background from a text description with the Creatica Backgrounds API?

Yes. The suggest endpoint ranks the available structures for a natural-language brief, and the palettes endpoint returns built-in palettes with mood tags to match. The agent can then render the top-ranked structure with a chosen palette.

### How do I render a background through Jentic with the Creatica Backgrounds API?

Search Jentic for 'render a procedural background', and it returns the Creatica generate operation with its input schema. Load the schema and execute POST `/v1/generate` with a seed and colours. To run it on your own infrastructure, install Jentic One from its GitHub repo.

### Can I limit what my agent is allowed to do with the Creatica Backgrounds API?

Yes. Most operations are read-only catalogue and schema lookups, so a rule can allow just those plus the generate call the agent needs. You choose the operations it may use, so it renders backgrounds and reads structures and nothing more. Each call runs through your own instance and is logged.