Gelato Mockup Generator: How It Works, Limits, and API Options

Gelato's mockup generator lives inside your Gelato dashboard: you pick a Gelato product, place your design, choose a scene and push the result to your store listing. Basic product mockups come with every plan, but the 800+ premium mockups, Magic Mockups (AI) and high-resolution mockup downloads are Gelato+ features, downloads top out at 3,000 x 3,000 px, and the Gelato API gives you product preview URLs rather than a general mockup renderer.

Those limits show when you want your own branded photography, the same look across hundreds of designs, or images bigger than 3,000 px. Below is what each Gelato tool does, what it costs, what the API really returns, and where rendering your own PSD by API is the better fit.

Gelato has four different things people call "the Gelato mockup generator". They are not the same, and the plan rules differ.

Two things to know before you plan around these tools. First, Gelato's own pages do not fully agree: the marketing page shows Mockup Studio for "apparel to mugs, wall art and phone cases", while the help center (last updated October 30, 2025) says it is designed for wall art. Check your dashboard before you build a workflow on it. Second, Magic Mockups generates the product and the background together with AI, so it is a scene idea tool, not a pixel-exact render of your print file.

Gelato's subscription page lists three plans on September 30, 2026:

• Free: $0. Includes "free product mockups".
• Gelato+: $29.99 per month, or $19.99 per month billed yearly (support.gelato.com, read 4 October 2026). Adds the 800+ premium mockups and Magic Mockups.
• Platinum: custom pricing, same mockup access as Gelato+.

Downloading mockup files is also tied to the plan. Gelato's help center says: "With a Gelato+ subscription, you unlock the ability to download stunning, high-resolution mockups of your products." The same article sets the ceiling: "Our mockups are available at a maximum resolution of 3000x3000 pixels", in PNG, WebP or JPG.

There are platform rules on top of that, straight from the same article:

• Etsy: the article says WebP and PNG are not supported and "Etsy allows 10 mockups per listing". Etsy itself accepts JPG, GIF and PNG listing photos (Etsy's announcement) and up to 20 photos per listing (Listing a Physical Item), both read on 7 October 2026.
• WooCommerce, Wix, Squarespace and BigCommerce: mockups can only be downloaded during product creation.
• Products that contain Shutterstock elements: mockup download is unavailable.

Not in the sense most developers mean. Gelato's API has separate services for orders, products, shipment and ecommerce (order.gelatoapis.com, product.gelatoapis.com, shipment.gelatoapis.com, ecommerce.gelatoapis.com), all authenticated with an X-API-KEY header. The Product API returns catalog metadata, not images.

Images show up in the Ecommerce API. When you create a store product from a template with POST /v1/stores/{storeId}/products:create-from-template, you pass your artwork in imagePlaceholders[].fileUrl (jpg, jpeg, png or pdf) and the product comes back with a previewUrl. Templates and store products also expose previewUrl, and store products add externalPreviewUrl and externalThumbnailUrl. The example in the docs is a signed storage link with a 24 hour expiry, so store the file yourself if you need it later.

What you do not get is a call where you send any scene you own plus a design and get back a finished image. Gelato's API terms also set "a standard daily limit of 5000 per day, unless otherwise agreed" for API calls, which matters if you plan to regenerate previews for a large catalog.

Gelato is a fulfillment network first. Its mockups are built to sell Gelato products. You outgrow them in four common situations:

1. You want one brand look across every product. Your own photography or a designer's PSD, not the scenes every other Gelato seller can pick.
2. You list at volume. Hundreds of designs times several colorways times several angles. Doing that in a dashboard is click work.
3. You need bigger files. Ads, hero banners and zoomable product images often want more than 3,000 px.
4. You sell through more than one supplier. A PSD-based pipeline does not care whether the order is printed by Gelato, Printful or your own shop.

This is the job SudoMock does. You upload a PSD with smart objects once, then send one render request per design. Gelato keeps printing and shipping; the listing images come from your template.

Framed posters are one of Gelato's core wall art products. With a PSD template like this one, the same angle, shadow and wall appear for every design you render, which is what makes a catalog look consistent.

A typical setup keeps Gelato for fulfillment and uses the API only for images:

1. Prepare one PSD per product and angle, with the print area as a smart object. SudoMock's smart object guide covers the layer setup.
2. Upload it once. The response lists each smart object's uuid.
3. For every new design, call the render endpoint with the artwork URL. Add a color overlay per smart object if you sell colorways.
4. Upload the returned image to Shopify, Etsy or your own store as the listing image, and create the Gelato product for fulfillment as usual.

curl -X POST "https://api.sudomock.com/api/v1/renders" \
  -H "x-api-key: sm_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "mockup_uuid": "YOUR_POSTER_TEMPLATE_UUID",
    "smart_objects": [
      {
        "uuid": "PRINT_AREA_SMART_OBJECT_UUID",
        "asset": { "url": "https://yourcdn.com/designs/sunset-print.png", "fit": "fit" }
      }
    ],
    "export_options": { "image_format": "jpg", "image_size": 1024, "quality": 90 }
  }'

