Make.com Mockup Scenario: Render Each New Google Sheets Row on Your Own PSD or Product Photo

One row is one mockup, so a sheet holds exactly the products a customer picked. That answers a question a printing company put on the Adobe community on 16 January 2025: "Out of a total list of 10 items the customer wants to see mockups for items 1, 4, 5 and 7 and only those items." With this scenario those four items are four rows, and nothing else is rendered.

Give the sheet a header row and one row per mockup: which template, which design, and an empty cell for the result. The template and its smart object are named by UUID, so a single SudoMock module can render a tee on one row and a framed print on the next.

Run the SudoMock Search mockups module once to read both UUIDs: it lists your templates with their smart objects, and Get mockup details does the same for one template. Without a PSD of your own, open a template in the library, such as the t-shirt mockups, the mug mockups or a framed print, and press Use This Mockup: it lands in your account with the same kind of UUIDs. The PSD upload guide covers your own files.

Keep the rows together. Make's Google Sheets documentation says of Watch New Rows (read 31 October 2026): "If a sheet contains a blank row, Make doesn't process all subsequent rows."

Watch New Rows starts each run with the rows added since the last one. Point it at the spreadsheet and the sheet, and set Table contains headers to Yes so the next modules see mockup_uuid and design_url by name instead of column letters.

When Make opens the Choose where to start window, select All: per Make's setup guide, the module then processes the rows already in the sheet first and the rows added later after them. The scenario runs on the schedule you give it in Make, and each run passes every new row through modules 2 and 3 one after another.

Render a mockup sends the row to SudoMock and returns the finished image link. Map the three columns into the module and set Fit on purpose, because the right value depends on the design's shape.

Export options are advanced fields: switch on Advanced settings in the module to see them. The connection asks for the key once, checks it against your account and shows its email, and every SudoMock module reads that one connection, so one key serves every scenario in your Make team. Fit keeps the whole design visible inside the smart object, while Fill stretches it to the smart object's edges, which suits a print file made at that exact shape. The export label starts the file name, so row-2 in the name tells you which row an image came from.

The module sends one render request. This is the same request for row 2 as an API call, with your key and your UUIDs in place of ours:

curl -X POST https://api.sudomock.com/api/v1/renders \
  -H "x-api-key: $SUDOMOCK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "mockup_uuid": "e532c503-fe20-4653-a301-af9f7a934609",
    "smart_objects": [
      {
        "uuid": "39865245-8d99-42e9-b1fc-3713fa4dbc94",
        "asset": { "url": "https://cdn.example.com/designs/sunset-waves.png", "fit": "fit" }
      }
    ],
    "export_options": { "image_format": "webp", "image_size": 1024 },
    "export_label": "row-2"
  }'

const response = await fetch('https://api.sudomock.com/api/v1/renders', {
  method: 'POST',
  headers: {
    'x-api-key': process.env.SUDOMOCK_API_KEY,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "mockup_uuid": "e532c503-fe20-4653-a301-af9f7a934609",
    "smart_objects": [
      {
        "uuid": "39865245-8d99-42e9-b1fc-3713fa4dbc94",
        "asset": {
          "url": "https://cdn.example.com/designs/sunset-waves.png",
          "fit": "fit"
        }
      }
    ],
    "export_options": {
      "image_format": "webp",
      "image_size": 1024
    },
    "export_label": "row-2"
  }),
});

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

import os
import requests

response = requests.post(
    "https://api.sudomock.com/api/v1/renders",
    headers={
        "x-api-key": os.environ["SUDOMOCK_API_KEY"],
        "Content-Type": "application/json",
    },
    json={
        "mockup_uuid": "e532c503-fe20-4653-a301-af9f7a934609",
        "smart_objects": [
            {
                "uuid": "39865245-8d99-42e9-b1fc-3713fa4dbc94",
                "asset": {
                    "url": "https://cdn.example.com/designs/sunset-waves.png",
                    "fit": "fit",
                },
            },
        ],
        "export_options": {
            "image_format": "webp",
            "image_size": 1024,
        },
        "export_label": "row-2",
    },
)

print(response.json())

package main

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

