PSD Mockup Template Guide: Best Practices for Automation

A PSD mockup template is a Photoshop file with a smart object where the design goes. You build it once, upload it once, and every render after that swaps new artwork into the smart object without opening Photoshop.

What a good template carries:

• High-resolution smart objects: Author the smart object contents at 3000 px or larger for print-ready output
• Descriptive layer names: Names come back in the upload response: "Design_Front" beats "Layer 1"
• 27 supported blend modes: From Multiply to Color Burn, all standard Photoshop blends render as authored
• Live effects and transforms: Warps, perspective, masks, Drop Shadow, Stroke, Glow, Bevel and Blend If render as authored
• Unlimited layers: Complex multi-layer mockups with no artificial constraints

In Photoshop, a smart object is a layer that acts as a container. Whatever image you place inside it appears with the same perspective, warp, blend mode and effects as the container. That is how a mockup works: your design goes into the smart object, and it looks printed on the product.

A mockup API reads the smart objects in your PSD and lets you swap their contents with a request. One PSD template renders unlimited mockup variations, one for every design you send it.

SudoMock supports all 27 standard Photoshop blend modes, and each one renders pixel-perfectly, exactly as authored in your PSD:

Masks render as authored. A layer mask on the smart object layer, a mask on a group that contains it, and a clipping mask all shape the design you send the same way they shape it in Photoshop.

SudoMock fully supports nested smart objects, with no limit on nesting depth. You can have smart objects inside smart objects, with all transforms and blend modes preserved at each level.

📁 Main PSD
├── Background
├── 📦 T-Shirt_Group
│   ├── Shirt_Base
│   └── 📦 Design_Smart_Object     ← API targets this
│       └── 📦 Nested_Effect_SO    ← Also supported
│           └── Your_Design
└── Shadow_Layer

• Deep nesting supported: No artificial limits on smart object hierarchy depth
• All transforms preserved: Warp, perspective, and distort work at every level
• Blend modes per level: Each nested smart object can have its own blend mode

SudoMock renders the layer effects (layer styles) applied to smart object layers:

✅ Good Names:
├── Design_Front
├── Design_Back
├── Logo_Chest
├── Label_Neck
└── Color_Overlay

❌ Bad Names:
├── Layer 1
├── Layer 1 copy
├── Smart Object 1
└── Group 1

Here's the recommended layer organization for a mockup template:

A two-minute check in Photoshop catches most template problems before the first render:

1. Double-click the Smart Object layer thumbnail
2. A new tab opens with the Smart Object contents
3. Paste in a test design
4. Save and close the tab
5. Check that the design appears correctly on the product
6. Verify perspective, blend mode, and effects look right

After you upload, render the template once at full size before it goes into production.

Upload the PSD once. The response lists every smart object, text layer, and group layer it found, under the names you gave them, each with the uuid you send back at render time.

curl -X POST https://api.sudomock.com/api/v1/psd/upload \
  -H "x-api-key: sm_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "psd_file_url": "https://example.com/tshirt-mockup.psd",
    "psd_name": "T-shirt front"
  }'

const response = await fetch('https://api.sudomock.com/api/v1/psd/upload', {
  method: 'POST',
  headers: {
    'x-api-key': 'sm_your_api_key',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "psd_file_url": "https://example.com/tshirt-mockup.psd",
    "psd_name": "T-shirt front"
  }),
});

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

import requests

response = requests.post(
    "https://api.sudomock.com/api/v1/psd/upload",
    headers={
        "x-api-key": "sm_your_api_key",
        "Content-Type": "application/json",
    },
    json={
        "psd_file_url": "https://example.com/tshirt-mockup.psd",
        "psd_name": "T-shirt front",
    },
)

print(response.json())

package main

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

func main() {
	payload := []byte(`{
  "psd_file_url": "https://example.com/tshirt-mockup.psd",
  "psd_name": "T-shirt front"
}`)

	req, err := http.NewRequest("POST", "https://api.sudomock.com/api/v1/psd/upload", 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'
{
  "psd_file_url": "https://example.com/tshirt-mockup.psd",
  "psd_name": "T-shirt front"
}
JSON;

$ch = curl_init('https://api.sudomock.com/api/v1/psd/upload');
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;

The file is fetched from that URL, so it has to download without a sign-in. A signed URL works.

{
  "success": true,
  "data": {
    "uuid": "550e8400-e29b-41d4-a716-446655440000",
    "name": "T-shirt front",
    "smart_objects": [
      {
        "uuid": "7c3e8f2a-1b4d-4e5f-8a9c-0d1e2f3a4b5c",
        "name": "Design_Front",
        "size": {
          "width": 3500,
          "height": 4000
        },
        "position": {
          "x": 450,
          "y": 380,
          "width": 1200,
          "height": 1400
        },
        "quad": [[450, 380], [1650, 420], [1600, 1780], [420, 1720]],
        "blend_mode": "multiply"
      }
    ]
  }
}

When rendering mockups, you have full control over the output format and quality:

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: '550e8400-e29b-41d4-a716-446655440000',
    smart_objects: [{
      uuid: '7c3e8f2a-1b4d-4e5f-8a9c-0d1e2f3a4b5c',
      asset: { url: 'https://your-storage.com/design.png' }
    }],
    export_options: {
      image_format: 'webp',    // png, jpg, or webp (default)
      image_size: 1024,        // 100-10000px wide (default 2048)
      quality: 90              // 1-100 (default 90)
    }
  })
});

const { data } = await response.json();
console.log(data.print_files[0].export_path); // the finished image

The same two requests are walked through step by step in the quickstart.

• .psd or .psb file, saved in RGB
• Dimensions up to 10,000×10,000px
• API uploads up to Adobe's official PSD file size limit; dashboard uploads up to 300 MB
• Design areas are smart objects, not rasterized, and visible
• Descriptive layer names, the same across templates

• Blend mode set (multiply for fabrics)
• Transforms applied (warp, perspective)
• Contents at 3000 px or larger
• Positioned correctly on canvas
• Effects on the smart object layer, not inside it