Name: Recraft V4 Styles Pro SVG Styled Vector Image API
Brand: magicapi
SKU: api-magicapi-high-quality-editable-svg-generator-recraft-ai-recraft-v4-styles-pro-svg
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎨 Styled SVG Vector Image Generator API (Recraft V4 Styles Pro SVG)

## Overview
Recraft V4 Styles Pro SVG is a vector image model from Recraft. Its developer describes it as generating high-quality editable vector images that match a reusable style or attached reference images.

Send a text `prompt` and 1 to 10 `style_reference_images`. The model builds a private style from the reference images and draws a new image in that style. Each request returns one SVG image, delivered inline as a data URI, together with a `style_id`.

## Features
- **SVG output**: the result is a vector SVG file, so it scales to any size and can be edited in a vector editor.
- **Style from reference images**: pass 1 to 10 PNG, JPG or WEBP image URLs in `style_reference_images` to set the look of the output.
- **Style strength**: `style_match` is `precise` (default) to follow the style closely or `flexible` to follow it more loosely.
- **Aspect ratios**: `Not set`, `1:1`, `4:3`, `3:4`, `3:2`, `2:3`, `16:9`, `9:16`, `1:2`, `2:1`, `4:5`, `5:4`, `6:10`, `14:10`, `10:14`. The default `Not set` uses `size` instead.
- **Sizes**: `size` sets width and height (default `2048x2048`) and is ignored when an aspect ratio is set.
- **Long prompts**: `prompt` accepts up to 10,000 characters.

## Use Cases
1. **On-brand illustrations**: draw new scenes in the style of existing artwork by passing that artwork as reference images.
2. **Consistent illustration sets**: send the same reference images with each prompt to keep a series of images in one style.
3. **Scalable graphics**: website, app and print graphics that need to stay sharp at any size.
4. **Editable artwork**: SVG output that designers can open and adjust in a vector editor.

## Visual Examples
### Example Input
Prompt: "A cozy corner coffee kiosk on a rainy evening, puddles reflecting the warm window light, with a glowing sign above the counter that reads "api.market"."

Style reference image (`style_reference_images`):

![Style reference image used for the Recraft V4 Styles Pro SVG example](https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp)

`aspect_ratio` was set to `1:1`. All other fields were left at their defaults (`style_match` `precise`).

### Example Output
The API returned an SVG file (2048 x 2048). The picture below is a PNG rendering of that SVG.

![Recraft V4 Styles Pro SVG output rendered as PNG: a corner coffee kiosk on a rainy evening with a sign reading api.market](https://blog.api.market/wp-content/uploads/2026/10/recraft-v4-styles-pro-svg-output-api-market.png)

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `prompt` | string | Yes |  |  | Text prompt for image generation (up to 10,000 characters) |
| `aspect_ratio` | string | No | `Not set` | `Not set`, `1:1`, `4:3`, `3:4`, `3:2`, `2:3`, `16:9`, `9:16`, `1:2`, `2:1`, `4:5`, `5:4`, `6:10`, `14:10`, `10:14` | Aspect ratio of the generated image. `Not set` uses `size` instead |
| `size` | string | No | `2048x2048` | `2048x2048`, `3072x1536`, `1536x3072`, `2560x1664`, `1664x2560`, `2432x1792`, `1792x2432`, `2304x1792`, `1792x2304`, `1664x2688`, `2560x1792`, `1792x2560`, `2688x1536`, `1536x2688` | Width and height of the generated image. Size is ignored if an aspect ratio is set |
| `style_id` | string | No | `""` |  | ID of a reusable Recraft style. Styles are created in Recraft's own style tools, not through this API. Documented as mutually exclusive with style_reference_images |
| `style_reference_images` | array of strings (URLs) | Yes |  |  | PNG, JPG or WEBP reference image URLs used to create a private style for this generation. Supports 1 to 10 images. Documented as mutually exclusive with style_id |
| `style_match` | string | No | `precise` | `precise`, `flexible` | How closely the generated image should follow the style |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.15 per API unit.
- **1 API unit = 1 output image.** Each request returns one SVG image, so each successful request costs $0.15.
- Every input setting (aspect ratio, size, number of reference images, style match) is billed the same.
- The example request above cost $0.15.
- **Failed or cancelled predictions are not billed.**
- **GET requests to check prediction status** are free and don't count toward API unit usage.
- **No monthly subscription fee.**

## API Documentation

### Base URL
All API requests go to: `https://prod.api.market/api/v1/magicapi/high-quality-editable-svg-generator-recraft-ai-recraft-v4-styles-pro-svg`

### Authentication
Send your api.market API key in the `x-api-market-key` header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
**IMPORTANT**: This API is asynchronous. The flow is:
1. Send a POST request to `/predictions`. A successful request returns **201 Created** with a prediction `id` and a `status` of `starting` or `processing`.
2. Poll GET `/predictions/{id}` with that ID.
3. Keep polling while `status` is `starting` or `processing`.
4. Stop when `status` is `succeeded` (read `output`), `failed` or `canceled` (read `error`).

A polling interval of 1 second and an overall timeout of 600 seconds (10 minutes) work well.

### Endpoints

#### Create a Prediction
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/high-quality-editable-svg-generator-recraft-ai-recraft-v4-styles-pro-svg/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "29014fc162fcf199a9e1f04a6e376b682840199203805993ece0a898a12907a8",
    "input": {
      "prompt": "A cozy corner coffee kiosk on a rainy evening, puddles reflecting the warm window light, with a glowing sign above the counter that reads \"api.market\".",
      "style_reference_images": [
        "https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp"
      ],
      "aspect_ratio": "1:1"
    }
  }'
