How to Automate Transparent Backgrounds with the Transparify API (n8n, Make, Zapier)

The Transparify browser tool works great for one-off images - drag, drop, download. But what happens when you need to process 50 product images a day? Or integrate transparent background restoration into a design pipeline that runs while you sleep?

The manual workflow doesn't scale. You need an API.

Transparify's REST API lets you automate alpha channel recovery programmatically. Send two images (white background + black background), get back a perfectly transparent PNG or WebP. No browser required. In this guide, you'll learn how to wire it into three popular automation platforms: n8n, Make (formerly Integromat), and Zapier.

Why Automate Transparent Background Restoration

If you're processing images one at a time in the browser, each image takes about 30 seconds of manual work: open the page, upload two files, wait for processing, download the result. That's fine for a handful of images. At scale, it becomes a bottleneck.

Here's where automation pays off:

• E-commerce pipelines - process product renders automatically as they come out of your 3D software or AI generator. New image pair lands in a folder, transparent version appears minutes later.
• Design asset libraries - keep a folder of AI-generated assets that automatically get their transparency restored and filed into your asset management system.
• Content teams - let non-technical team members trigger transparency restoration from a form, Slack message, or email attachment.
• SaaS integrations - build transparent background restoration directly into your product. Let your users upload image pairs and get results without leaving your app.

The API handles the same alpha recovery math as the browser tool - comparing white and black background versions pixel by pixel to calculate exact transparency values. The difference is that it runs on the server, accepts programmatic input, and returns results you can pipe into the next step of your workflow.

Transparify API Quick Reference

The API has a single endpoint that does one thing well: restore transparency from an image pair. Here's everything you need to know to call it.

Request Parameters

Send a POST request to https://transparify.app/api/v1/restore with multipart/form-data:

Both images must have identical dimensions. The API will return a 422 error if the dimensions don't match.

Response

On success (HTTP 200), the API returns the binary image data directly - not JSON. The response includes two useful headers:

Error responses return JSON with an error field and an appropriate HTTP status code (400, 401, 422, 429, or 500).

Quick Test with curl

curl -X POST https://transparify.app/api/v1/restore \
  -H "Authorization: Bearer trns_your_api_key_here" \
  -F "white_image=@white.png" \
  -F "black_image=@black.png" \
  -F "format=png" \
  -o result.png

If you get back a valid PNG file, your API key is working and you're ready to automate. For more code examples in Python, Node.js, and Go, see the full API documentation.

Prerequisites

Before setting up any of the workflows below, you'll need:

1. A Transparify account - sign up free if you don't have one.
2. An API key - create one in your dashboard. Keys start with trns_.
3. Image pairs - white and black background versions of each image. If you're generating these from AI tools, see our guide on getting transparent PNGs from AI generators for prompt tips.

Your plan determines how many API calls you can make per month and the maximum image dimensions:

The Free plan is enough to test your automation end to end. Upgrade when you're ready for production volumes. See pricing for full details.

Workflow 1: n8n

n8n is an open-source workflow automation tool that you can self-host or use as a cloud service. It has excellent support for binary data and HTTP requests, making it the best fit for image processing workflows.

Workflow Overview

1. Trigger - a new file appears in a folder (Google Drive, S3, local filesystem) or a webhook fires
2. Read Images - download/read the white and black background image files
3. HTTP Request - send both images to the Transparify API
4. Save Result - write the returned image to your output folder or pass it to the next node

Step-by-Step Setup

1. Set up your trigger. Use the trigger that matches your source - Google Drive Trigger, S3 Trigger, Webhook, Cron, or Manual. For testing, use the Manual trigger.

2. Read your images. Add two "Read Binary File" nodes (or "Google Drive: Download" / "S3: Get Object" depending on your source). Name the outputs white and black so you can reference them later.

3. Configure the HTTP Request node. This is where the API call happens:

• Method: POST
• URL: https://transparify.app/api/v1/restore
• Authentication: Header Auth - set Authorization to Bearer trns_your_api_key
• Body Content Type: Multipart Form Data
• Body Parameters:
  • white_image - set to binary, reference the white image data
  • black_image - set to binary, reference the black image data
  • format - set to png or webp
• Options: Set "Response Format" to "File" so n8n treats the response as binary data

4. Save the result. Add a "Write Binary File" node (or upload to Google Drive, S3, etc.) to store the transparent image.

Handling Responses and Errors

The API returns standard HTTP status codes. Use an IF node after the HTTP Request to branch on the response status:

• 200 - success, continue to save the image
• 422 - image dimensions don't match. Check that both files are the same size.
• 429 - rate limit exceeded. Add a Wait node (60 seconds) and retry. If you hit the monthly quota, the response body will say so.
• 401 - invalid API key. Check your credentials.

For batch processing, add a Wait node between iterations to stay within your rate limit. For the Free plan (10 requests/minute), a 6-second delay between calls keeps you safe.

Workflow 2: Make (Integromat)

Make (formerly Integromat) is a visual automation platform with strong support for HTTP requests and binary data handling. It's a solid choice if you prefer a visual drag-and-drop builder.

Scenario Overview

1. Trigger - watch a folder, receive a webhook, or run on schedule
2. Download Images - fetch the white and black background images
3. HTTP Module - send both images to the Transparify API
4. Output - save the result to Google Drive, Dropbox, or your preferred storage

