Smartmockups API: Status and a Reliable Alternative

Smartmockups launched in 2016 out of Liberec, Czech Republic. Founded by Lukas Zajic and Andrew Nekvinda, it offered quick, browser-based mockup creation. Upload a design, pick a template, export.

Then Canva came knocking. In February 2021, Canva acquired Smartmockups (alongside the parent company behind remove.bg) to fold mockup capabilities into its design ecosystem.

For three years Smartmockups kept running as a standalone product. But on September 27, 2024, Canva pulled the plug. The smartmockups.com domain now redirects to Canva, user data was deleted, and saved projects did not transfer. And that API? Still "Coming soon" when the lights went off.

This is not just a Smartmockups story. It is an architecture story, and it is the most useful part of this page if you are choosing an engine to build on.

Template-based mockup tools composite your design onto a pre-rendered scene, usually in the browser. The mockup is essentially a finished photograph with a designated drop zone, and the placement happens client-side with basic image manipulation. That model is fast to ship for a UI. It is the wrong foundation for a programmatic engine, because a real API has to:

1. Run the full compositing pipeline server-side, deterministically, without a browser in the loop
2. Handle real concurrency: queues, retries, and throughput under burst load
3. Reproduce the full range of layer behavior (blend modes, masks, smart filters) rather than a flat drop zone
4. Hold response times steady while traffic climbs

An API-first product needs that foundation from day one. You cannot bolt it onto a browser compositor later without essentially rebuilding the thing. After the acquisition, Smartmockups engineering went toward Canva integration rather than new server infrastructure, and the promised API never had a foundation to stand on. The lesson for buyers is simple: a tool that demos beautifully in a browser tells you nothing about whether it can survive as an API.

If you typed "smartmockups api" you do not want a template gallery. You want an engine that returns the right image, every time, at the volume your catalog demands. Here is what that engine looks like, and where SudoMock has spent its engineering.

Verified Adobe-grade fidelity. SudoMock renders your PSD to match Photoshop's own output, pixel for pixel. It supports all 27 blend modes, smart filters including Perspective Warp, Curves, and Gaussian Blur, nested smart objects, masks, and adjustment layers. A fabric fold warps correctly, a drop shadow lands where Photoshop would put it. That is the difference between a mockup a customer trusts and one that looks subtly wrong.

Your own PSD, not a shared catalog. This is the part that quietly matters most for sellers. A generic shared template library is a liability, not a feature. If your store runs the same stock scenes as thousands of other shops, your listings look interchangeable, and marketplaces have little reason to favor duplicate imagery. A mockup should be yours, rendered from the PSD your designer built, so your catalog looks like nobody else's. SudoMock is built around that: you upload your own templates and swap designs into them programmatically.

Print-ready resolution. Renders go up to 10,000px with no forced downscaling, so the same call that feeds your web listing can feed a print file.

Battle-tested reliability. Over 2 billion renders served as of June 2026, 99.9% uptime backed by a public status page, and sub-second average render times. Every render can fire an HMAC-signed completion webhook with automatic retries and a replay dashboard, plus full position metadata so your downstream system knows exactly where the design landed. That is the boring infrastructure a real automation pipeline lives or dies on.

Fully white-label. Serve every render from your own domain with zero SudoMock branding, and embed the editor directly in your product. Your customers never see a third party.

Developer experience. API-first, with Python and Node SDKs, a public MCP server, and native Shopify, WooCommerce, n8n, Zapier, and Make integrations. You are not gluing a UI tool to a cron job. Compare the broader field on our mockup tool alternatives page, and see SudoMock vs Smartmockups for the side-by-side.

Price is not the reason to pick an engine, but it is not nothing either, so here are the real numbers without the marketing math.

Adobe's published Photoshop API rate was $0.15 per successful call (2023 public pricing, since moved to enterprise-only). SudoMock publishes its prices. Plans start at $25/month. Subscriptions from $0.002 per render. The free tier is 500 credits with no card. The current plans live on the pricing page.

