Most AI image generators output a flat raster file and stop there. Recraft AI does something the rest of the category still struggles with: it generates true SVG vector graphics, complete with editable paths, alongside raster images, and it ties both to a brand style system designers can reuse across a whole project. As of August 2026, Recraft’s current model family, V4.1, ships eight variants split across raster and vector output, and the company just released a new “V4 Styles” line built specifically for style-consistent generation across a batch of assets. This tutorial covers the full setup: the web app, the API, pricing by model tier, vector-specific workflows, and a working Python integration you can drop into a design pipeline.
Whether you’re a developer automating asset generation or a designer trying to cut down on repetitive icon and logo work, the steps below get you from a blank account to a functioning pipeline, including the pitfalls that trip up most people using Recraft for the first time. We’ll build two complete working projects along the way: a batch icon set generator that produces a consistent visual family from a list of concepts, and a lightweight style registry pattern for teams managing more than one brand identity through the same account.
What Makes Recraft AI Different From Other Image Generators
The single feature that separates Recraft from Midjourney, GPT Image, or Flux is native SVG output. Most AI image tools generate a raster image and, at best, offer a separate auto-trace or vectorization pass that approximates the shapes after the fact, often producing messy paths that need cleanup before they’re usable in production design software. Recraft’s vector models generate the SVG directly as part of the model’s output, which means logos, icons, and illustrations arrive as clean, scalable, editable paths ready to open in Illustrator, Figma, or any SVG-compatible tool.
The second differentiator is Recraft’s style system. Rather than re-describing an aesthetic in every prompt, you can define a style once (color palette, line weight, illustration approach) and apply it consistently across dozens of generations, which matters enormously for brand work where every icon in a set needs to look like it came from the same design system. Google’s Nano Banana Pro and OpenAI’s GPT Image 2 both handle single, richly detailed images well, but neither treats “consistent style across a batch” as a first-class product feature the way Recraft does.
The tradeoff is that Recraft is not the strongest choice for photorealism. If your task is a hyperrealistic product photo or a cinematic scene, Flux 2 Pro or Nano Banana Pro will generally out-perform Recraft on raw photographic fidelity. Recraft’s strength is design production: logos, icons, illustrations, packaging mockups, and marketing assets that need to be both good-looking and immediately usable in a design tool, not just a finished picture.
Prerequisites Before You Start
- A free Recraft account, created at recraft.ai with an email address or Google sign-in
- Python 3.10 or later for the API sections (verify with
python3 --version) - The
requestslibrary installed viapip install requests, since Recraft’s API does not require a dedicated SDK - A credit card if you plan to move past the free tier, since API access requires a funded account
- Basic familiarity with REST APIs and JSON request bodies
- A vector-editing tool such as Adobe Illustrator, Figma, or Inkscape if you plan to work with the SVG output beyond simple export
- About 90 minutes to complete every step in this tutorial, including testing both raster and vector generation
Step 1: Create a Recraft Account and Explore the Web App
Go to recraft.ai and sign up with an email address or a Google account. The free tier gives you a limited daily allotment of generations, enough to test the interface and get a feel for how the model responds to prompts before committing to a paid plan. Once inside, the main generation screen presents a prompt box, a style selector, and a model toggle for switching between raster and vector output.
Spend the first few minutes exploring the style library. Recraft ships with dozens of built-in styles spanning flat illustration, 3D render, photographic, line art, and icon-specific presets. Selecting a built-in style before you write a single custom prompt is the fastest way to understand what the model is actually capable of, and it saves you from spending your daily free-tier quota on trial-and-error prompt writing.
Step 2: Generate Your First Raster Image
In the web app, select the default V4.1 raster model, choose a style (start with “Realistic” or “Flat Illustration” to see the range), and enter a prompt. A useful test prompt for evaluating quality:
A minimalist icon set representing cloud storage, security, and
data sync, flat design, consistent line weight, single accent
color on a white backgroundGenerate and review the result. Note that Recraft’s raster output at the standard V4.1 tier is 1K resolution by default, with the Pro variant stepping up to 2K. If the image needs to be larger for print or a hero banner, you will need the Pro model tier, covered in Step 5.
Step 3: Generate a True SVG Vector Image
Switch the model toggle to a Vector variant (V4.1 Vector) and run the same or a similar prompt. The output arrives as an SVG file you can download directly, not a raster image with a vectorization filter applied afterward. Open the downloaded file in Illustrator, Figma, or Inkscape and check the path structure: because it’s a genuine vector generation, individual shapes should be editable and scalable to any size without quality loss, which is the entire point of using Recraft over a raster-first competitor for logo and icon work.
Vector generation costs more per image than raster (covered in the pricing table below), so reserve it for assets that genuinely need to be scalable, editable production files, rather than defaulting to vector mode for every generation.
Step 4: Build and Apply a Custom Brand Style
This is Recraft’s signature feature for teams doing repeated design work. From the style panel, choose “Create style,” and either upload a set of reference images that define the look you want (color palette, illustration technique, line weight) or fine-tune from an existing built-in style. Recraft’s August 2026 release, internally called V4 Styles, was built specifically to improve consistency when this custom style is applied across many separate generations, which was previously a weak point where later generations in a batch would visibly drift from the first.
Once saved, the custom style gets a style ID you can reuse both in the web app and, more importantly, in API calls, which is what turns a one-off design exercise into a repeatable pipeline. Save the style ID somewhere you can find it again, since you will need it in Step 7.
Step 5: Understand Recraft’s Model Tiers and Pricing
Recraft bills API usage in “API units,” where $1 equals 1,000 units, rather than a flat dollar figure per call. This matters because different operations (a full generation, a background removal, an upscale) consume different unit amounts, and understanding the unit cost of each operation is the difference between a predictable monthly bill and an unpleasant surprise.
| Model / operation | API units | Approx. USD cost | Output |
|---|---|---|---|
| Recraft V4.1 (default) | 35 | $0.035 | Raster, 1K |
| Recraft V4.1 Pro | 210 | $0.21 | Raster, 2K |
| Recraft V4.1 Vector | 80 | $0.08 | SVG vector |
| Recraft V4.1 Pro Vector | 330 | $0.33 | SVG vector, higher fidelity |
| Image-to-image / inpainting / style creation | 44 | $0.044 | Varies by operation |
| Background removal | 11 | $0.011 | Raster |
| Vectorization (raster to SVG) | 11 | $0.011 | SVG |
| Crisp upscale | 4.4 | $0.0044 | Raster |
| Creative upscale | 252.5 | $0.2525 | Raster, enhanced detail |
The takeaway from this table: a standard V4.1 raster generation at $0.035 is competitively priced against most frontier image models, but the Pro Vector tier at $0.33 per image is a meaningful jump, and creative upscale at over $0.25 is the single most expensive line item on the list. Reserve Pro Vector and creative upscale for final production assets, and prototype with the base V4.1 raster and vector tiers, which run at roughly a tenth of the cost.
For consumer subscription pricing beyond pay-as-you-go API billing, Recraft offers monthly plans with daily or monthly credit allotments through the web app; check the current figures on Recraft’s pricing page before committing, since subscription tiers and included credits are the numbers most likely to shift between releases.
Step 6: Get Your API Key
In the Recraft web app, open your account settings and find the API section. Generate a new API key and copy it immediately, since it will not be displayed again in full. Store it as an environment variable rather than hardcoding it into any script:
export RECRAFT_API_KEY="your-api-key-here"
# Verify it loaded
echo $RECRAFT_API_KEYAPI access requires a funded account; you cannot make authenticated API calls purely against unused free-tier web app credits, so add a payment method under billing before attempting the requests in the next step.
Step 7: Make Your First API Request
Recraft’s image generation API is OpenAI-compatible in its request shape, which means the JSON body should look familiar if you’ve worked with any other major image API. The endpoint is:
POST https://external.api.recraft.ai/v1/images/generationsHere is a minimal Python script that generates a raster image and saves the result:
import os
import requests
API_KEY = os.environ["RECRAFT_API_KEY"]
URL = "https://external.api.recraft.ai/v1/images/generations"
headers = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json",
}
payload = {
"model": "recraftv4_1",
"prompt": "A flat-style icon of a padlock inside a shield, "
"single accent color, white background, consistent "
"2px line weight",
"n": 1,
"size": "1024x1024",
"response_format": "url",
}
response = requests.post(URL, headers=headers, json=payload, timeout=60)
response.raise_for_status()
data = response.json()
image_url = data["data"][0]["url"]
print(f"Generated image: {image_url}")
# Download the file locally
img_bytes = requests.get(image_url, timeout=30).content
with open("recraft_output.png", "wb") as f:
f.write(img_bytes)
print("Saved recraft_output.png")Run the script. A successful call returns a JSON payload with a data array containing a hosted URL for the generated image, which the script then downloads and saves locally. If model is omitted from the payload entirely, Recraft defaults to recraftv4_1, but specifying it explicitly is better practice for any script you intend to maintain over time, since Recraft has changed its default model with past major releases.
Step 8: Generate SVG Vectors Through the API
To get true vector output instead of raster, swap the model parameter to one of the vector variants. The response format and download step change slightly since the payload is SVG markup rather than a raster image URL in some configurations, so check the response_format and content type Recraft returns for vector calls specifically:
payload = {
"model": "recraftv4_1_vector",
"prompt": "A simple line-art logo of a mountain peak inside a "
"circle, monochrome, suitable for a tech startup",
"n": 1,
"response_format": "url",
}
response = requests.post(URL, headers=headers, json=payload, timeout=60)
response.raise_for_status()
data = response.json()
svg_url = data["data"][0]["url"]
svg_content = requests.get(svg_url, timeout=30).content
with open("logo_vector.svg", "wb") as f:
f.write(svg_content)
print("Saved logo_vector.svg")Open the resulting SVG in a text editor first to confirm it is valid, well-formed vector markup rather than an embedded raster image wrapped in an SVG container, which is a shortcut some cheaper “vector” tools use. Recraft’s vector models generate genuine path data, so the file should be readable and editable in any standard vector tool without a conversion step.
Step 9: Apply Your Custom Brand Style via API
Using the style ID you saved in Step 4, pass it as an additional field in the request payload to apply your brand style consistently across API-generated images, the same way you would in the web interface:
payload = {
"model": "recraftv4_1",
"prompt": "An icon representing customer support, headset and "
"speech bubble",
"style_id": "your-saved-style-id",
"n": 1,
"size": "1024x1024",
"response_format": "url",
}This is the pattern that makes Recraft genuinely useful for production icon sets: define the style once through the web app or a style-creation API call, then loop through a list of prompts (one per icon) while holding the style ID constant, producing a visually consistent set without manually re-describing the aesthetic in every single prompt.
Step 10: Build a Batch Icon Set Generator
Here is a complete working project: a script that reads a list of icon concepts and generates a consistent set using a single saved style, with basic error handling for failed requests.
import os
import time
import requests
API_KEY = os.environ["RECRAFT_API_KEY"]
URL = "https://external.api.recraft.ai/v1/images/generations"
STYLE_ID = os.environ.get("RECRAFT_STYLE_ID")
HEADERS = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json",
}
ICON_SET = [
("cloud-storage", "an icon of a cloud with an upward arrow"),
("security", "an icon of a shield with a checkmark"),
("sync", "an icon of two circular arrows forming a loop"),
("notifications", "an icon of a bell with a small dot badge"),
("settings", "an icon of a gear with rounded teeth"),
]
def generate_icon(name, description, vector=True, max_retries=3):
model = "recraftv4_1_vector" if vector else "recraftv4_1"
payload = {
"model": model,
"prompt": f"A minimalist flat icon: {description}, single "
f"accent color, white background, consistent style",
"n": 1,
"response_format": "url",
}
if STYLE_ID:
payload["style_id"] = STYLE_ID
for attempt in range(max_retries):
try:
resp = requests.post(URL, headers=HEADERS, json=payload, timeout=60)
if resp.status_code == 429:
wait = 2 ** attempt * 5
print(f"Rate limited, waiting {wait}s")
time.sleep(wait)
continue
resp.raise_for_status()
data = resp.json()
file_url = data["data"][0]["url"]
content = requests.get(file_url, timeout=30).content
ext = "svg" if vector else "png"
out_path = f"icons/{name}.{ext}"
os.makedirs("icons", exist_ok=True)
with open(out_path, "wb") as f:
f.write(content)
return out_path
except requests.exceptions.HTTPError as e:
print(f"Failed to generate {name}: {e}")
return None
print(f"Gave up on {name} after {max_retries} retries")
return None
if __name__ == "__main__":
for name, description in ICON_SET:
result = generate_icon(name, description)
if result:
print(f"Saved {result}")
time.sleep(1)Run the script with python generate_icon_set.py. It produces an icons/ directory with one file per concept, all rendered through the same style ID for visual consistency, a task that would take considerably longer through the web interface one generation at a time.
Step 11: Post-Process With Background Removal and Upscaling
Recraft’s API exposes background removal and upscaling as separate, cheaper operations rather than bundling them into every generation call, which keeps costs down when you only need one of these on a subset of images. Background removal runs at roughly 11 API units ($0.011), a fraction of a full generation, making it worth using liberally on product shots or icons that need a transparent background for downstream use in a design tool.
bg_removal_payload = {"image_url": "https://your-hosted-image-url.png"}
resp = requests.post(
"https://external.api.recraft.ai/v1/images/removeBackground",
headers=HEADERS,
json=bg_removal_payload,
timeout=60,
)
resp.raise_for_status()
transparent_url = resp.json()["data"][0]["url"]Upscaling comes in two tiers: a cheap “crisp upscale” for a straightforward resolution increase, and a considerably more expensive “creative upscale” that adds enhanced detail rather than simply interpolating pixels. Use crisp upscale by default and reserve creative upscale for hero images where the added cost is justified by the visible quality gain.
Step 12: Export and Integrate Into Your Design Workflow
Once you have a batch of generated assets, the last step is getting them into whatever tool your design team actually uses. SVG files generated through Recraft import cleanly into Figma via drag-and-drop or the standard SVG import flow, and they open directly in Illustrator without a “trace image” step. For teams working in a design system, consider committing the generated SVGs to a shared component library rather than treating them as one-off exports, since Recraft’s style consistency means a batch generated together will look cohesive enough to serve as a genuine icon library rather than a loose collection of similar-but-not-quite-matching assets.
5 Common Pitfalls When Using Recraft AI
1. Defaulting to vector mode for everything. Vector generation costs more than double the base raster tier per image. Use raster for anything that will only ever be displayed at a fixed size (a social post, a web banner) and reserve vector for assets that genuinely need to scale or be edited as paths.
2. Confusing API units with dollars in cost estimates. Because Recraft bills in units where $1 equals 1,000 units, it’s easy to misread a “252.5 unit” creative upscale as a trivial cost when it is actually a quarter of a dollar per image, which adds up fast across a large batch.
3. Skipping the style system and re-describing aesthetics in every prompt. Without a saved style ID, batch-generated assets drift visually from one image to the next, even with careful prompt engineering. Set up a style once and reuse the ID rather than trying to replicate consistency through prompt text alone.
4. Expecting photorealistic output. Recraft is a design-first tool. If a project needs photorealistic photography-style images, a model like Flux 2 Pro or Nano Banana Pro will consistently outperform Recraft, which is tuned for illustration, icon, and brand-asset generation rather than photographic realism.
5. Not verifying SVG file validity before handing off to a designer. Occasionally a vector export contains embedded raster elements rather than pure path data, particularly for very photographic or texture-heavy prompts that do not translate cleanly to vector shapes. Open every SVG in a text editor or vector tool before delivering it downstream to confirm it is genuinely editable.
Expected Output Examples
A successful raster generation call returns a JSON body structured like this:
{
"created": 1735689600,
"data": [
{
"url": "https://cdn.recraft.ai/generations/abc123.png"
}
]
}The batch icon script from Step 10 produces console output similar to this on a successful run:
Saved icons/cloud-storage.svg
Saved icons/security.svg
Rate limited, waiting 5s
Saved icons/sync.svg
Saved icons/notifications.svg
Saved icons/settings.svgTroubleshooting Guide: 8 Issues and Fixes
1. 401 Unauthorized on every request. Your API key is missing, malformed, or expired. Confirm the Authorization: Bearer header is set correctly and that the key was copied in full when generated, since truncated keys are a common copy-paste error.
2. 402 Payment Required or a billing error. Your account has no funded balance. API access requires an active payment method on file; free-tier web app credits do not carry over to API usage.
3. Vector model returns unexpected raster-looking output. Confirm you specified a vector-suffixed model value (e.g. recraftv4_1_vector) and not the base raster model. Omitting the vector suffix silently falls back to raster generation.
4. Style ID not being applied. Double-check the style was fully saved in the web app (styles can take a moment to finish processing after creation) before referencing its ID in an API call. Calling the API with an ID for a style still processing will typically fall back to the default aesthetic.
5. 429 Too Many Requests. You’ve hit a rate limit tied to your account tier. Implement exponential backoff, as shown in the batch script in Step 10, and space out large batch jobs rather than firing all requests concurrently.
6. Generated SVG fails to open in Illustrator. This is rare but can occur with malformed markup on edge-case prompts. Validate the SVG with an online validator or open it in a browser first; if it renders in a browser but fails in Illustrator, try re-exporting through Figma as an intermediate step.
7. Background removal returns an image with visible fringing. This typically happens on subjects with fine detail (hair, fur, semi-transparent edges) where the alpha mask struggles. Consider generating the original image with a solid, high-contrast background specifically to make removal cleaner, rather than relying on the removal step to salvage a poor original.
8. Costs higher than expected at month end. Audit whether your pipeline is defaulting to Pro or Pro Vector tiers unnecessarily. These cost six to ten times the base V4.1 tier per image, and a script that doesn’t explicitly pin the model parameter can silently shift tiers after an account or default change.
Advanced Tips for Production Use
For teams generating large icon libraries or brand asset sets, batch prompts in small groups (five to ten at a time) rather than one enormous run, so a single failed or rate-limited request doesn’t force you to restart an entire multi-hour job. Log every prompt, style ID, and resulting file path to a simple CSV or database as you go, which makes it trivial to regenerate a single asset later without reconstructing the original prompt from memory.
When building a style, feed it reference images that are already close to your target aesthetic rather than expecting the model to interpolate from a vague text description alone. A style built from three to five well-chosen reference images consistently produces more reliable results than one built from a text prompt describing the desired look in the abstract.
Finally, treat vectorization (converting an existing raster image to SVG) as a distinct tool from vector generation. If you already have a raster image you like and just need it as editable paths, the vectorization endpoint at roughly $0.011 per image is far cheaper than regenerating the same concept through a vector model from scratch, and it preserves the exact composition you already approved.
One more habit worth building early: keep a small “known good” prompt library for each recurring asset type your team generates. If your product needs a new settings icon every few months as features ship, save the exact prompt structure, style ID, and model tier that produced the best previous result, rather than reconstructing the approach from memory each time. Over a year of steady use, this turns Recraft from a tool someone has to relearn each session into an actual repeatable production step with predictable output quality and cost.
Recraft vs Ideogram: Choosing the Right Tool for Design Work
Recraft and Ideogram 4.0 both get recommended for design-adjacent AI image work, but they solve different problems. Ideogram’s strength is typography accuracy inside a raster image, reaching roughly 0.97 OCR accuracy on rendered text according to comparison benchmarks circulating in mid-2026, which makes it the better pick for posters, social graphics, and anything where dense, readable text embedded in the image is the primary requirement. Recraft’s strength is editable, scalable output and cross-asset consistency, which makes it the better pick for logos, icon systems, and any deliverable that needs to leave the AI tool as a working design file rather than a finished picture.
| Use case | Recraft | Ideogram |
|---|---|---|
| Editable vector logos and icons | Native SVG generation, strong fit | Raster only, needs separate vectorization |
| Brand style consistency across a batch | Dedicated style system with saved style IDs | Prompt-driven, less centralized |
| Dense in-image text and typography | Adequate, not the primary strength | Strong, frequently top-ranked for text accuracy |
| Photorealistic photography | Weaker fit | Moderate |
| Cost per base-tier image | ~$0.035 (raster) | ~$0.03–0.10 (2K) |
Many design teams end up using both: Ideogram for text-heavy marketing assets, Recraft for the logo, icon set, and brand system that needs to remain editable long after the initial generation.
Rate Limits and Account Tiers
Recraft does not publish a single fixed numeric rate-limit table publicly; limits scale with account tier and billing history, similar to most metered AI APIs. Free-tier and newly created accounts should expect conservative caps on both requests per minute and total daily generations. Established, funded accounts with consistent usage typically see higher effective limits. If your pipeline needs guaranteed throughput for a launch or a large one-time batch job, reach out to Recraft’s support or account team in advance rather than assuming your current limits will cover a sudden spike in volume.
Build your batch scripts to assume rate limiting will happen rather than treating it as an edge case. The retry-with-backoff pattern used throughout this tutorial (Steps 10 and the batch icon generator) handles the common case cleanly, but for genuinely large jobs, consider adding a fixed delay between requests from the start (even a conservative one-second pause) rather than relying entirely on reactive backoff after a 429 response, since that approach tends to produce steadier throughput over a long-running job than a burst-then-back-off pattern.
Real-World Use Cases: What Teams Build With Recraft
Four use cases show up repeatedly among teams that have adopted Recraft into a production workflow. The first is icon library generation for SaaS products, where a design or engineering team needs 40 to 100 consistent icons for a settings menu, dashboard, or onboarding flow. Before tools like Recraft, this work either meant hiring a designer for a dedicated icon sprint or piecing together a mismatched set from stock icon libraries. Recraft’s style system, combined with batch API calls like the script built in Step 10, compresses that into an afternoon of prompt writing and review rather than a multi-week design engagement.
The second is logo concepting for early-stage startups and freelance designers pitching multiple directions to a client. Because vector output is immediately editable, a designer can generate a dozen logo directions, narrow to three finalists, then continue refining the winning concept by hand in Illustrator rather than starting from a raster reference and rebuilding it as vectors from scratch. This shifts AI generation from a “mood board” tool into something closer to an actual first-draft production step.
The third is packaging and print mockups, where Recraft’s flat-illustration and pattern-generation strengths handle repeating background patterns, box art, and label designs that need to tile or scale cleanly across different package sizes. The fourth, increasingly common among marketing teams, is social media template generation: a base style is defined once for a brand’s visual identity, then dozens of on-brand graphics get generated against that style for a content calendar, keeping visual consistency without a designer manually building each asset from a template file.
Setting Up a Multi-Style Design System
Teams working across multiple product lines or sub-brands often need more than one saved style. Rather than treating style creation as a one-time setup step, build a small internal registry mapping each brand or product line to its style ID, similar to how a design system maintains a token file for colors and spacing. A simple JSON file checked into your project repository works well for this:
{
"styles": {
"primary-brand": "style_a1b2c3d4",
"product-line-icons": "style_e5f6g7h8",
"marketing-social": "style_i9j0k1l2"
}
}Reference this file from your generation scripts rather than hardcoding style IDs inline, so a style update (say, a rebrand that requires a refreshed style) only requires updating one entry rather than hunting through every script that references the old ID. This also makes it straightforward for a non-developer on the design team to update the registry themselves once a new style is finalized, without needing to touch the generation code directly.
When a rebrand or style refresh happens, keep the old style ID in the registry under a clearly deprecated key rather than deleting it outright. Regenerating a past asset for a historical reference or an archived campaign sometimes requires reproducing the exact original style, and losing the ID makes that impossible without recreating the style from scratch and hoping the result matches closely enough.
Security and Cost Governance
Treat a Recraft API key with the same operational care as any other production credential. Store it in a secrets manager rather than a plaintext environment file for any deployment beyond local development, and rotate it periodically, particularly after any team member with access to it leaves the project. Never embed the key in client-side code, since Recraft’s API is designed for server-side or backend use and a key exposed in a browser bundle can be extracted and abused within minutes of a public deployment.
Because API usage is metered per operation rather than a flat subscription, set up basic spend monitoring before running any large batch job. A simple safeguard: track cumulative API units consumed within your own script (summing the unit cost per call type from the pricing table in Step 5) and halt the job if it crosses a pre-set threshold, rather than discovering an unexpectedly large bill only after checking the account dashboard at the end of the month. This is especially relevant for creative upscale calls, which at roughly $0.25 per image are the single most expensive line item Recraft offers, and an accidental loop calling that endpoint repeatedly can rack up cost quickly.
Frequently Asked Questions
What is the current version of Recraft AI?
As of August 2026, Recraft’s current model family is V4.1, spanning raster, vector, Pro, and Utility variants. Recraft also released a new “V4 Styles” line in August 2026 focused specifically on style-consistent generation across batches.
Does Recraft actually generate real SVG files, or just trace a raster image?
Recraft’s vector model variants (model names ending in _vector) generate genuine SVG path data directly as part of the model’s output, rather than producing a raster image and running a separate auto-trace pass afterward.
How much does the Recraft API cost per image?
The base V4.1 raster model costs 35 API units (about $0.035) per image. Vector generation costs 80 units (~$0.08), Pro raster costs 210 units (~$0.21), and Pro Vector costs 330 units (~$0.33). Recraft bills at a rate of 1,000 API units per $1.
What model parameter should I use in API calls?
The default model is recraftv4_1 for standard raster output. Use recraftv4_1_vector for SVG output, and add _pro to either (e.g. recraftv4_1_pro, recraftv4_1_pro_vector) for higher-resolution or higher-fidelity generation at a higher cost.
Is Recraft better than Ideogram for logo design?
For logos and icons that need to remain editable as vector paths, Recraft is generally the better fit due to its native SVG generation. Ideogram is competitive for logo concepts that involve dense typography but will require a separate vectorization step to become an editable design file.
Can I use Recraft-generated images commercially?
Commercial use is available under Recraft’s terms of service and paid subscription or API billing tiers; verify the specific licensing terms for your use case and account type on Recraft’s official pricing and terms pages before publishing commercial work.
Why does my batch of icons look inconsistent even though I used the same prompt style?
Text-only prompt consistency has real limits. Save a custom style through the web app or style-creation API endpoint and reference its style ID in every generation call in the batch, rather than relying on repeated text descriptions alone to maintain a consistent look.
What’s the cheapest way to get an SVG from an image I already have?
Use Recraft’s vectorization endpoint, priced at roughly 11 API units (about $0.011) per image, rather than regenerating the concept through a vector model from scratch, which costs several times more.