Make integration
9 min read · Reviewed

Make Mockup Automation: HTTP Scenarios and File Exports

Use Make's HTTP app to connect approved artwork and product templates to your order or catalog scenario. Separate job submission from file delivery so a render does not need to finish within the initiating module's timeout.

By Mockups Generator · Custom HTTP scenarios available

FROM EVENT TO IMAGEExample workflow
↗Your trigger

New artwork or an order

Good things grow source artworkGeometric color study source artwork
{ }Render API

Template + design + settings

Background render job
◎Signed webhook

Verify the completion event

Continue your workflow

Before you start

  • A Mockups Generator account, an available render allowance and a named API key from API access.
  • A ready template, its exact artwork-area ID from GET /api/v1/templates/{template_id}, and an approved sample export.
  • An owned artwork asset ID, or a direct public image URL. Prefer saved assets for repeated work.
  • A source-record ID plus an artwork version for a stable idempotency key, and a place to persist the accepted job ID.

Download the setup resources

Examples contain placeholders, not live credentials. Follow the format label: configuration recipes are instructions, while workflow and connector files can be imported into their platform. Platform account permissions and a small live test are required.

  • Configuration JSON

    Make HTTP module mapping

    Field-by-field configuration and JSON request examples for HTTP v4. This is a setup recipe, not an importable Make blueprint.

  • Postman JSON

    Shared Postman collection

    Importable requests for assets, JSON jobs, reviewed plans, recovery and file downloads. Set your key locally.

  1. 1

    Trigger from an approved source item

    Choose an order, spreadsheet or Airtable event containing a template ID, artwork asset ID and operation version. Filter out drafts and records that already have a completed job. Keep a Job ID field so a restart can resume the existing work.

  2. 2

    Create the HTTP keychain

    Add HTTP Make a request. Choose API key authentication, create a keychain and send it as the Authorization header with the complete Bearer value. Use the dedicated credential setting rather than storing the key in a scenario body or manually mapped header.

  3. 3

    Build a JSON request

    Set the URL to your HTTPS origin plus /api/v1/render-jobs, method POST and JSON body. Map the template ID and options.slots artwork reference. Add Idempotency-Key from the source-record ID and artwork version. Use Make's JSON mapping or JSON creation tools so dynamic text is properly escaped.

  4. 4

    Persist the acceptance response

    Parse the JSON response and save id plus the run key in your source record or a Make data store. Keep the original body if you may need to repeat the submission. Do not upload id or the whole JSON envelope as an image.

  5. 5

    Check completion within a deadline

    For a short sample, use a bounded repeater with a pause and a GET status module. For larger work, use a second scheduled scenario that reads stored pending job IDs and checks each once per run. Use filters for done, error or cancelled and record a deadline so queued work does not cause an endless polling scenario.

  6. 6

    Download a file with authentication

    After done, use HTTP Download a file against the canonical result path with the same keychain. Map its returned file data and file name to the destination upload module. Signed-storage redirects must not receive your bearer key from a different origin.

  7. 7

    Record delivery separately from rendering

    Mark the source record delivered only after the upload succeeds. If delivery fails, rerun the download and destination upload for the same job. A download retry does not require another paid render.

Module configuration

The recipe targets HTTP v4, which supports centralized API-key keychains and authenticated downloads. Keep response parsing enabled for JSON job and status calls. Set Content type through the body controls, not as a duplicate header. Older HTTP modules may expose different field names; match the HTTP contract rather than importing an invented blueprint.

{
  "template_id": "REPLACE_TEMPLATE_ID",
  "options": {
    "format": "png",
    "mode": "full",
    "slots": {
      "REPLACE_SLOT_ID": {
        "asset_id": "REPLACE_ASSET_ID",
        "fit": "contain"
      }
    }
  }
}

Official platform documentation for this setup

Collections without a long synchronous request

Add a preflight POST to /api/v1/bulk-jobs/preflight, a filter requiring valid=true and a review of total, warnings and sample output. For areas-based assignments, store plan_id and plan_hash before the submit module. Submit only the saved token, idempotency_key and optional continue_on_error or webhook_url. Poll /bulk-jobs/{id}, then download the ZIP. Persist an accepted token across retries rather than running preflight again with the same key.

Use webhooks deliberately

A Make Custom webhook can trigger a separate completion scenario. Your Mockups Generator submission can supply that public webhook_url, but cannot add custom outbound webhook authentication headers. If your Make hook requires an extra API-key header, place a verifier in front of it or use polling. Verify the HMAC where raw bytes are available, deduplicate event_id, correlate a known job ID and confirm its state before applying updates.

Official platform documentation for this setup

Artworks, folders and output profiles

Use the asset list's offset and has_more values to fetch complete artwork pools. A collection can reference folder IDs through its area pools; a reviewed plan fixes the resolved inputs even if the folder changes later. GET /api/public/output-profiles supplies listing dimensions. A profile fits the scene on a white canvas and does not crop it into a new composition.

Verify completion and move a real file

Treat 202 as acceptance. Persist id, then poll the canonical job endpoint with the same bearer credential. queued, running and cancelling mean wait; done means download; error and cancelled need a recovery branch. A protected result URL cannot be pasted into a destination that has no way to send your API key. Download the bytes through an authenticated action, then upload a file to your destination. A temporary signed link can expire, so refresh it or use the canonical result endpoint. Do not forward the bearer key across a redirect to another origin.

Retries, duplicate events and interrupted runs

Use one key for one intended operation, such as order-1042-artwork-v1. Keep it stable on a lost-response retry. The same inputs and key return the same render job; changed inputs return 409 and need an explicit new version. Do not repeat a synchronous paid render just because the previous step timed out. Retry reads and idempotent submissions with bounded backoff for temporary network or 5xx errors. Fix 401 credentials, 404 ownership, 402 allowance and 422 validation before retrying. When a polling deadline is reached, save the job ID and resume checking it later; the server continues independently.

Troubleshooting checklist

Check the actual HTTP status and detail field before changing the workflow. Test a single ready template and saved asset first, then add multi-area placements and collection output. Avoid enabling schedules until the downloaded file and its destination record have both been inspected.

Field or conditionMapping or action
401Use the full Bearer value and a non-revoked API key; a website key is for the iframe only.
404Confirm the template, asset or job belongs to this account or is an accessible public template.
409Read detail: result not ready, changed inputs, stale revision and expired review need different actions.
402 / 429Check account allowance / reduce concurrency and back off for rate limits.
422Inspect the slot ID, ready status, nested options and direct-image URL. JSON options must be an object.
Broken destination imageDownload with authentication and upload bytes; protected URLs are not public attachments.

Official references

Platform requirements were checked against these official sources on . API examples are checked against the current application. Validate credentials, imports and destination behavior in your own platform account.

FAQ

Common questions

1.Is the Make resource an importable blueprint?

No. It is a labeled HTTP v4 configuration recipe. It supplies verified endpoint and field mappings so you can build a scenario in your own account without embedding API secrets.

2.Can Make upload an authenticated result_url directly to Drive?

Use an authenticated HTTP file download first, then map the returned file data to Drive's upload module. A protected URL alone is not a portable file.

3.Can I use product color variants?

Yes, when the template exposes authored product-color controls. Artwork color fills are a different setting. Preflight the collection and inspect a sample.

Put the guide into practice

Review the workflow and requirements before creating your next output.

Open the API referenceFree plan · no credit card · no watermarks
PSD compatibility reportsSaved projectsAPI with webhooks