```

Response (201 Created):
```json
{
  "id": "rsm74dmygdrmy0d17g4svzfvr8",
  "version": "29014fc162fcf199a9e1f04a6e376b682840199203805993ece0a898a12907a8",
  "status": "starting",
  "created_at": "2026-10-14T20:10:25.921Z"
}
```

#### Check Prediction Status
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/high-quality-editable-svg-generator-recraft-ai-recraft-v4-styles-pro-svg/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "rsm74dmygdrmy0d17g4svzfvr8",
  "status": "succeeded",
  "output": {
    "image": "data:image/svg+xml;base64,PHN2Zy...",
    "style_id": "67520668-eb17-4567-8e45-e5835f2b059a"
  },
  "error": null,
  "created_at": "2026-10-14T20:10:25.921Z",
  "started_at": "2026-10-14T20:10:26.921Z",
  "completed_at": "2026-10-14T20:10:58.921Z"
}
```

`output` is an object. `image` is the generated SVG as an inline data URI (`data:image/svg+xml;base64,...`); the value above is truncated, a real response contains the full base64-encoded SVG, which can run to several megabytes. Decode the base64 part after the comma to get the `.svg` file. `style_id` is a string (or `null`) identifying the style used for the generation.

### Status Codes
- **201 Created**: prediction created (POST `/predictions`). This is the normal success response.
- **200 OK**: prediction details returned (GET `/predictions/{id}`).
- **400 Bad Request**: invalid input, for example a missing `prompt` or `style_reference_images`, or an `aspect_ratio` that is not in the list.
- **401 Unauthorized**: missing or invalid API key.
- **404 Not Found**: no prediction with that ID.
- **429 Too Many Requests**: rate limit exceeded.
- **500 Internal Server Error** or **503 Service Unavailable**: temporary server problem; retry later.

## Rate Limits

All plans allow 10 requests per second. Requests above that return `429 Too Many Requests`; back off before retrying and honour any `Retry-After` header. Polling a prediction with GET is free but still counts toward the per-second limit, so poll every 1 to 5 seconds rather than in a tight loop.

## Error Handling
- Check the HTTP status code of every request and read the response body for the error message.
- A prediction can also end with `status` set to `failed`; the `error` field then explains why. Failed predictions are not billed.
- Retry 429, 500 and 503 responses with exponential backoff. Fix the input before retrying a 400.

## Implementation Guide
### Example Code

#### JavaScript
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/high-quality-editable-svg-generator-recraft-ai-recraft-v4-styles-pro-svg";

