Render product mockups with Node.js

This page takes a Photoshop file to a finished image from a Node.js service: one upload you run once, then a route that renders on demand.

Hand this to a coding agent before it writes SudoMock calls in Node.

Open in Cursor

Prerequisites

Node 20 or later. The files below are ESM, so use a .mjs file or set "type": "module" in your package.json. A CommonJS project can reach the same client with const { SudoMock } = require('sudomock').
An API key. Create one, then export it. Keys begin with sm_ and travel in the x-api-key header.
A PSD reachable over HTTPS. Preparing a PSD covers what to check before the first upload.
If the API is new to you, the Quickstart runs the same two requests with curl first.

Guide

Install

npm install sudomock

pnpm add sudomock

yarn add sudomock

Put the key in the environment rather than in the code. The client reads SUDOMOCK_API_KEY when you construct it with no argument.

export SUDOMOCK_API_KEY=sm_your_api_key

Upload the template once

Uploading returns the layers you can address later, each with its own UUID. This belongs in your setup, not in the path that serves requests.

upload.mjs

import SudoMock from 'sudomock'

const client = new SudoMock()

const mockup = await client.uploads.create({
  psdFileUrl: 'https://example.com/heavyweight-tee.psd',
  psdName: 'Heavyweight tee front',
})

console.log('mockup', mockup.uuid)

for (const layer of mockup.smartObjects) {
  console.log('smart object', layer.uuid, layer.name)
}

Run it, then keep the two UUIDs it prints:

node upload.mjs
export MOCKUP_UUID=the_mockup_uuid
export SMART_OBJECT_UUID=the_smart_object_uuid

One upload serves every render after it. A template you uploaded last month renders today without being sent again.

Render from a route

The route below takes an artwork URL and answers with the rendered image. It uses the built-in HTTP server, so nothing beyond the client is needed.

server.mjs

import { createServer } from 'node:http'
import SudoMock, { SudoMockError } from 'sudomock'

const client = new SudoMock()
const mockupId = process.env.MOCKUP_UUID
const smartObjectUuid = process.env.SMART_OBJECT_UUID

async function readJson (req) {
  req.setEncoding('utf8')
  let body = ''
  for await (const chunk of req) body += chunk
  return body ? JSON.parse(body) : {}
}

const server = createServer(async (req, res) => {
  if (req.method !== 'POST' || req.url !== '/mockups') {
    res.writeHead(404).end()
    return
  }

  try {
    const { artworkUrl } = await readJson(req)

    const render = await client.renders.create({
      mockupId,
      smartObjects: [
        { uuid: smartObjectUuid, asset: { url: artworkUrl } },
      ],
      exportOptions: { imageFormat: 'webp', imageSize: 2048 },
    })

    res.writeHead(200, {
      'content-type': 'application/json',
    })
    res.end(JSON.stringify({ url: render.url }))
  } catch (error) {
    if (error instanceof SudoMockError) {
      res.writeHead(error.status || 502, {
        'content-type': 'application/json',
      })
      res.end(JSON.stringify({ error: error.code }))
      return
    }

    res.writeHead(500).end()
  }
})

server.listen(3000)

Start it with node server.mjs and send it an artwork:

curl -X POST http://localhost:3000/mockups \
  -H "Content-Type: application/json" \
  -d '{"artworkUrl":"https://example.com/artwork.png"}'

The answer carries url, the finished image. The same value sits in render.printFiles, paired with the smart object it was placed into. How the artwork meets that area is set by asset.fit, described in Fit and blend modes.

A render that takes a while does not have to hold the request open. Pass isAsync as true, and client.renders.create resolves with a job instead. Await client.jobs.waitForJob(job.jobId), or let a webhook call you back.

Handle the failures

Everything the client raises is a SudoMockError carrying status and code, and the subclasses let you branch without reading message text: AuthenticationError for a key the account no longer honours, CreditError when the render cannot be paid for, ValidationError for a body the API rejected, and RateLimitError when calls arrive faster than the account allows.Only the last one is worth repeating, and it says how long to wait:

import { setTimeout as sleep } from 'node:timers/promises'
import { RateLimitError } from 'sudomock'

if (error instanceof RateLimitError) {
  await sleep((error.retryAfter ?? 1) * 1000)
  // send the same render again
}

An account still in trial renders up to 1024 px wide. An imageSize above that answers OUTPUT_RESOLUTION_LIMIT rather than quietly shrinking the image, so the width you asked for is the width you get.

Error codes lists every code, its status, and whether retrying it can help.

Next steps

SDK reference

Every resource on the client, in Node and in Python.

Webhooks

Get called back the moment a background render finishes.

Get started

Learn

Resources

Render product mockups with Node.js

Prerequisites

Guide

Next steps

SDK reference

Webhooks

​Prerequisites

​Guide

​Next steps

SDK reference

Webhooks

Prerequisites

Guide

Next steps