Step-by-Step Setup

1. Add your trigger module. Use "Google Drive: Watch Files," "Webhooks: Custom Webhook," or any module that provides or references your image files.

2. Download the image files. If your trigger doesn't provide the binary data directly, add "HTTP: Get a File" modules to download both the white and black background images.

3. Add the HTTP > Make a Request module. Configure it as follows:

• URL: https://transparify.app/api/v1/restore
• Method: POST
• Headers: Add Authorization: Bearer trns_your_api_key
• Body type: Multipart/form-data
• Fields:
  • Field name: white_image, type: File, map the binary data from step 2
  • Field name: black_image, type: File, map the binary data from step 2
  • Field name: format, type: Text, value: png
• Parse response: No (the response is binary image data, not JSON)

4. Save the output. Use "Google Drive: Upload a File," "Dropbox: Upload a File," or any storage module. Map the binary data from the HTTP response to the file content.

Error Handling in Make

Make has built-in error handling routes. Right-click the HTTP module and add an Error Handler route:

• For 429 (rate limit) - add a Sleep module (60 seconds) followed by a Retry directive. This handles both per-minute rate limits and gives you time to check monthly quotas.
• For 422 (dimension mismatch) - route to a notification module (email, Slack) to flag the problematic image pair for manual review.
• For 401 (auth error) - route to a notification so you can update your API key.

Use a Router module after the error handler to branch based on the HTTP status code. This lets you handle each error type differently rather than failing the entire scenario.

Workflow 3: Zapier

Zapier is the most widely used automation platform, but it has some limitations when it comes to binary file handling. It's still possible to use it with the Transparify API, but the setup is a bit different.

Zap Overview

1. Trigger - new file in Google Drive, Dropbox, or similar
2. Fetch Images - get the file URLs or contents
3. Webhooks Action - POST to the Transparify API (or use Code by Zapier)
4. Output - save the result

Step-by-Step Setup

Zapier's built-in "Webhooks by Zapier" action supports sending files via URL, but multipart file uploads from binary data are limited. The most reliable approach is to use "Code by Zapier" for the API call.

1. Set up your trigger. Use "Google Drive: New File in Folder" or a similar trigger. Make sure the trigger provides the file download URLs.

2. Get file URLs. If your images are in cloud storage, you'll need their direct download URLs. Some triggers provide these automatically. If not, add a step to generate temporary download URLs.

3. Use Webhooks by Zapier (Custom Request):

• Method: POST
• URL: https://transparify.app/api/v1/restore
• Headers: Authorization: Bearer trns_your_api_key
• Map your image files to the white_image and black_image fields

If the Webhooks action doesn't handle the file upload correctly, use the Code by Zapier approach below instead.

Code by Zapier Alternative

For the most reliable results, use a "Code by Zapier" step with Python. This gives you full control over the multipart request:

import requests

# Input data from previous Zapier steps
white_url = input_data['white_image_url']
black_url = input_data['black_image_url']
api_key = input_data['api_key']

# Download both images
white_img = requests.get(white_url).content
black_img = requests.get(black_url).content

# Call Transparify API
response = requests.post(
    'https://transparify.app/api/v1/restore',
    headers={'Authorization': f'Bearer {api_key}'},
    files={
        'white_image': ('white.png', white_img, 'image/png'),
        'black_image': ('black.png', black_img, 'image/png'),
    },
    data={'format': 'png'}
)

if response.status_code == 200:
    # Save to a temporary URL or pass to next step
    output = {
        'status': 'success',
        'processing_time': response.headers.get('X-Processing-Time-Ms'),
        'remaining_calls': response.headers.get('X-Remaining-Calls'),
    }
else:
    output = {
        'status': 'error',
        'error': response.json().get('error', 'Unknown error'),
        'status_code': response.status_code
    }

return output

Note: Code by Zapier has a 1-second timeout for free plans and 30 seconds for paid plans. Large images may need the paid plan to avoid timeouts.

Zapier Limitations

Zapier is a great general-purpose automation tool, but it has some constraints for image processing workflows:

• Binary handling is limited - Zapier prefers working with text data and URLs. Passing binary image data between steps requires workarounds.
• No native multipart file upload - the Webhooks action can send files by URL, but uploading raw binary files from memory isn't straightforward.
• Code step limitations - Python code runs in a sandboxed environment with restricted libraries and execution time limits.
• No retry logic - Zapier doesn't have built-in retry/delay modules like n8n and Make. If you hit a rate limit, the Zap fails and you rely on Zapier's automatic replay.

For these reasons, Zapier works best for low-volume automations (a few images per day) or as a trigger that hands off to a more capable processing tool.

Choosing the Right Automation Tool

All three platforms can call the Transparify API, but they differ in how well they handle the binary image data and error recovery that image processing requires.

Our recommendations:

• n8n if you want full control, self-hosting, and the best binary data handling. Ideal for developers and high-volume pipelines.
• Make if you prefer a visual builder with good error handling and don't need self-hosting. Great for teams with mixed technical skill levels.
• Zapier if you're already using it for other automations and only need to process a few images. The Code by Zapier step makes it work, but it's not the most elegant solution.

Regardless of which tool you choose, the API call is the same: POST two images, get a transparent result. The difference is just how each platform wraps that call.