async function createAndWaitForPrediction(input) {
  const response = await fetch(`${baseUrl}/predictions`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-market-key": apiKey
    },
    body: JSON.stringify({ version: "29014fc162fcf199a9e1f04a6e376b682840199203805993ece0a898a12907a8", input })
  });

  if (response.status !== 201) {
    throw new Error(`API error: ${response.status} ${await response.text()}`);
  }

  const prediction = await response.json();
  return pollForResults(prediction.id);
}

const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function pollForResults(predictionId) {
  const maxTimeout = 600000;
  const pollInterval = 1000;
  const startTime = Date.now();

  while (Date.now() - startTime < maxTimeout) {
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: { "x-api-market-key": apiKey }
    });

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${await response.text()}`);
    }

    const prediction = await response.json();

    if (prediction.status === "succeeded") {
      return prediction.output;
    }

    if (prediction.status === "failed" || prediction.status === "canceled") {
      throw new Error(`Prediction ${prediction.status}: ${prediction.error || "Unknown error"}`);
    }

    await delay(pollInterval);
  }

  throw new Error("Prediction timed out after 10 minutes");
}

createAndWaitForPrediction({
  "prompt": "A cozy corner coffee kiosk on a rainy evening, puddles reflecting the warm window light, with a glowing sign above the counter that reads \"api.market\".",
  "style_reference_images": [
    "https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp"
  ],
  "aspect_ratio": "1:1"
}).then((output) => console.log(output));
```

#### Python
```python
import time
import requests

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/high-quality-editable-svg-generator-recraft-ai-recraft-v4-styles-pro-svg"

def create_and_wait_for_prediction(input_data):
    headers = {"Content-Type": "application/json", "x-api-market-key": API_KEY}
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={"version": "29014fc162fcf199a9e1f04a6e376b682840199203805993ece0a898a12907a8", "input": input_data},
    )

    if response.status_code != 201:
        raise Exception(f"API error: {response.status_code} {response.text}")

    return poll_for_results(response.json()["id"])

def poll_for_results(prediction_id):
    max_timeout = 600
    poll_interval = 1
    headers = {"x-api-market-key": API_KEY}
    start_time = time.time()

    while time.time() - start_time < max_timeout:
        response = requests.get(f"{BASE_URL}/predictions/{prediction_id}", headers=headers)

        if response.status_code != 200:
            raise Exception(f"API error: {response.status_code} {response.text}")

        prediction = response.json()

        if prediction["status"] == "succeeded":
            return prediction["output"]

        if prediction["status"] in ("failed", "canceled"):
            raise Exception(f"Prediction {prediction['status']}: {prediction.get('error') or 'Unknown error'}")

        time.sleep(poll_interval)

    raise Exception("Prediction timed out after 10 minutes")

print(create_and_wait_for_prediction({
    "prompt": "A cozy corner coffee kiosk on a rainy evening, puddles reflecting the warm window light, with a glowing sign above the counter that reads \"api.market\".",
    "style_reference_images": ["https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp"],
    "aspect_ratio": "1:1"
}))
```

## FAQ
- **What format is the output?**
  - An SVG vector image, returned inline in `output.image` as a base64 data URI. Decode the part after `base64,` and save it as an `.svg` file.
- **Do I have to send reference images?**
  - Yes. `style_reference_images` is required on every request and takes 1 to 10 PNG, JPG or WEBP image URLs.
- **Can I use `style_id` instead of reference images?**
  - Not on its own. `style_id` is documented as mutually exclusive with `style_reference_images`, but `style_reference_images` is required, so send your reference images with every request and leave `style_id` empty. To keep a series consistent, reuse the same reference images.
- **Which takes priority, `aspect_ratio` or `size`?**
  - `aspect_ratio`. `size` is only used when `aspect_ratio` is `Not set` (the default).
- **How many images does one request return?**
  - One. Each image is billed as one API unit ($0.15).
- **What if my prediction fails?**
  - Failed predictions are not billed. Read the `error` field, adjust the input and try again.

## Contact Us

If you have any questions or need assistance, you can reach out to us through the embedded chat on the bottom right corner of the page or send an email to hello@magicapi.com.


Generate editable SVG vector images that match the style of 1 to 10 reference images with Recraft V4 Styles Pro SVG. $0.15 per image, pay as you go.