> [Site index](https://perfectvector.com/llms.txt) — available pages and descriptions.

# Vectorize an Image in Make With an HTTP Workflow

> Send a Google Drive image to a vectorization API from Make. Map the file bytes, handle pending or failed responses, and save the SVG in another folder.

Source: https://perfectvector.com/blog/make-com-vectorize-image-automation

Language: en
Author: Jay
Published: 2026-11-13T08:00:00+09:00

Use this reference to map the file and response fields for a Make HTTP v4 scenario that reads a raster image from Google Drive. It covers the request, conversion ID and SVG result. The API exchange was verified with a test key, and the Make and Drive mappings follow official module documentation.

## Start with one file and a test key

Connect Google Drive to Make. Put a single-frame PNG, JPEG or WebP in a test folder, choose a separate folder for outputs, and get a [PerfectVector test key](https://perfectvector.com/account/developers). Pick a file no larger than 5 MiB and between 100 and 4096 pixels on each side. A successful test conversion returns a fixed sample SVG. [PerfectVector test mode](https://perfectvector.com/docs/api/test-mode)

Add **Google Drive → Download a File** and select the source file by its ID. If you add a folder trigger later, map the ID from that trigger to this module. For the first run, use one known file so you can inspect its filename and data in the module output. [Make's guide to working with files](https://help.make.com/working-with-files)

## Map the file into the HTTP request

Use **HTTP → Make a request** in Make's HTTP v4 app. Store your test key under **Credentials** with **API key** authentication. In the keychain, put the full value beginning with `Bearer ` in the **Key** field, choose header placement, set the parameter name to `Authorization`, and restrict it to the origin `https://api.perfectvector.com`. Use the same keychain for the download. [Make's API key setup](https://apps.make.com/api-key-authentication-type)

Use `https://api.perfectvector.com` as the origin for each endpoint below.

| HTTP v4 setting   | Value for the first run                                                                     |
| ----------------- | ------------------------------------------------------------------------------------------- |
| URL and method    | `POST /v1/vectorizations`                                                                   |
| Body content type | `multipart/form-data`                                                                       |
| Body field        | Type **File**, name `image`. Map the filename and file data from **Download a File**.       |
| Header            | `Idempotency-Key`: choose a stable value such as `drive-logo-test-0001` for this operation. |
| Header            | `Prefer: wait=10`                                                                           |
| Parse response    | **Yes**. Run once to populate mappable output fields such as `id` and `status`.             |
| Timeout           | 30 seconds for this request.                                                                |

Make builds the multipart boundary when you choose the body type. Leave the POST response as JSON. That gives you one format to inspect whether the conversion completes immediately or needs more time. The two seconds in PerfectVector's polling guidance refer to the interval between status checks. [Make HTTP modules](https://apps.make.com/http) · [PerfectVector waiting and async](https://perfectvector.com/docs/api/waiting-and-async)

**Workflow illustration**

![An image travels from a source folder through an HTTP request to a conversion record, then as a vector file to a destination folder.](https://perfectvector.com/blog/make-com-vectorize-image-automation/workflow.webp)

*Map the image bytes into the request. Use the conversion ID to check status and fetch the SVG for the output folder.*

## Download only after the conversion succeeds

Filter the route before **HTTP → Download a file** so that it runs only when the parsed conversion status is `succeeded`. Use the same API origin and the path `/v1/vectorizations/{id}/result`. Replace `{id}` with the mapped conversion ID. Use the API keychain and set **Return error if HTTP request fails** to **Yes**. The download module provides file data for the next module. [Make HTTP modules](https://apps.make.com/http) · [PerfectVector results](https://perfectvector.com/docs/api/results)

Add **Google Drive → Upload a File** and choose the output folder. Select the file from **HTTP → Download a file** as the source. To override the name, choose **Map** in the file input, keep the downloaded data, and enter a name such as `logo-test.svg`. Leave **Convert a File** off to keep the SVG in its original format. [Make Google Drive modules](https://apps.make.com/google-drive-modules) Open the uploaded file and look for the “TEST MODE” sample. That checks the mapping through the entire scenario.

| Response from the POST             | Route or recovery                                                                                                                                                                                                                                       |
| ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `201` and `succeeded`              | Download the SVG and upload the file data to Drive.                                                                                                                                                                                                     |
| `202` and `queued` or `processing` | Save the conversion ID for the status check below. Leave the download filter closed.                                                                                                                                                                    |
| `201` and `failed`                 | Record the conversion ID and its error. Stop this route before the download.                                                                                                                                                                            |
| `4xx` or `5xx`                     | Inspect the module error and API problem code, when present. For `429` or `503`, honor `Retry-After` when supplied and reuse the same key and bytes within the replay window. If a live conversion is already in progress, wait for it to finish first. |

## Check a pending conversion before downloading

The run-once scenario covers one test file. If a live submission returns `202`, check it with a second **HTTP → Make a request** module using **GET**, the same API keychain and **Parse response** set to **Yes**. Use the same API origin and the path `/v1/vectorizations/{id}`. Map the saved ID into the path. Route `succeeded` to the result download, leave `queued` and `processing` pending, and record the conversion ID and result error for `failed`. Wait about two seconds before checking a pending ID again. [PerfectVector waiting and async](https://perfectvector.com/docs/api/waiting-and-async)

A client timeout can leave the submission running. Use the saved ID, or replay the same image bytes and key within 24 hours if you have no ID. A terminal `failed` conversion with `timeout` or `provider_unavailable` needs a new key if you choose to retry. Wait until the provider is available for the latter. Persist the key with the source file version before scheduling unattended work, and record pending IDs so the next run can check status before uploading again. [PerfectVector safe retries](https://perfectvector.com/docs/api/idempotency) · [PerfectVector API errors](https://perfectvector.com/docs/api/errors)

We used cURL with a PerfectVector test key to submit the multipart upload, read the conversion by ID, and download the fixed sample SVG. The Make and Google Drive steps follow Make’s official module and file-mapping documentation. Follow the run-once check in your own workspace to verify the mappings.

## FAQ

### Why does my Make scenario return an unsupported media type error?

Check the body content type and the file mapping. Select `multipart/form-data`, name the file field `image`, and map the data output from the download module. Open the original file to verify it is an eligible PNG, JPEG or WebP. [PerfectVector API limits](https://perfectvector.com/docs/api/limits)

### What does the test SVG tell me about my artwork?

It verifies the request and file handoff. PerfectVector returns a fixed sample with a test key. Use a live conversion and inspect the resulting shapes and colors to evaluate your image. [PerfectVector test mode](https://perfectvector.com/docs/api/test-mode)

## Sources

1. [Make — Working with files](https://help.make.com/working-with-files) — Google Drive download and upload mapping for filenames and data.
2. [Make — HTTP](https://apps.make.com/http) — HTTP v4 multipart upload, JSON parsing and file download.
3. [Make — API key authentication](https://apps.make.com/api-key-authentication-type) — Bearer credential storage and service origin restrictions.
4. [PerfectVector — Limits](https://perfectvector.com/docs/api/limits) — Supported input formats and multipart fields.
5. [PerfectVector — Waiting and async](https://perfectvector.com/docs/api/waiting-and-async) — The wait header and the immediate or pending response.
6. [PerfectVector — Results](https://perfectvector.com/docs/api/results) — Authenticated SVG result download.
7. [PerfectVector — Test mode](https://perfectvector.com/docs/api/test-mode) — Fixed test-key SVG and expected immediate success.
8. [Make — Google Drive modules](https://apps.make.com/google-drive-modules) — Download and upload fields and the file conversion option.

***

[Get a test key through the PerfectVector API page](https://perfectvector.com/api) and use the JSON response example in the [API quickstart](https://perfectvector.com/docs/api/quickstart) with one eligible image. Confirm that the upload returns a conversion ID and that downloading its result produces an SVG that opens.

## Explore

- [Read the HTML article](https://perfectvector.com/blog/make-com-vectorize-image-automation)
- [Best AI Image Vectorizers 2026: Top Picks by Use Case](https://perfectvector.com/blog/best-ai-vectorizers-2026.md)
- [Plan a Folder-to-SVG Batch in Claude Code](https://perfectvector.com/blog/batch-vectorize-images-claude-code-mcp.md)
- [Product facts](https://perfectvector.com/product-facts.md)
- [FAQ](https://perfectvector.com/faq.md)
- [Pricing and credits](https://perfectvector.com/pricing.md)