Run the same workload through each and the gap is obvious, but do the multiplication yourself rather than trusting a slogan. The point is not that one is cheap. It is that once you have chosen the engine on fidelity and reliability, the cost should not be what stops you from scaling it. For a full side-by-side across providers, see our mockup API pricing comparison, and for the Adobe case specifically, SudoMock vs Adobe Photoshop API.

If you were waiting on the Smartmockups API, here is how to get to real automation in an afternoon.

Step 1: Prepare your PSD. Build or open a Photoshop template with smart object layers, and name each one descriptively, like "Chest Design" or "Front Print." Lighting, angle, and brand are baked into your own file, which is the whole point.

Step 2: Get an API key. Sign up and grab your key from the dashboard. About thirty seconds.

Step 3: Upload your template. Push the PSD through the dashboard (files up to 300 MB) or the upload endpoint, which has no file size limit. The response returns your mockup UUID and the list of smart objects with their dimensions. The quickstart guide walks the whole setup.

Step 4: Render your first mockup.

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": "c315f78f-d2c7-4541-b240-a9372842de94",
    "smart_objects": [{
      "uuid": "128394ee-6758-4f2f-aa36-e2b19b152bd9",
      "asset": { "url": "https://your-cdn.com/design.png", "fit": "cover" }
    }],
    "export_options": { "image_format": "webp", "image_size": 1024, "quality": 95 }
  }'

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": "c315f78f-d2c7-4541-b240-a9372842de94",
    "smart_objects": [
      {
        "uuid": "128394ee-6758-4f2f-aa36-e2b19b152bd9",
        "asset": {
          "url": "https://your-cdn.com/design.png",
          "fit": "cover"
        }
      }
    ],
    "export_options": {
      "image_format": "webp",
      "image_size": 1024,
      "quality": 95
    }
  }),
});

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": "c315f78f-d2c7-4541-b240-a9372842de94",
        "smart_objects": [
            {
                "uuid": "128394ee-6758-4f2f-aa36-e2b19b152bd9",
                "asset": {
                    "url": "https://your-cdn.com/design.png",
                    "fit": "cover",
                },
            },
        ],
        "export_options": {
            "image_format": "webp",
            "image_size": 1024,
            "quality": 95,
        },
    },
)

print(response.json())

package main

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

func main() {
	payload := []byte(`{
  "mockup_uuid": "c315f78f-d2c7-4541-b240-a9372842de94",
  "smart_objects": [
    {
      "uuid": "128394ee-6758-4f2f-aa36-e2b19b152bd9",
      "asset": {
        "url": "https://your-cdn.com/design.png",
        "fit": "cover"
      }
    }
  ],
  "export_options": {
    "image_format": "webp",
    "image_size": 1024,
    "quality": 95
  }
}`)

	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": "c315f78f-d2c7-4541-b240-a9372842de94",
  "smart_objects": [
    {
      "uuid": "128394ee-6758-4f2f-aa36-e2b19b152bd9",
      "asset": {
        "url": "https://your-cdn.com/design.png",
        "fit": "cover"
      }
    }
  ],
  "export_options": {
    "image_format": "webp",
    "image_size": 1024,
    "quality": 95
  }
}
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;

You get back a CDN URL with the finished render, and a signed webhook fires on completion so your system never has to poll.

Step 5: Scale it. Wire the render call to n8n, Zapier, or Make so a new Google Drive file, a new Shopify product, or an Airtable row triggers a batch automatically. Upload once, render thousands of variations, no browser tabs and no "Coming soon" that never comes.

Start with one product: prepare its PSD, upload it once, and render a single design. The render matches Photoshop's own output for the same file, down to the warp, the shadows, and the blend modes. Preparing a PSD lists the file requirements and the steps to build the template.

If you worked from Smartmockups templates and have no PSD of your own, start from a ready template in the mockup template library. To run the same render without code, the n8n and Make guides show how a new design file in a folder or a new row in a sheet starts it.