const response = await fetch('https://api.sudomock.com/api/v1/renders', {
  method: 'POST',
  headers: {
    'x-api-key': 'sm_your_api_key',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "mockup_uuid": "YOUR_POSTER_TEMPLATE_UUID",
    "smart_objects": [
      {
        "uuid": "PRINT_AREA_SMART_OBJECT_UUID",
        "asset": {
          "url": "https://yourcdn.com/designs/sunset-print.png",
          "fit": "fit"
        }
      }
    ],
    "export_options": {
      "image_format": "jpg",
      "image_size": 1024,
      "quality": 90
    }
  }),
});

const data = await response.json();
console.log(data);

import requests

response = requests.post(
    "https://api.sudomock.com/api/v1/renders",
    headers={
        "x-api-key": "sm_your_api_key",
        "Content-Type": "application/json",
    },
    json={
        "mockup_uuid": "YOUR_POSTER_TEMPLATE_UUID",
        "smart_objects": [
            {
                "uuid": "PRINT_AREA_SMART_OBJECT_UUID",
                "asset": {
                    "url": "https://yourcdn.com/designs/sunset-print.png",
                    "fit": "fit",
                },
            },
        ],
        "export_options": {
            "image_format": "jpg",
            "image_size": 1024,
            "quality": 90,
        },
    },
)

print(response.json())

package main

import (
	"bytes"
	"fmt"
	"io"
	"net/http"
)

func main() {
	payload := []byte(`{
  "mockup_uuid": "YOUR_POSTER_TEMPLATE_UUID",
  "smart_objects": [
    {
      "uuid": "PRINT_AREA_SMART_OBJECT_UUID",
      "asset": {
        "url": "https://yourcdn.com/designs/sunset-print.png",
        "fit": "fit"
      }
    }
  ],
  "export_options": {
    "image_format": "jpg",
    "image_size": 1024,
    "quality": 90
  }
}`)

	req, err := http.NewRequest("POST", "https://api.sudomock.com/api/v1/renders", bytes.NewBuffer(payload))
	if err != nil {
		panic(err)
	}
	req.Header.Set("x-api-key", "sm_your_api_key")
	req.Header.Set("Content-Type", "application/json")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

<?php

$payload = <<<'JSON'
{
  "mockup_uuid": "YOUR_POSTER_TEMPLATE_UUID",
  "smart_objects": [
    {
      "uuid": "PRINT_AREA_SMART_OBJECT_UUID",
      "asset": {
        "url": "https://yourcdn.com/designs/sunset-print.png",
        "fit": "fit"
      }
    }
  ],
  "export_options": {
    "image_format": "jpg",
    "image_size": 1024,
    "quality": 90
  }
}
JSON;

$ch = curl_init('https://api.sudomock.com/api/v1/renders');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'x-api-key: sm_your_api_key',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => $payload,
]);

$response = curl_exec($ch);
curl_close($ch);

echo $response;

Set image_size up to 10,000 px for print-size listing images.

The default call is synchronous and returns the image URL in the response. For large batches, set "is_async": true, then poll the job or register a webhook endpoint for render.succeeded and render.failed instead of waiting on each request. JPG at 3,000 px is a practical default for listing images; switch image_format to png when you need transparency.

Mugs are another Gelato staple. The same render call works for any product you have a PSD for, so apparel, wall art and drinkware can share one pipeline.

If you do not have PSDs yet, SudoMock's library has 300+ Gelato-compatible templates across apparel, accessories, drinkware, wall art and packaging that you can start from.

If you need your own scenes at volume, upload one PSD and render a few of your real designs with the 500 free credits, following the quickstart. For how other print providers handle mockups, see the Printful mockup generator guide, Printify's mockup API and the mockup API pricing comparison.

Gelato's mockup tools, plans, download limits and API terms come from Gelato's help center, subscription plans page and API terms, checked on September 30, 2026.