Skip to main content
The Create page sits at the top of the left rail in the dashboard, the first screen behind the login and the one place a mockup is made without writing a request. It takes three starting points, a Photoshop file, a product photograph or an image you generate, and each one ends as a saved template with its own UUID, shared with every member of the organization and rendering from the same balance.

​
Creating mockups

The Create page with the PSD templates panel open, listing example templates beside the upload control.
Creating and rendering both draw on the same credit balance, and the current weights are on pricing. On trial credits the result carries a watermark and a reduced width, so check the plan before you promise a size. See What you can do in the dashboard.

​
Start from a Photoshop file

Upload your own file, or open an example template to see a working mockup first. The upload reads the file and reports every slot it can address:
  • smart_objects, the design areas your artwork drops into.
  • text_layers, the copy a render can replace.
  • group_layers, the enclosing groups whose outlines a render can recolour.
Each entry carries a UUID, the handle a render names later in the browser and over HTTP alike. The same rules apply on both sides, from the colour mode to the file size the dashboard accepts: see Preparing a PSD.

​
Start from a product photo

Upload a photograph of a real product and mark where the artwork belongs. From then on it takes new artwork the way a smart object does, for as long as you keep it, with no layered file involved. A photograph carries two kinds of render target. A print area is a bounded zone you draw on the product, a chest panel or a poster face. The product stays available underneath as one surface, so the same shirt holds a logo zone and still accepts an all over print, and a render names one target per artwork. Print areas and surfaces covers how the two are addressed.

​
Start from a generated image

With no photograph yet, describe the product and the scene and generate one. Choose the product category, the aspect ratio and the style first, because those three settle the frame you will be marking afterwards. Generating spends credits the way a render does, and the library keeps the result, so one scene can be reused across a season of designs. After that it behaves like any photograph you uploaded: mark the print area, then render onto it.

​
Mark where the artwork belongs

A photograph and a generated image reach the same editor, and the marking step is identical for the two.
1

Open the prepared mockup

The editor opens the result of the upload rather than an empty canvas.
2

Drag the corners of a zone

A zone is four corner points and has to sit inside the photograph. Leave the product without zones and it still renders as a whole item.
3

Save the areas

Saving writes exactly what Replace the print areas of a photo mockup writes, and the saved order follows the photograph rather than the order you drew in.
4

Copy the request

The Code tab prints a ready to run call carrying the real mockup id and target id.

​
Find what you created

All three starting points land in one library, and a file uploaded in the browser takes its file name, so a folder of exports is worth renaming early. My mockups lists a saved template’s layers and carries the renaming and deleting.

​
Leave the browser

A template made here is renderable over HTTP a second later under the same UUID, with nothing to synchronise and nothing to register twice. The same templates and the same balance are reachable from four more surfaces:
  • SDKs for the language you already write in.
  • Integrations that make the call for you, with an official node for n8n and an app for Make.
  • Connect an agent so an MCP client renders from inside a session.
  • Plain HTTP, with a key you issue on the API keys page.

​
API reference

The two endpoints behind this page are Create a mockup from a PSD and Create a mockup from a product photo. Both take the same file and the same photograph this page takes, answer with the same UUIDs, and accept a large file in the background rather than holding the connection open.