func main() {
	payload := []byte(`{
  "mockup_uuid": "e532c503-fe20-4653-a301-af9f7a934609",
  "smart_objects": [
    {
      "uuid": "39865245-8d99-42e9-b1fc-3713fa4dbc94",
      "asset": {
        "url": "https://cdn.example.com/designs/sunset-waves.png",
        "fit": "fit"
      }
    }
  ],
  "export_options": {
    "image_format": "webp",
    "image_size": 1024
  },
  "export_label": "row-2"
}`)

	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", os.Getenv("SUDOMOCK_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": "e532c503-fe20-4653-a301-af9f7a934609",
  "smart_objects": [
    {
      "uuid": "39865245-8d99-42e9-b1fc-3713fa4dbc94",
      "asset": {
        "url": "https://cdn.example.com/designs/sunset-waves.png",
        "fit": "fit"
      }
    }
  ],
  "export_options": {
    "image_format": "webp",
    "image_size": 1024
  },
  "export_label": "row-2"
}
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: ' . getenv('SUDOMOCK_API_KEY'),
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => $payload,
]);

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

echo $response;

The image link comes back at data.print_files[0].export_path, and the module puts it on its output as Rendered image URL. On 31 October 2026 we sent rows 2 to 4 this way: the sunset badge on a t-shirt template and on a mug template with Fit, and a botanical print made at 2:3 in a 2:3 framed print template with Fill. Each came back as a WebP named after its row. The average SudoMock render finishes in under a second.

Row 2: the sunset badge on a t-shirt template, Fit.

Row 3: the same design link on a mug template.

Row 4: a 2:3 print in a 2:3 framed print template, Fill.

Update a Row writes the image link back into the row that asked for it. Map Row number from Watch New Rows so the link lands in the right row, and put Rendered image URL in the mockup_url column.

To keep the image file as well as the link, add the SudoMock Download a render module after module 2 with Render URL set to Rendered image URL. It returns the image as a file, which a Google Drive or Dropbox upload module stores in a folder of your choice.

A product with no PSD renders from a photo of the product saved as a photo mockup. Swap module 2 for Render a photo mockup, keep a photo_mockup_uuid and a print_area_uuid column in the sheet, and the rest of the scenario stays as it is. To keep PSD rows and photo rows in one sheet, add a Router after Watch New Rows with a filter on each route: rows with a photo_mockup_uuid go to Render a photo mockup, the others to Render a mockup, and each route ends in its own Update a Row.

The finished link is the Export path of the first entry in Print files, which goes into Update a Row the same way. You save a product photo as a photo mockup once, in the dashboard or with the Create a mockup from a photo module, and every later row reuses it; photo mockups shows how a print area is set. Get a photo mockup returns both values for the sheet: the Photo mockup ID, and the Print area ID of each area under Quads. For a bag, a ready tote bag template works too.

Row 5: Render a photo mockup placed the badge in the tote's saved Front area. The tote photo came from an image model; Photo Mockups kept the exact design on it.

A row whose design link does not open stops the run at the SudoMock module, and the rows behind it in that run are not rendered. Add an error handler to the SudoMock module so a bad row is skipped and the others still render.

When we sent a row whose design link returned a 404, SudoMock answered 422 with the code ASSET_UNREACHABLE and the message "The artwork could not be downloaded.", and the Make module shows it as [422] One or more artwork inputs are invalid. The link has to return the image file itself to anyone who opens it, so a share page or a link that needs a login fails the same way. In Make, open the context menu of the SudoMock module, choose Add error handler and pick Skip: per Make's help, it "skips the error or the failed bundle from the scenario flow" and the run "continues with the next bundle." The skipped row keeps an empty mockup_url, which shows you which rows to fix. Watch New Rows does not fetch a row it has already processed, so paste the fixed row as a new row at the end of the sheet and the next run renders it.

Build the three modules on a sheet with two rows, one template you already have and one design link, and run the scenario once with Run once. The Make integration page lists every module of the app, the render reference lists every field Render a mockup can send, and fit and blend modes shows the three fit values side by side. The SudoMock app is also listed on Make's integrations page. If your automations run on n8n, the SudoMock node for n8n renders the same rows.