# Analytics API
Source: https://docs.magnific.com/api-reference/analytics/overview
Track your team AI credit consumption and discover team resources with the Magnific Analytics API.
Programmatic access to the same credit usage data available in your dashboard and CSV export.
The Analytics API lets you retrieve your team's AI credit consumption data programmatically. Integrate usage data directly into your reporting pipelines, BI tools, or internal dashboards.
Available exclusively for **Business** and **Enterprise** plans at no additional cost. It does not consume credits.
## Credit usage
Query credit consumption over time with [`POST /v1/analytics/team-credit-usage`](/api-reference/analytics/team-credit-usage/query). Each response includes per-user breakdown with email addresses and per-project grouping automatically.
```bash theme={null}
curl -X POST https://api.magnific.com/v1/analytics/team-credit-usage \
-H "X-Magnific-API-Key: YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"granularity": "day",
"start_date": "2026-05-01",
"end_date": "2026-05-31",
"group_ids": [10]
}'
```
### Example response
```json theme={null}
{
"data": [
{
"date": "2026-05-01T00:00:00+00:00",
"consumptions": [
{
"tool": "AI Image Models",
"user_uses": 45,
"user_credits": 1800,
"user_usages": [
{
"user_email": "designer@company.com",
"user_uses": 30,
"user_credits": 1200,
"project_reference": "a1b2c3d4-1111-4000-8000-000000000001",
"project_name": "Marketing Campaign",
"group_name": "Design Team"
},
{
"user_email": "developer@company.com",
"user_uses": 15,
"user_credits": 600
}
]
},
{
"tool": "Asset Download",
"user_uses": 10,
"user_credits": 900
}
]
}
]
}
```
### Filtering
Narrow down results to specific subsets of your team:
| Filter | What it does | Where to get the IDs |
| -------------------- | ----------------------------------------------------- | --------------------------------------------------------------------------- |
| `group_ids` | Show only consumption from members of specific groups | [`GET /v1/analytics/team-groups`](/api-reference/analytics/team-groups) |
| `project_references` | Show only consumption within specific projects | [`GET /v1/analytics/team-projects`](/api-reference/analytics/team-projects) |
| `api_key_ids` | Show only consumption from specific API keys | [`GET /v1/analytics/team-api-keys`](/api-reference/analytics/team-api-keys) |
### Time granularity
The `granularity` parameter controls the time bucket size. Defaults to `day`.
| Value | Description | Best for |
| ------- | ------------------------------------------- | ----------------------------- |
| `day` | One data point per calendar day | Short ranges (up to 30 days) |
| `week` | One data point per ISO week (Monday–Sunday) | Medium ranges (1–3 months) |
| `month` | One data point per calendar month | Quarterly or yearly overviews |
| `year` | One data point per calendar year | Multi-year trend analysis |
### Date range limits
* If no dates are provided, returns the **last 7 days**
* **Enterprise**: maximum 365 days
* **Business**: maximum 180 days
## Discovery endpoints
Four companion endpoints let you list team resources and get the IDs needed for filtering credit usage:
| Endpoint | Returns |
| --------------------------------------------------------------------------- | ------------------------------------ |
| [`GET /v1/analytics/team-members`](/api-reference/analytics/team-members) | Members with email, role, and status |
| [`GET /v1/analytics/team-api-keys`](/api-reference/analytics/team-api-keys) | API keys with name and status |
| [`GET /v1/analytics/team-groups`](/api-reference/analytics/team-groups) | Groups with name and member count |
| [`GET /v1/analytics/team-projects`](/api-reference/analytics/team-projects) | Projects with name |
Cache discovery results — team composition changes infrequently.
## Authentication
All endpoints authenticate with the `X-Magnific-API-Key` header. Your team is identified automatically from the API key. See [Authentication](/authentication) for details.
## Rate limits
All Analytics API endpoints are limited to **10,000 requests per day** (10,000 RPD) per API key on the **Business** and **Enterprise** plans, the only plans where the Analytics API is available.
## API reference
Query credit consumption over time with filters
List members with email, role, and status
List API keys with name and status
List groups with member count
List projects with name
## Frequently Asked Questions
The same data available in your Credit Usage dashboard and CSV export: date, tool (display name), user email, usage count, credits consumed, project, and group. The difference is structured JSON instead of flat CSV rows.
No. The Analytics API is included with your Business or Enterprise plan at no additional cost.
Call the discovery endpoints first. For example, `GET /v1/analytics/team-groups` returns all your groups with their `group_id`. Pass those IDs into the `group_ids` filter when querying credit usage. The same applies to projects (`project_references`) and API keys (`api_key_ids`).
Enterprise plans can query up to 365 days. Business plans can query up to 180 days. If no dates are provided, the API defaults to the last 7 days.
# List team API keys
Source: https://docs.magnific.com/api-reference/analytics/team-api-keys
get /v1/analytics/team-api-keys
List all API keys in your team with their name, status, and creation date. Use key IDs to filter credit usage reports.
# Get team credit usage over time
Source: https://docs.magnific.com/api-reference/analytics/team-credit-usage/query
post /v1/analytics/team-credit-usage
Query your team AI credit consumption over time. Filter by group, project, or API key with day, week, month, or year granularity.
# List team groups
Source: https://docs.magnific.com/api-reference/analytics/team-groups
get /v1/analytics/team-groups
List all groups in your team with their name and member count. Use group IDs to filter credit usage reports.
# List team members
Source: https://docs.magnific.com/api-reference/analytics/team-members
get /v1/analytics/team-members
List all members of your team with their email, role, and membership status.
# List team projects
Source: https://docs.magnific.com/api-reference/analytics/team-projects
get /v1/analytics/team-projects
List all projects in your team with their reference UUID and name. Use project references to filter credit usage reports.
# Audio Isolation - List tasks
Source: https://docs.magnific.com/api-reference/audio-isolation/audio-isolation-tasks
get /v1/ai/audio-isolation
Get the status of all audio isolation tasks
# Audio Isolation - Extract sounds from audio/video
Source: https://docs.magnific.com/api-reference/audio-isolation/isolate
post /v1/ai/audio-isolation
Isolate and extract specific sounds from audio or video files using SAM Audio AI technology.
Describe the sound you want to isolate, and the API separates it from background noise.
**Use cases:**
- Extract speech from noisy recordings
- Isolate musical instruments from a mix
- Separate specific sound effects from video audio
- Remove background noise while preserving target sounds
**Input options:**
- Provide either an `audio` URL/base64 or a `video` URL/base64 (mutually exclusive)
- Supported audio formats: WAV, MP3, FLAC, OGG, M4A
- Supported video formats: MP4, MOV, WEBM, AVI
- For video input, use bounding box coordinates (x1, y1, x2, y2) to focus on a specific region
**Output:** WAV audio file containing the isolated sound
# SAM Audio - Audio Isolation API | Magnific API
Source: https://docs.magnific.com/api-reference/audio-isolation/overview
Isolate specific sounds from audio or video with SAM Audio. Extract vocals, speech, instruments, or sound effects using text descriptions. WAV output for production workflows.
Powered by SAM Audio technology, this API isolates specific sounds from audio or video files using natural language descriptions.
SAM Audio is an AI-powered audio isolation API that extracts specific sounds from audio or video files based on text descriptions. Describe what you want to isolate - vocals, speech, instruments, or sound effects - and receive a clean WAV file containing only that sound. The API supports both audio files (WAV, MP3, FLAC, OGG, M4A) and video files (MP4, MOV, WEBM, AVI) as input.
### Key capabilities
* **Text-guided isolation**: Describe any sound to extract (e.g., "A person speaking", "Piano playing", "Dog barking")
* **Multi-format input**: Accepts audio (WAV, MP3, FLAC, OGG, M4A) or video (MP4, MOV, WEBM, AVI) files
* **Video localization**: Optional bounding box (`x1`, `y1`, `x2`, `y2`) to focus on specific areas in video
* **Quality tuning**: Adjust `reranking_candidates` (1-8) to balance quality vs. latency
* **Event detection**: Enable `predict_spans` for better isolation of non-ambient sounds
* **WAV output**: High-quality WAV audio file with the isolated sound
* **Async processing**: Webhook notifications or polling for task completion
### Use cases
* **Music production**: Extract vocals from songs for remixes or karaoke tracks
* **Podcast editing**: Isolate speech from background noise or music
* **Film post-production**: Separate dialogue from ambient sounds for audio mixing
* **Sound design**: Extract specific sound effects from video recordings
* **Transcription services**: Clean up audio by isolating speech before transcription
* **Instrument isolation**: Separate specific instruments from full band recordings
### Isolate audio with SAM Audio
Submit an audio or video file with a text description of the sound to isolate. The service returns a task ID for async polling or webhook notification.
Create a new audio isolation task
List all audio isolation tasks
Get task status and results by ID
### Parameters
| Parameter | Type | Required | Default | Description |
| ---------------------- | --------- | -------- | ------- | ------------------------------------------------------------------------------------- |
| `description` | `string` | Yes | - | Text description of the sound to isolate (e.g., "A person speaking", "Piano playing") |
| `audio` | `string` | No\* | - | URL or base64-encoded audio file (WAV, MP3, FLAC, OGG, M4A) |
| `video` | `string` | No\* | - | URL or base64-encoded video file (MP4, MOV, WEBM, AVI) |
| `x1` | `integer` | No | `0` | Bounding box left coordinate for video localization (0 = full frame) |
| `y1` | `integer` | No | `0` | Bounding box top coordinate for video localization (0 = full frame) |
| `x2` | `integer` | No | `0` | Bounding box right coordinate for video localization (0 = full frame) |
| `y2` | `integer` | No | `0` | Bounding box bottom coordinate for video localization (0 = full frame) |
| `sample_fps` | `integer` | No | `2` | Frame sampling rate for video (1-5 FPS) |
| `reranking_candidates` | `integer` | No | `1` | Quality vs. latency trade-off (1-8, higher = better quality, slower) |
| `predict_spans` | `boolean` | No | `false` | Enable for better isolation of non-ambient, event-based sounds |
| `webhook_url` | `string` | No | - | URL for task completion notification |
\*Either `audio` or `video` must be provided, but not both.
## Frequently Asked Questions
SAM Audio is an AI-powered audio isolation API that uses text descriptions to identify and extract specific sounds from audio or video files. You submit a file with a description of the target sound (e.g., "A person speaking"), receive a task ID immediately, then poll for results or receive a webhook notification. The output is a WAV file containing only the isolated sound.
For audio input: WAV, MP3, FLAC, OGG, and M4A formats. For video input: MP4, MOV, WEBM, and AVI formats. Files can be provided as URLs or base64-encoded strings.
Be specific and descriptive. Good examples: "A person speaking", "Piano playing in the background", "Dog barking loudly", "Acoustic guitar strumming". Avoid vague descriptions like "music" or "noise" - instead specify what type of music or sound you want to isolate.
The `reranking_candidates` parameter (1-8) controls the quality vs. speed trade-off. Higher values produce better isolation quality but take longer to process. Use `1` for fastest results, `8` for highest quality. Default is `1`.
Enable `predict_spans` when isolating non-ambient, event-based sounds like speech, individual notes, or sound effects. Keep it disabled (default) for continuous ambient sounds like background music or environmental noise.
For video input, you can specify a bounding box (`x1`, `y1`, `x2`, `y2`) to focus on sounds originating from a specific area of the frame. This is useful when you want to isolate audio from a particular person or object in the video. Set all values to `0` (default) to process the full frame.
SAM Audio outputs a high-quality WAV audio file containing only the isolated sound. This uncompressed format is ideal for further editing or processing in audio production workflows.
## Best practices
* **Description specificity**: Use detailed descriptions for better isolation accuracy
* **Input quality**: Higher quality input audio/video produces better isolation results
* **Quality tuning**: Start with `reranking_candidates=1` for testing, increase for production
* **Event sounds**: Enable `predict_spans` for speech, music notes, or sound effects
* **Video focus**: Use bounding boxes to isolate sounds from specific video regions
* **Production integration**: Use webhooks instead of polling for scalable applications
* **Error handling**: Implement retry logic with exponential backoff for 503 errors
## Related APIs
* **[Sound Effects](/api-reference/sound-effects/post-sound-effects)**: Generate sound effects from text descriptions
* **[Lip Sync](/api-reference/lip-sync/latent-sync/overview)**: Synchronize lip movements with audio
* **[OmniHuman 1.5](/api-reference/video/omni-human-1-5)**: Generate human animations driven by audio
# Audio Isolation - Get task status
Source: https://docs.magnific.com/api-reference/audio-isolation/task-by-id
get /v1/ai/audio-isolation/{task-id}
Get the status of one audio isolation task
# Search enterprise audit-log events
Source: https://docs.magnific.com/api-reference/audit-logs/events
get /v1/analytics/audit-logs/events
Search your enterprise audit-log events. Filter by actor, group, folder, event type, request, or date window, and paginate with page or cursor.
# Audit Logs API | Magnific API
Source: https://docs.magnific.com/api-reference/audit-logs/overview
Pull your enterprise audit trail programmatically with the Magnific Audit Logs API. Track who did what, filter events, and stream your full history via cursor.
Programmatic, admin/owner-only access to the same audit events available in your Enterprise dashboard — who did what, to which resource, and how access changed.
The Audit Logs API lets you retrieve your enterprise team's audit events over HTTP, so you can stream them into a SIEM, build compliance reports, or power your own security monitoring. It exposes the same activity feed as the dashboard, projected to a customer-safe set of fields.
Available exclusively for **Enterprise** plans with **audit logs enabled**, and only to team **admins and owners**. It does not consume credits.
## Key capabilities
* **Complete activity feed**: every governance, project, and member action your team produces — role changes, shares, permission grants, API-key lifecycle, and more.
* **Rich filtering**: narrow by actor (`member_id`), group (`group_id`), folder (`folder_id`), event type (`event_type`), a single request (`request_id`), or a date window.
* **Cursor pagination**: walk your entire history reliably with an opaque `cursor` — no offset limits, no skipped or duplicated rows.
* **Server-side name resolution**: project and folder names are resolved for you, so you don't have to join against other endpoints.
* **Customer-safe payloads**: the free-form event data is narrowed to a vetted allow-list — provider internals, cross-system identifiers, and moderation flags never leave your boundary.
* **No credit cost**: reading your own audit trail is free.
## Use cases
* **SIEM / SOC ingestion**: forward audit events into Splunk, Elastic, or Datadog for centralized security monitoring.
* **Compliance & audit reporting**: produce evidence of access changes and administrative actions for SOC 2, ISO 27001, or internal reviews.
* **Access reviews**: reconstruct who granted which permission, to whom, and when.
* **Incident investigation**: pivot on a `request_id` to pull every event emitted by a single operation.
* **Anomaly detection**: stream events into your own pipeline to flag unusual role changes or bulk shares.
## Read audit events
Fetch events with [`GET /v1/analytics/audit-logs/events`](/api-reference/audit-logs/events). Authenticate with your API key — your enterprise team and identity are resolved automatically.
```bash theme={null}
curl "https://api.magnific.com/v1/analytics/audit-logs/events?date_from=2026-07-16&date_to=2026-07-31&per_page=100" \
-H "X-Magnific-API-Key: YOUR_API_KEY" \
-H "Accept: application/json"
```
### Example response
```json theme={null}
{
"data": [
{
"event_id": "b3d1f0a2-9c4e-4a1b-8f2d-1a2b3c4d5e6f",
"date": "2026-07-30T09:14:52+00:00",
"action": {
"event_type": "team.member.role_changed",
"verb": "update",
"status": "success",
"resource_id": "18422",
"request_id": "req-7f3a9c1e",
"correlation_id": "corr-2b8e",
"old_state": { "role": "member" },
"new_state": { "role": "admin" },
"duration_ms": 42,
"data": {
"target_user_id": 10511077,
"role": "admin",
"operation": "grant"
},
"project_name": null,
"folder_name": null
},
"member": {
"type": "user",
"user_id": 10499812,
"email": "admin@company.com"
},
"category": "member",
"source": {
"project": "magnific",
"platform": "web",
"referer": null
}
}
],
"meta": {
"pagination": { "current_page": 1, "per_page": 20, "last_page": 5, "total": 92 },
"next_cursor": "eyJzIjpbMTcyMjMyOF19"
}
}
```
### Event structure
Each event describes one action, the actor behind it, and where it came from.
| Field | Description |
| ---------- | ------------------------------------------------------------------------------------------------------------------------------------ |
| `event_id` | Unique identifier of the event |
| `date` | When it occurred (UTC, ISO-8601) |
| `action` | What happened: `event_type`, `verb`, `status`, `old_state`/`new_state`, `duration_ms`, and a `data` payload with event-specific keys |
| `member` | The actor: `type`, `user_id`, `email` |
| `category` | The resource category the event belongs to |
| `source` | Where it originated: `project`, `platform`, `referer` |
The `action.data`, `action.old_state`, and `action.new_state` objects are free-form. On the API they are narrowed to a vetted allow-list — provider/inference internals, cross-system identifiers, internal billing state, and content-moderation flags are stripped and never returned.
### Filtering
Combine any of these query parameters. Multi-value filters accept a single value, a comma-separated list (`member_id=1,2`), or repeated params (`member_id[]=1&member_id[]=2`).
| Filter | What it does |
| ----------------------- | --------------------------------------------------------------------------------------- |
| `date_from` / `date_to` | Restrict to a date window (`YYYY-MM-DD`). Max **15 days**; defaults to the last 15 days |
| `member_id` | Only events performed by specific actor user IDs |
| `group_id` | Only events involving specific team groups |
| `folder_id` | Only events on specific folder references |
| `event_type` | Only specific event types |
| `request_id` | Every event emitted by one request (incident pivots) |
### Pagination
Two modes, depending on what you need:
Use `page` and `per_page` (max 100) for browsing. `page * per_page` cannot exceed 10000 — narrow the date range or switch to a cursor for deeper reads.
Pass `cursor` to iterate with no depth limit. `page` is ignored. Follow `meta.next_cursor` until it is `null` to walk your whole history.
To sync your full trail, request the first page, then keep calling with the returned `meta.next_cursor` until it comes back `null`.
## Authentication
Authenticate with the `X-Magnific-API-Key` header. Your enterprise team and identity are resolved automatically from the API key. The key must belong to a team **admin or owner** of an **Enterprise** team with **audit logs enabled**. See [Authentication](/authentication) for details.
## Retention
The audit index retains at most **15 days** of events. Queries cannot span a wider window. For long-term retention, stream events into your own storage on a schedule.
## Rate limits
The Audit Logs API is limited to **50,000 requests per day** per API key, with a short-term burst cap. Use cursor pagination and incremental syncs to stay well within budget.
## API reference
Search and stream your enterprise audit events with filters and cursor pagination
## Best practices
* **Sync incrementally**: after a full backfill, poll a small recent window (e.g. the last hour) on a schedule instead of re-reading everything.
* **Use the cursor for backfills**: page mode is capped at 10000 results; the cursor has no depth limit and never skips rows.
* **Persist your own copy**: retention is 15 days — export to your storage if you need history beyond that.
* **Pivot on `request_id`**: when investigating an incident, grab one event's `request_id` and re-query to see every related event.
* **Handle 429**: back off and retry when you hit the daily or burst limit.
## Frequently Asked Questions
It's a read-only HTTP endpoint that returns your enterprise team's audit events — who did what, to which resource, and how access changed. It exposes the same activity feed as the Enterprise dashboard, projected to a customer-safe set of fields.
Only team **admins and owners** of an **Enterprise** team that has **audit logs enabled**. The caller is resolved automatically from the API key; if the key's owner is not an admin/owner, the request is rejected.
The audit index retains at most 15 days. A single query cannot span more than 15 days, and it defaults to the last 15 days when no dates are provided. To keep history longer, export events into your own storage.
Use cursor pagination. Request the first page, then keep calling with the `meta.next_cursor` value from the previous response until it returns `null`. Cursor mode has no depth limit and won't skip or duplicate rows.
The event `data`, `old_state`, and `new_state` objects are free-form. On the public API they are narrowed to a vetted allow-list, so provider internals, cross-system identifiers, internal billing state, and content-moderation flags are stripped. The dashboard and CSV export still show the full object.
No. Reading your own audit trail is included with your Enterprise plan at no additional cost.
50,000 requests per day per API key, plus a short-term burst cap. See [Rate Limits](/ratelimits) for details.
## Related APIs
* **[Analytics API](/api-reference/analytics/overview)**: credit consumption over time, plus team member, API key, group, and project discovery endpoints.
# AI Image Classifier - Detection API | Magnific API
Source: https://docs.magnific.com/api-reference/classifier/overview
Detect AI-generated images with the AI Image Classifier API. Get probability scores for authentic vs synthetic content. Instant results for content moderation workflows.
Powered by advanced machine learning, this API analyzes images to determine the probability of AI generation with high accuracy.
The AI Image Classifier is a detection API that analyzes images to determine whether they were created by artificial intelligence or are authentic photographs. Submit any image and receive a confidence score indicating the probability of AI generation vs. natural origin. The API returns instant results, making it ideal for real-time content moderation and verification workflows.
### Key capabilities
* **Binary classification**: Returns probability scores for both `ai` and `not_ai` categories
* **High accuracy detection**: Advanced ML model trained on diverse AI-generated and authentic images
* **Multiple input formats**: Accepts base64-encoded images, URLs, or binary data
* **Instant response**: Synchronous API with immediate results (no task polling required)
* **Confidence scoring**: Probability values from 0 to 1 for precise threshold-based decisions
* **Format support**: Works with common image formats (JPEG, PNG, WebP, GIF)
### Use cases
* **Content moderation**: Automatically flag potentially AI-generated uploads on user platforms
* **Editorial verification**: Verify image authenticity before publication in news or media
* **Stock image curation**: Filter AI-generated content from authentic photography collections
* **Social media compliance**: Detect synthetic content for platform policy enforcement
* **Academic integrity**: Identify AI-generated images in research or educational submissions
* **Legal and forensic analysis**: Support authenticity verification for evidence documentation
### Classify images with AI Image Classifier
Submit an image to analyze whether it was generated by AI. The API returns probability scores instantly without requiring task polling.
Analyze an image for AI-generation probability
### Parameters
| Parameter | Type | Required | Default | Description |
| --------- | -------- | -------- | ------- | ------------------------------------------------------------ |
| `image` | `string` | Yes | - | Image to analyze: base64-encoded string, URL, or binary data |
### Response
The API returns an array of classification results with probability scores:
| Field | Type | Description |
| ------------- | -------- | ------------------------------------------------------ |
| `class_name` | `string` | Classification category: `ai` or `not_ai` |
| `probability` | `number` | Confidence score from 0 to 1 (higher = more confident) |
**Example response:**
```json theme={null}
{
"data": [
{
"class_name": "not_ai",
"probability": 0.9489
},
{
"class_name": "ai",
"probability": 0.0511
}
]
}
```
## Frequently Asked Questions
The AI Image Classifier is a detection API that uses machine learning to analyze visual patterns in images that are characteristic of AI generation. It examines features like texture consistency, artifact patterns, and statistical properties to determine whether an image was created by AI tools (like Midjourney, DALL-E, or Stable Diffusion) or is an authentic photograph. The API returns probability scores for both categories.
The classifier accepts common image formats including JPEG, PNG, WebP, and GIF. Images can be provided as base64-encoded strings, direct URLs, or binary data in the request body.
The API returns two probability scores that sum to approximately 1.0. A `not_ai` probability of 0.95 means the model is 95% confident the image is authentic. For content moderation, you can set thresholds based on your requirements - for example, flag images where `ai` probability exceeds 0.7 for review.
The classifier is trained on a diverse dataset of AI-generated images from various models and authentic photographs. Accuracy depends on the image type and generation method. The probability scores help you make threshold-based decisions appropriate for your use case. For critical applications, consider combining with manual review.
Rate limits vary by subscription tier. See [Rate Limits](/ratelimits) for current limits and how to handle rate-limited requests.
See the [Pricing page](/pricing) for current rates and subscription options.
The classifier is optimized for detecting fully AI-generated images. Partially edited images (AI inpainting on real photos, filters, or composites) may produce mixed results. For best accuracy, use on complete images rather than crops or heavily processed versions.
## Best practices
* **Image quality**: Submit high-resolution images when possible for more accurate analysis
* **Threshold tuning**: Set classification thresholds based on your false-positive tolerance
* **Batch processing**: For high-volume workflows, implement request queuing to respect rate limits
* **Human review**: Use API scores to prioritize manual review rather than as sole decision criteria
* **Error handling**: Implement retry logic with exponential backoff for 503 errors
* **Caching**: Cache results for identical images to reduce API calls and costs
## Related APIs
* **[Mystic](/api-reference/mystic/mystic)**: Generate high-quality AI images with Magnific's proprietary model
* **[Image Upscaler](/api-reference/image-upscaler-creative/image-upscaler)**: Enhance image resolution with AI upscaling
* **[Background Remover](/api-reference/remove-background/overview)**: Remove or replace image backgrounds
# Analyzes an image to determine its likelihood of being AI-generated
Source: https://docs.magnific.com/api-reference/classifier/post-ai-classifier
post /v1/ai/classifier/image
Accepts an image file as input and analyzes it to determine the probability that the image was generated by artificial intelligence, providing a confidence score.
# Creations API
Source: https://docs.magnific.com/api-reference/creations/overview
Retrieve your most recent AI creations programmatically with the Magnific Creations API.
Programmatic access to the most recent creations of the user behind your API key.
The Creations API lets you retrieve a user's most recent creations — the files they have generated — enriched with the metadata of the creation that produced each one. Use it to surface a user's latest work in your own app, dashboards, or galleries.
It does not consume credits.
## Recent creations
Fetch the most recent creations with [`GET /v1/creations/recent`](/api-reference/creations/recent-creations). Results are paginated and ordered from newest to oldest. The identity is resolved automatically from the API key — you always get the creations of that key's user.
```bash theme={null}
curl https://api.magnific.com/v1/creations/recent?per_page=3 \
-H "X-Magnific-API-Key: YOUR_API_KEY"
```
### Example response
```json theme={null}
{
"data": [
{
"id": 1337,
"reference": "4fef9987-75d0-44d1-b336-65f42f883bff",
"user_id": 159327,
"name": "My awesome creation",
"external_id": "8421",
"tool_name": "text-to-image",
"thumbnail": { "url": "https://cdn.freepik.com/thumbnails/8421.jpg" },
"created_at": "2026-05-01T12:30:00Z",
"updated_at": "2026-05-01T12:30:00Z",
"creation": {
"id": 8421,
"identifier": "a1b2c3d4",
"family": "image",
"tool": "text-to-image",
"url": "https://cdn.freepik.com/creations/8421.png",
"preview": "https://cdn.freepik.com/creations/8421-preview.png",
"status": "completed",
"public": false,
"nsfw": false,
"user_id": 159327,
"created_at": "2026-05-01T12:30:00Z"
}
}
],
"meta": {
"pagination": {
"current_page": 1,
"per_page": 3
}
}
}
```
### Query parameters
| Parameter | Description | Default |
| ----------- | -------------------------------------------------------------------- | ------- |
| `page` | Page number to retrieve | `1` |
| `per_page` | Number of creations per page | `5` |
| `tool_name` | Filter by the tool that produced the creation (e.g. `text-to-image`) | — |
## Authentication
Authenticate with the `X-Magnific-API-Key` header. The user is identified automatically from the API key — you cannot request another user's creations. See [Authentication](/authentication) for details.
## Rate limits
The endpoint is limited to **30,000 requests per minute** (30,000 RPM) per API key. Exceeding it returns `429 Too Many Requests`.
## API reference
List the user's most recent creations, newest first
## Frequently Asked Questions
Always the creations of the user associated with the API key. Identity is resolved server-side from the key, so a client cannot request another user's creations.
No. The Creations API is a read-only endpoint and does not consume credits.
Use the `page` and `per_page` query parameters. The response `meta.pagination` block reflects the current page and page size.
Yes. Pass `tool_name` (for example `text-to-image`) to return only the creations produced by that tool.
# Get the user's most recent creations
Source: https://docs.magnific.com/api-reference/creations/recent-creations
get /v1/creations/recent
Retrieve the most recent creations of the user associated with your API key, enriched with each creation's metadata. Paginated, newest first.
# Flows - Get flow definition
Source: https://docs.magnific.com/api-reference/flows/get-flow
get /v1/ai/flows/{flow-id}
Returns the full definition of a flow, including its dynamic inputs and cost.
**Inputs** define what values the caller must provide when running the flow:
- `creation` type: accepts an image/media URL, base64-encoded data, or an existing creation identifier
- `text` type: accepts a plain text string (prompt, label, etc.)
- `number` type: accepts a numeric value
- `select` type: accepts a value from predefined options
Use each input's `api_key` field (recommended, human-friendly node name) as the identifier when calling the run endpoint.
The UUID-based `id` field is still accepted for backward compatibility.
The `tool_metadata.total_cost` field indicates the credit cost per execution.
# Flows - Get run status
Source: https://docs.magnific.com/api-reference/flows/get-run
get /v1/ai/flows/runs/{run-id}
Retrieve the current status and results of a flow execution run.
Use this endpoint to **poll** the status of a run after calling the
`POST /v1/ai/flows/{flow-id}/run` endpoint. The `run_id` path parameter
corresponds to the `workflow_run_identifier` returned in the run response.
**Polling strategy:**
- Wait 2-3 seconds after starting the run before the first poll
- Poll every 3-5 seconds
- When `status` is `completed`, the `result` field contains download URLs
- When `status` is `failed`, the `error_message` field describes the failure
**Asset URLs** in the `result` field are temporary and valid for **12 hours**.
**Statuses:**
| Status | Description |
|--------|-------------|
| `pending` | Run is queued but has not started yet |
| `running` | Flow is executing |
| `completed` | Finished successfully, `result` is available |
| `completed_with_errors` | Execution finished but some nodes failed |
| `failed` | Execution failed, see `error_message` |
| `cancelled` | Execution was cancelled |
# Flows - List flows
Source: https://docs.magnific.com/api-reference/flows/list-flows
get /v1/ai/flows
Returns all flows **published as tools** that the authenticated user can execute.
Each item includes the flow identifier, name, and tool metadata.
Flows are visual AI pipelines built in [Magnific Spaces](https://www.magnific.com/spaces).
Each flow chains together multiple AI tools (upscale, generate, edit, etc.) and can be executed via API.
**Use this endpoint to discover** runnable flows, then call the detail endpoint to get input definitions before running them.
# Flows - List my flows
Source: https://docs.magnific.com/api-reference/flows/list-my-flows
get /v1/ai/me/flows
Returns all flows **owned** by the authenticated user, including drafts and unpublished workflows.
Unlike `GET /v1/ai/flows` which returns only flows published as tools, this endpoint returns
every flow the user has created — regardless of whether it has been published as a tool.
Each item includes the flow identifier and name.
# Flows API
Source: https://docs.magnific.com/api-reference/flows/overview
Run visual AI pipelines via API. Chain together AI tools like upscale, generate, and edit into reusable Flows with dynamic inputs.
Execute multi-step AI workflows with a single API call. Each Flow chains together AI tools into a reusable pipeline.
Flows are visual AI pipelines created in [Magnific Spaces](https://www.magnific.com/spaces). Each Flow chains together multiple AI tools (upscale, generate, edit, transform, etc.) into a reusable pipeline. Once published, Flows can be executed programmatically via this API — you provide the required inputs (images, text prompts, etc.) and the Flow runs the entire pipeline, returning the final output.
### Key capabilities
* **Dynamic inputs**: Each Flow defines its own inputs — images, text prompts, numbers, or selections
* **Async execution**: Submit a run, then poll for status or receive a webhook notification
* **Multi-output**: Flows can produce images, videos, or audio depending on the workflow
### How it works
1. **List flows** to discover available workflows
2. **Get flow details** to see required inputs and their types
3. **Run the flow** by providing values for each input, keyed by its `api_key` (recommended) or `id` (legacy)
4. **Poll or webhook** to get the results when execution completes
List all available flows
List flows you own, including drafts
Get a flow definition and its inputs
Run a flow with your inputs
Poll run status and results
### Input types
| Input Type | Accepted Values | Example |
| ---------- | ------------------------------------------------------- | --------------------------------- |
| `creation` | Image URL, base64-encoded image, or creation identifier | `"https://example.com/photo.jpg"` |
| `text` | Plain text string | `"A car in the forest"` |
| `number` | Numeric value | `0.5` |
| `select` | Value from predefined options | `"style_a"` |
### Example: Run a flow
```bash theme={null}
curl -X POST "https://api.magnific.com/v1/ai/flows/uqzQLDr2Aw/run" \
-H "X-Magnific-Api-Key: YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"inputs": {
"image": "https://example.com/my-sketch.jpg"
},
"webhook": "https://your-server.com/webhook"
}'
```
### Identifiers
Flows are identified by their SQID:
| Format | Example | Description |
| -------- | ------------ | ------------------------------------- |
| **SQID** | `uqzQLDr2Aw` | Short unique identifier for each flow |
Existing integrations that call the legacy `/v1/ai/apps` paths remain functional. New integrations should use the `/v1/ai/flows` endpoints documented here.
## More about Spaces
[Magnific Spaces](https://www.magnific.com/spaces) is the infinite canvas where you build and publish Flows. Connect AI nodes visually — image generation, upscaling, style transfer, text processing, and more — into reusable workflows. Collaborate with your team in real time, then publish your workflow as a Flow to make it available via this API.
Start building your own AI workflows on the infinite canvas.
View your published Flows and copy their IDs to use with this API.
## Frequently Asked Questions
Flows are visual AI pipelines built in Magnific Spaces. They chain together multiple AI tools (image generation, upscaling, style transfer, etc.) into a single reusable workflow. The API lets you execute these workflows programmatically.
Call `GET /v1/ai/flows/{flow-id}` to get the full definition, including all required inputs with their types and labels. Use each input's `api_key` field (recommended) — a human-friendly identifier matching the node name — as the key in the `inputs` object when running the flow. The UUID-based `id` field is still accepted for backward compatibility (legacy).
Execution time depends on the workflow complexity and the AI tools involved. Simple single-tool workflows may complete in 10-30 seconds. Multi-step workflows with video generation can take 1-5 minutes. Use webhooks for production integrations.
See the [Rate Limits](/ratelimits) page for current limits by subscription tier.
Each flow shows its credit cost in the `tool_metadata.total_cost` field. See the [Pricing page](/pricing) for credit rates.
## Related APIs
* **[Image Upscaler](/api-reference/image-upscaler-creative/image-upscaler)**: Upscale images with AI enhancement
* **[Text to Image](/api-reference/text-to-image/image-generation)**: Generate images from text prompts
* **[Image to Video](/api-reference/image-to-video/overview)**: Convert images into video clips
# Flows - Run a flow
Source: https://docs.magnific.com/api-reference/flows/run-flow
post /v1/ai/flows/{flow-id}/run
Triggers the execution of a flow. Provide values for all required inputs
defined in the flow's definition (see the GET endpoint).
The `inputs` object maps each input's `api_key` (recommended) or its `id` (UUID, legacy) to its value:
| Input Type | Accepted Values |
|------------|----------------|
| `creation` | Image URL (`https://...`), base64-encoded image string, or existing creation identifier |
| `text` | Plain text string |
| `number` | Numeric value |
| `select` | Value from allowed options |
**This endpoint is asynchronous.** It returns immediately with `status: "running"` and a
`workflow_run_identifier`. Provide a `webhook` URL to receive notifications when the execution
completes. The webhook receives two events: `initialized` (run started) and `finished`/`failed` (run completed).
The webhook payload for a completed run includes a `result` object containing `images`, `videos`,
and `audios` arrays with download URLs for the generated assets.
# AI Icon Generation - Text-to-Icon API | Magnific API
Source: https://docs.magnific.com/api-reference/icon-generation/overview
Generate custom icons from text prompts with AI. Create PNG or SVG icons in 5 styles: solid, outline, color, flat, and sticker. Production-ready vector output for apps and websites.
Generate custom icons from text descriptions using advanced AI models, with support for multiple styles and vector output formats.
AI Icon Generation is a text-to-icon API that creates custom icons from natural language prompts. Describe the icon you need, and receive production-ready PNG or SVG files in your chosen style. The API supports 5 distinct visual styles and offers a preview workflow for rapid iteration before final rendering.
### Key capabilities
* **Text-to-icon generation**: Create icons from natural language descriptions (e.g., "A cute cat icon", "Shopping cart with heart")
* **Multiple output formats**: Export as PNG for raster graphics or SVG for scalable vector graphics
* **5 visual styles**: Choose from `solid`, `outline`, `color`, `flat`, or `sticker` styles
* **Preview workflow**: Generate quick previews before committing to final high-quality renders
* **Quality tuning**: Adjust `num_inference_steps` (10-50) and `guidance_scale` (0-10) for fine control
* **Async processing**: Webhook notifications for task completion
* **Vector-ready output**: SVG format for infinite scalability without quality loss
### Use cases
* **Mobile app development**: Generate consistent icon sets for iOS and Android applications
* **Web design**: Create custom icons matching your brand identity and design system
* **UI/UX prototyping**: Rapidly iterate on icon concepts during design exploration
* **Marketing materials**: Generate unique icons for presentations, infographics, and social media
* **Brand identity**: Create distinctive iconography that aligns with brand guidelines
* **E-commerce**: Generate product category icons, feature badges, and navigation elements
### Generate icons with the API
Create icons by submitting a text prompt with your desired style and format. Use the preview endpoint for quick iterations, then render the final output in your preferred format.
Generate a new icon from text prompt
Generate a quick preview of the icon
Download icon in PNG or SVG format
### Parameters
| Parameter | Type | Required | Default | Description |
| --------------------- | --------- | -------- | ------- | -------------------------------------------------------------------- |
| `prompt` | `string` | Yes | - | Text description of the icon to generate (e.g., "A cute cat icon") |
| `webhook_url` | `string` | Yes | - | URL for task completion notification |
| `style` | `string` | No | `solid` | Visual style: `solid`, `outline`, `color`, `flat`, or `sticker` |
| `format` | `string` | No | `png` | Output format: `png` or `svg` |
| `num_inference_steps` | `integer` | No | `10` | Generation quality steps (10-50, higher = better quality, slower) |
| `guidance_scale` | `number` | No | `7` | Prompt adherence strength (0-10, higher = stricter prompt following) |
### Style reference
| Style | Description | Best for |
| --------- | ---------------------------------- | -------------------------------- |
| `solid` | Filled shapes with single color | UI icons, navigation elements |
| `outline` | Line-based icons with strokes | Minimalist designs, light themes |
| `color` | Multi-colored filled icons | Marketing, illustrations |
| `flat` | Simplified shapes with flat colors | Modern app interfaces |
| `sticker` | Decorative style with playful look | Social media, casual apps |
## Frequently Asked Questions
AI Icon Generation is a text-to-icon API that uses advanced AI models to create custom icons from natural language descriptions. You submit a prompt describing the icon you want (e.g., "A shopping cart icon"), choose a style and format, and receive a task ID. Poll for results or receive a webhook notification when the icon is ready. The output is a production-ready PNG or SVG file.
The API supports two output formats: PNG for raster graphics and SVG for scalable vector graphics. PNG is ideal for immediate use in web and mobile applications, while SVG provides infinite scalability without quality loss, perfect for responsive designs and print materials.
Five visual styles are available: `solid` (filled shapes), `outline` (line-based), `color` (multi-colored), `flat` (simplified modern), and `sticker` (decorative playful). Each style suits different design contexts - solid and outline work well for UI elements, while color and sticker are better for marketing and casual applications.
Be specific and descriptive. Good examples: "A cute cat icon", "Shopping cart with a heart", "Lightning bolt in a circle", "Envelope with notification badge". Include the subject and any distinctive features. Avoid overly complex descriptions - icons work best as simple, recognizable symbols.
The preview endpoint (`/preview`) generates a quick draft for rapid iteration during the design process. The main generate endpoint (`/v1/ai/text-to-icon`) creates the production-ready icon. Use previews to explore different prompts and styles, then generate the final version once satisfied.
`num_inference_steps` (10-50) controls generation quality - higher values produce more refined icons but take longer. `guidance_scale` (0-10) determines how strictly the AI follows your prompt - higher values create icons more closely matching your description, while lower values allow more creative interpretation.
Rate limits vary by subscription tier. See [Rate Limits](/ratelimits) for current limits and quotas.
See the [Pricing page](/pricing) for current rates and subscription options.
## Best practices
* **Prompt clarity**: Use clear, concise descriptions focusing on the core concept of the icon
* **Style consistency**: Use the same style across icon sets for visual coherence in your application
* **Preview first**: Use the preview endpoint to iterate quickly before generating final renders
* **SVG for scalability**: Choose SVG format when icons will be used at multiple sizes
* **Quality vs. speed**: Start with default `num_inference_steps` (10) for testing, increase for production
* **Guidance tuning**: Use higher `guidance_scale` (8-10) for literal interpretations, lower (4-6) for creative variations
* **Webhook integration**: Use webhooks instead of polling for production applications
* **Error handling**: Implement retry logic with exponential backoff for 503 errors
## Related APIs
* **[Magnific Mystic](/api-reference/mystic/mystic)**: Generate full illustrations and images from text prompts
* **[Image Upscaler](/api-reference/image-upscaler-creative/image-upscaler)**: Enhance icon resolution for high-DPI displays
* **[Background Removal](/api-reference/remove-background/overview)**: Remove backgrounds from existing icons or images
# AI Icon generation
Source: https://docs.magnific.com/api-reference/icon-generation/post-generate-icon
post /v1/ai/text-to-icon
Create stunning icons in different styles and formats (png, svg) from text prompts using our advanced AI models.
## Description
Generate an icon from a text prompt.
# AI Icon preview generation
Source: https://docs.magnific.com/api-reference/icon-generation/post-preview
post /v1/ai/text-to-icon/preview
Create stunning previews icons in different styles and formats (png, svg) from text prompts using our advanced AI models.
# Download an icon preview
Source: https://docs.magnific.com/api-reference/icon-generation/post-{format}-by-id
post /v1/ai/text-to-icon/{task-id}/render/{format}
Download the generated AI icon in the specified format png or svg.
# Download an icon
Source: https://docs.magnific.com/api-reference/icons/download-an-icon
get /v1/icons/{id}/download
Download the specified icon by its unique ID in the requested format and size.
Download the original icon asset. See the [Icons API overview](/api-reference/icons/icons-api) for authentication and usage guidance.
# Search and filter icons by specified order
Source: https://docs.magnific.com/api-reference/icons/get-all-icons-by-order
get /v1/icons
Get a list of icons based on the provided parameters and ordering criteria.
Use the Magnific Icons API to list icons ordered by relevance, popularity, or recency. See the [Icons API overview](/api-reference/icons/icons-api) for authentication and usage guidance.
# Get detailed icon information by ID
Source: https://docs.magnific.com/api-reference/icons/get-one-icon-by-id
get /v1/icons/{id}
Get detailed information about a specific icon identified by its unique ID.
Fetch a specific icon by ID. See the [Icons API overview](/api-reference/icons/icons-api) for authentication and usage guidance.
# Icons API
Source: https://docs.magnific.com/api-reference/icons/icons-api
Search, retrieve, and download icons programmatically with the Magnific Icons API.
The Magnific Icons API lets you find and retrieve icons from our catalog with AI-powered search and download the assets for use in your applications.
### What you can do
* List icons with sorting and filters
* Get a single icon by ID
* Download an icon asset
### Authentication
All requests require an API key via the `x-magnific-api-key` header. See the [Quickstart](/quickstart) and [Authentication](/authentication).
### Endpoints
List icons with sorting and filters
Retrieve a single icon by ID
Download an icon asset
### Use cases
* Build an icon picker into your design tool or CMS
* AI-powered search by keyword and sort by popularity
* Programmatically download icons during build/deploy
### FAQ
#### Is there a rate limit?
Yes. See [Rate limits](/ratelimits).
#### What license applies to icons?
Refer to the [License agreement](https://www.magnific.com/legal/terms-of-use#api-services).
# Ideogram Image Edit - List tasks
Source: https://docs.magnific.com/api-reference/ideogram-image-edit/get-ideogram-image-edit
get /v1/ai/ideogram-image-edit
Get the status of all Ideogram Image Edit tasks
# Ideogram Image Edit - Get task status
Source: https://docs.magnific.com/api-reference/ideogram-image-edit/get-{task-id}-by-id
get /v1/ai/ideogram-image-edit/{task-id}
Get the status of a specific Ideogram Image Edit task
# Ideogram Inpainting API
Source: https://docs.magnific.com/api-reference/ideogram-image-edit/overview
Edit specific areas of an image using Ideogram AI inpainting. Mask-based editing with multiple rendering speeds, MagicPrompt enhancement, style and character references.
Powered by Ideogram AI, this API edits specific areas of an image using mask-based inpainting with prompt-guided generation.
Ideogram Inpainting is an AI-powered image editing API that lets you modify specific regions of an image using a mask and a text prompt. Provide a black-and-white mask where black regions indicate the areas to edit, along with a prompt describing the desired changes. The API supports multiple rendering speeds (TURBO, DEFAULT, QUALITY), automatic prompt enhancement via MagicPrompt, and style/character reference images for consistent results.
### Key capabilities
* **Mask-based editing**: Use a black-and-white mask to precisely define which areas of the image to modify
* **Multiple rendering speeds**: Choose between TURBO (fastest), DEFAULT (balanced), or QUALITY (highest quality)
* **MagicPrompt**: Automatically enhance your prompt for better results (AUTO, ON, or OFF)
* **Style customization**: Apply style codes, style types (AUTO, GENERAL, REALISTIC, DESIGN), and style reference images
* **Character consistency**: Use character reference images to maintain consistent characters across edits
* **Color palette control**: Guide the color palette of generated content
* **Reproducible results**: Optional seed parameter (0-2147483647) for consistent output across requests
* **Flexible input**: Accepts HTTPS URLs or base64-encoded images (max 10MB per image)
* **Async processing**: Webhook notifications or polling for task completion
### Use cases
* **Object replacement**: Replace objects in a scene with AI-generated alternatives
* **Background editing**: Modify or replace backgrounds while preserving subjects
* **Content removal**: Remove unwanted elements from images seamlessly
* **Creative retouching**: Edit specific areas with creative prompts for artistic effects
* **Product photography**: Modify product backgrounds or surroundings for e-commerce
* **Character editing**: Maintain character consistency across multiple edited images
### Edit images with Ideogram Inpainting
Submit an image with a mask and prompt to edit specific regions. The service returns a task ID for async polling or webhook notification.
Create a new inpainting task
List all inpainting tasks
Get task status and results by ID
### Parameters
| Parameter | Type | Required | Default | Description |
| ---------------------------- | --------- | -------- | --------- | ----------------------------------------------------------------------------------------------------------------------------- |
| `image` | `string` | Yes | - | Image to edit. HTTPS URL or base64-encoded (JPEG, WebP, PNG, max 10MB) |
| `mask` | `string` | Yes | - | Black-and-white mask image (same size as input). Black regions indicate areas to edit. HTTPS URL or base64-encoded (max 10MB) |
| `prompt` | `string` | Yes | - | Text describing the desired changes to the image |
| `rendering_speed` | `string` | No | `DEFAULT` | Rendering speed: `TURBO`, `DEFAULT`, or `QUALITY` |
| `magic_prompt` | `string` | No | - | MagicPrompt enhancement: `AUTO`, `ON`, or `OFF` |
| `style_type` | `string` | No | - | Style type: `AUTO`, `GENERAL`, `REALISTIC`, or `DESIGN` |
| `style_codes` | `array` | No | - | List of style codes for image generation |
| `style_reference_images` | `array` | No | - | Images to use as style references (URLs or base64) |
| `character_reference_images` | `array` | No | - | Images for character consistency (URLs or base64) |
| `color_palette` | `object` | No | - | Color palette to guide generated content |
| `seed` | `integer` | No | random | Seed for reproducibility (0-2147483647) |
| `webhook_url` | `string` | No | - | URL for task completion notification |
## Frequently Asked Questions
Ideogram Inpainting is an AI-powered image editing API. You provide an image, a black-and-white mask indicating which areas to edit, and a text prompt describing the desired changes. The API generates new content in the masked regions that blends seamlessly with the rest of the image. You receive a task ID immediately, then poll for results or receive a webhook notification.
The mask must be the same size as the input image. It should be a black-and-white image where black regions indicate the areas you want to edit. White regions will remain unchanged. Supported formats are JPEG, WebP, and PNG (max 10MB).
There are three rendering speeds: **TURBO** is the fastest with lower quality, **DEFAULT** provides balanced speed and quality, and **QUALITY** is slower but produces the highest quality results. The default is DEFAULT.
MagicPrompt automatically enhances your text prompt for better generation results. Set it to `AUTO` to let the model decide, `ON` to always use it, or `OFF` to disable it. This can significantly improve output quality with minimal effort.
Yes. Use the `character_reference_images` parameter to provide reference images of the character you want to maintain. Combined with `style_type`, this helps ensure consistent characters across multiple edits.
The API accepts JPEG, WebP, and PNG images up to 10MB each. Both HTTPS URLs and base64-encoded strings are supported for images, masks, and reference images. The output is returned as a downloadable image URL.
Rate limits vary by subscription tier. See [Rate Limits](/ratelimits) for current limits.
See the [Pricing page](/pricing) for current rates and subscription options.
## Best practices
* **Precise masks**: Create clean, well-defined masks for the best results. Avoid feathered or blurry edges
* **Descriptive prompts**: Be specific about what you want in the edited region (e.g., "red roses in a garden" instead of just "flowers")
* **MagicPrompt for quick results**: Use `magic_prompt: "AUTO"` to let the model enhance your prompt automatically
* **Rendering speed tradeoffs**: Use TURBO for quick previews, DEFAULT for production, and QUALITY for final outputs
* **Style references**: Provide style reference images when you need a specific visual style across edits
* **Seed for consistency**: Use the same seed value when you need reproducible results across multiple API calls
* **Production integration**: Use webhooks instead of polling for scalable applications
* **Error handling**: Implement retry logic with exponential backoff for 503 errors
## Related APIs
* **[Ideogram Image Expand](/api-reference/image-expand/ideogram/overview)**: Expand images beyond their boundaries with Ideogram
* **[Image Upscaler](/api-reference/image-upscaler-creative/post-image-upscaler)**: Enhance image resolution and quality
* **[Remove Background](/api-reference/remove-background/post-beta-remove-background)**: Remove image backgrounds for compositing
* **[Reimagine Flux](/api-reference/text-to-image/reimagine-flux/post-reimagine-flux)**: Reimagine images with Flux
# Ideogram Image Edit - Edit an image using inpainting
Source: https://docs.magnific.com/api-reference/ideogram-image-edit/post-ideogram-image-edit
post /v1/ai/ideogram-image-edit
Edit an image using Ideogram AI's inpainting capabilities. Provide an image and a mask to specify the areas to edit, along with a prompt describing the desired changes.
**Key features:**
- Inpainting: Edit specific areas of an image using a mask
- Multiple rendering speeds: TURBO, DEFAULT, or QUALITY
- MagicPrompt: Automatically enhance your prompt for better results
- Style customization: Use style codes, style types, and reference images
- Character reference: Use reference images to maintain character consistency
**Supported formats:** JPEG, WebP, PNG (max 10MB each)
# Change Camera - Transform image perspective
Source: https://docs.magnific.com/api-reference/image-change-camera/change-camera
post /v1/ai/image-change-camera
Transform an image by changing the camera angle using AI. Adjust horizontal rotation (0-360 degrees), vertical tilt (-30 to 90 degrees), and zoom level (0-10) to generate a new image as if the camera had been repositioned around the subject.
This is an asynchronous endpoint. After submitting a request, use the task ID to poll for results or provide a `webhook_url` to receive a notification when processing completes.
**Camera controls:**
- **Horizontal angle** (`horizontal_angle`): Rotate the viewpoint 0-360 degrees around the subject. `0` = front view, `90` = right side, `180` = back view, `270` = left side.
- **Vertical angle** (`vertical_angle`): Tilt the camera from -30 (looking up) to 90 (bird's eye view). `0` = eye level.
- **Zoom** (`zoom`): Adjust from `0` (wide shot, full scene) to `10` (close-up).
**Use cases:** Product photography with multiple angle views, architectural visualization, creative image manipulation, and generating consistent multi-angle views of objects and scenes.
# Change Camera - List tasks
Source: https://docs.magnific.com/api-reference/image-change-camera/change-camera-tasks
get /v1/ai/image-change-camera
Retrieve the status of all Change Camera tasks for the authenticated user. Returns a list of tasks with their current status, creation time, and result URLs for completed tasks.
# Change Camera API
Source: https://docs.magnific.com/api-reference/image-change-camera/overview
Change camera angle and perspective of any image with the Change Camera API. Adjust horizontal rotation (0-360), vertical tilt (-30 to 90), and zoom (0-10) for multi-angle views.
Transform any image by repositioning the virtual camera with precise control over horizontal rotation, vertical tilt, and zoom level.
Change Camera is an image editing API that transforms the camera perspective of any image using AI. Provide an input image and specify horizontal rotation (0-360 degrees), vertical tilt (-30 to 90 degrees), and zoom level (0-10) to generate a new image as if the camera had been physically repositioned around the subject. The API accepts JPG, PNG, and WebP images via publicly accessible HTTPS URLs and outputs in PNG or JPEG format. Processing is asynchronous with support for both polling and webhook notifications.
### Key capabilities
* **360-degree horizontal rotation**: Rotate the viewpoint around the subject from 0 (front) through 90 (right side), 180 (back), 270 (left side), to 360 degrees
* **Vertical tilt control**: Tilt the camera from -30 degrees (looking up) through 0 (eye level) to 90 degrees (bird's eye view)
* **Adjustable zoom**: Control the distance from wide shot (`0`) through standard framing (`5`) to close-up (`10`)
* **Output format options**: Choose between lossless PNG or compressed JPEG output
* **Reproducible results**: Optional seed parameter for consistent output across requests
* **Async processing**: Webhook notifications or polling for task completion
### Camera controls reference
| Control | Parameter | Range | Default | Key positions |
| ----------------------- | ------------------ | --------- | ------- | ------------------------------------------------ |
| **Horizontal rotation** | `horizontal_angle` | 0-360 | 0 | `0` front, `90` right, `180` back, `270` left |
| **Vertical tilt** | `vertical_angle` | -30 to 90 | 0 | `-30` looking up, `0` eye level, `90` bird's eye |
| **Zoom** | `zoom` | 0-10 | 5 | `0` wide shot, `5` medium, `10` close-up |
### Use cases
* **Product photography**: Generate multiple angle views of a product from a single photo for e-commerce listings
* **Architectural visualization**: View buildings and interiors from different perspectives without reshooting
* **Creative image manipulation**: Explore alternative viewpoints of scenes, portraits, and objects
* **3D asset previewing**: Create multi-angle previews from a single reference image
* **Marketing materials**: Produce varied camera angles for advertising campaigns from one source image
* **Content creation**: Generate consistent multi-angle views of subjects for social media and editorial content
### Transform images with Change Camera
Submit an image URL with camera angle parameters to create a new transformation task. The service returns a task ID for async polling or webhook notification.
Create a new camera angle transformation task
List all Change Camera tasks
Get task status and results by ID
### Parameters
| Parameter | Type | Required | Default | Description |
| ------------------ | --------- | -------- | ------- | ------------------------------------------------------------------------------ |
| `image` | `string` | Yes | - | Input image URL (publicly accessible HTTPS). Supported formats: JPG, PNG, WebP |
| `horizontal_angle` | `integer` | No | `0` | Horizontal rotation: `0` (front) to `360` degrees around the subject |
| `vertical_angle` | `integer` | No | `0` | Vertical tilt: `-30` (looking up) to `90` (bird's eye view) degrees |
| `zoom` | `integer` | No | `5` | Zoom level: `0` (wide shot) to `10` (close-up) |
| `output_format` | `string` | No | `png` | Output format: `png` (lossless) or `jpeg` (compressed) |
| `seed` | `integer` | No | random | Seed for reproducibility (minimum: 1) |
| `webhook_url` | `string` | No | - | URL for task completion notification |
## Frequently Asked Questions
The Change Camera API transforms the camera perspective of any image using AI. You submit an image URL with desired camera angle parameters (horizontal rotation, vertical tilt, and zoom), receive a task ID immediately, then poll for results or receive a webhook notification when processing completes. The AI generates a new image as if the camera had been repositioned around the subject.
The Change Camera API accepts images via publicly accessible HTTPS URLs. Supported input formats are JPG, PNG, and WebP. Output is available in PNG (lossless, default) or JPEG (compressed) format, controlled by the `output_format` parameter.
The `horizontal_angle` parameter rotates the camera around the subject from 0 to 360 degrees. Key positions: `0` is the front view, `90` is the right side, `180` is the back view, `270` is the left side, and `360` returns to the front (equivalent to `0`). The default is `0` (front view).
The `vertical_angle` parameter tilts the camera up or down relative to the subject. Values range from `-30` (looking up at the subject from below) through `0` (eye level, default) to `90` (bird's eye view looking straight down). A value of `45` provides a moderate downward angle.
Yes. Use the `seed` parameter with the same value across requests. Combined with identical image URLs and camera parameters, the API produces consistent output. This is useful for fine-tuning angles iteratively.
Rate limits vary by subscription tier. See [Rate Limits](/ratelimits) for current limits.
See the [Pricing page](/pricing) for current rates and subscription options.
## Best practices
* **Start with defaults**: Begin with default values (`horizontal_angle=0`, `vertical_angle=0`, `zoom=5`) and adjust one parameter at a time to understand the effect
* **Subtle angle changes**: Small adjustments (15-30 degrees horizontal, 10-20 degrees vertical) often produce the most realistic results
* **Input quality**: Use high-resolution, well-lit images for best perspective transformation quality
* **Seed for iteration**: Use the `seed` parameter when fine-tuning angles to isolate the effect of each parameter change
* **Production integration**: Use webhooks instead of polling for scalable applications
* **Error handling**: Implement retry logic with exponential backoff for 503 errors
## Related APIs
* **[Image Upscaler](/api-reference/image-upscaler-precision-v2/overview)**: Enhance image resolution before or after camera angle transformation
* **[Style Transfer](/api-reference/image-style-transfer/image-styletransfer)**: Apply artistic styles to images after changing the perspective
* **[Remove Background](/api-reference/remove-background/overview)**: Remove backgrounds for clean subject isolation before camera transformation
# Change Camera - Get task status
Source: https://docs.magnific.com/api-reference/image-change-camera/task-by-id
get /v1/ai/image-change-camera/{task-id}
Retrieve the status and result of a specific Change Camera task by its task ID. When the task status is `completed`, the response includes the URL of the generated image with the new camera angle.
# Get the status of all image expand tasks
Source: https://docs.magnific.com/api-reference/image-expand/get-flux-pro
get /v1/ai/image-expand/flux-pro
# Get the status of all image expand seedream v4.5 tasks
Source: https://docs.magnific.com/api-reference/image-expand/get-seedream-v4-5
get /v1/ai/image-expand/seedream-v4-5
# Get the status of one image expand seedream v4.5 task
Source: https://docs.magnific.com/api-reference/image-expand/get-seedream-v4-5-task
get /v1/ai/image-expand/seedream-v4-5/{task-id}
# Get the status of one image expand task
Source: https://docs.magnific.com/api-reference/image-expand/get-{task-id}-by-id
get /v1/ai/image-expand/flux-pro/{task-id}
# Ideogram - Expand image
Source: https://docs.magnific.com/api-reference/image-expand/ideogram/expand-image
post /v1/ai/image-expand/ideogram
This endpoint allows you to expand an image using the Ideogram AI model. The image will be expanded based on the provided pixel values for each side.
If no prompt is provided, the model will auto-generate one based on the image content.
# Get the status of all image expand ideogram tasks
Source: https://docs.magnific.com/api-reference/image-expand/ideogram/ideogram-tasks
get /v1/ai/image-expand/ideogram
# Ideogram Image Expand API
Source: https://docs.magnific.com/api-reference/image-expand/ideogram/overview
Expand images beyond their original boundaries with Ideogram Image Expand. AI-powered outpainting with directional control up to 2048 pixels per side and optional prompt guidance.
Powered by Ideogram AI, this API expands images beyond their original boundaries with intelligent content generation that blends seamlessly with the original.
Ideogram Image Expand is an AI-powered outpainting API that extends images beyond their original boundaries using Ideogram's generative model. Specify how many pixels to add on each side (left, right, top, bottom) up to 2048 pixels, and optionally provide a text prompt to guide the generated content. If no prompt is provided, the model auto-generates one based on the image content. The API produces seamless expansions that maintain visual consistency with the original image, making it ideal for adapting images to different aspect ratios or adding creative space around subjects.
### Key capabilities
* **Directional expansion**: Independently control expansion on each edge (left, right, top, bottom) from 0 to 2048 pixels
* **Auto-prompt generation**: Automatically generates a prompt from the image content when no prompt is provided
* **Prompt-guided generation**: Optional text descriptions to guide what appears in expanded areas
* **Seamless blending**: AI-generated content matches the style, lighting, and composition of the original image
* **Reproducible results**: Optional seed parameter (0-2147483647) for consistent output across requests
* **Async processing**: Webhook notifications or polling for task completion
### Use cases
* **Social media adaptation**: Convert landscape images to portrait format (or vice versa) for different platforms
* **Print production**: Add bleed area or extend backgrounds for large-format printing
* **Design workflows**: Create additional canvas space for text overlays, logos, or design elements
* **Photography enhancement**: Extend cropped photos to recover lost composition
* **E-commerce**: Expand product images to fit standardized dimensions
* **Marketing materials**: Adapt hero images to various banner sizes and aspect ratios
### Expand images with Ideogram
Submit an image with expansion parameters to extend it in any direction. The service returns a task ID for async polling or webhook notification.
Create a new image expansion task
List all Ideogram image expansion tasks
Get task status and results by ID
### Parameters
| Parameter | Type | Required | Default | Description |
| ------------- | --------- | -------- | -------------- | ------------------------------------------------------------------------------------------------------------------------ |
| `image` | `string` | Yes | - | Base64-encoded image to expand |
| `left` | `integer` | Yes | - | Pixels to expand on the left side (0-2048) |
| `right` | `integer` | Yes | - | Pixels to expand on the right side (0-2048) |
| `top` | `integer` | Yes | - | Pixels to expand on the top side (0-2048) |
| `bottom` | `integer` | Yes | - | Pixels to expand on the bottom side (0-2048) |
| `prompt` | `string` | No | auto-generated | Text prompt describing the desired expanded content. If not provided, the AI auto-generates a prompt based on the image. |
| `seed` | `integer` | No | random | Seed for reproducibility (0-2147483647) |
| `webhook_url` | `string` | No | - | URL for task completion notification |
## Frequently Asked Questions
Ideogram Image Expand is an AI-powered outpainting API that extends images beyond their original boundaries. You submit a base64-encoded image with pixel expansion values for each edge (left, right, top, bottom), receive a task ID immediately, then poll for results or receive a webhook notification when processing completes. The API generates new content that seamlessly blends with the original image.
You can expand up to 2048 pixels on each edge (left, right, top, bottom) independently. All four directional parameters (left, right, top, bottom) are required. Set any edge to 0 if you do not want to expand in that direction.
If no prompt is provided, the Ideogram model automatically generates a prompt based on the image content. This auto-prompt feature analyzes the existing image and produces contextually appropriate content for the expanded areas.
The API accepts base64-encoded images. Common formats like JPEG, PNG, and WebP can be encoded and submitted. The output is returned as a downloadable image URL.
Yes. Use the `seed` parameter with the same value (0-2147483647) across requests to generate reproducible results. Combined with identical images, expansion values, and prompts, you will get consistent outputs.
Both APIs extend images beyond their original boundaries. Ideogram Image Expand features auto-prompt generation when no prompt is provided and requires all four directional parameters. Flux Pro Image Expand uses optional directional parameters with default values of 0. Choose based on your workflow preferences and output quality requirements.
Rate limits vary by subscription tier. See [Rate Limits](/ratelimits) for current limits.
See the [Pricing page](/pricing) for current rates and subscription options.
## Best practices
* **Balanced expansion**: For best results, avoid extreme asymmetric expansions; gradual extensions maintain better visual coherence
* **Prompt specificity**: Use descriptive prompts when you need specific content in expanded areas (e.g., "sunset sky with orange clouds" instead of just "sky")
* **Auto-prompt for natural results**: Omit the prompt parameter to let the model analyze the image and generate contextually appropriate content
* **Image quality**: Higher resolution input images produce better expansion results
* **Seed for consistency**: Use the same seed value when you need reproducible results across multiple API calls
* **Production integration**: Use webhooks instead of polling for scalable applications
* **Error handling**: Implement retry logic with exponential backoff for 503 errors
## Related APIs
* **[Flux Pro Image Expand](/api-reference/image-expand/overview)**: Alternative image expansion API powered by Flux Pro
* **[Image Upscaler](/api-reference/image-upscaler-creative/post-image-upscaler)**: Enhance image resolution and quality
* **[Remove Background](/api-reference/remove-background/post-beta-remove-background)**: Remove image backgrounds for compositing
# Get the status of one image expand ideogram task
Source: https://docs.magnific.com/api-reference/image-expand/ideogram/task-by-id
get /v1/ai/image-expand/ideogram/{task-id}
# Flux Pro Image Expand - Outpainting API | Magnific API
Source: https://docs.magnific.com/api-reference/image-expand/overview
Expand images beyond their original boundaries with Flux Pro Image Expand. AI-powered outpainting with directional control up to 2048 pixels per side. Perfect for social media, print, and design workflows.
Powered by Flux Pro, this API expands images beyond their original boundaries using AI-generated content that seamlessly blends with the original.
Flux Pro Image Expand is an AI-powered outpainting API that extends images beyond their original boundaries. Specify how many pixels to add on each side (left, right, top, bottom) up to 2048 pixels, and optionally provide a text prompt to guide the generated content. The API produces seamless expansions that maintain visual consistency with the original image, making it ideal for adapting images to different aspect ratios or adding creative space around subjects.
### Key capabilities
* **Directional expansion**: Independently control expansion on each edge (left, right, top, bottom) from 0 to 2048 pixels
* **Prompt-guided generation**: Optional text descriptions to guide what appears in expanded areas
* **Seamless blending**: AI-generated content matches the style, lighting, and composition of the original image
* **Flexible input**: Accept base64-encoded images for easy integration
* **High-resolution output**: Support for substantial canvas extensions while maintaining quality
* **Async processing**: Webhook notifications or polling for task completion
### Use cases
* **Social media adaptation**: Convert landscape images to portrait format (or vice versa) for different platforms
* **Print production**: Add bleed area or extend backgrounds for large-format printing
* **Design workflows**: Create additional canvas space for text overlays, logos, or design elements
* **Photography enhancement**: Extend cropped photos to recover lost composition
* **E-commerce**: Expand product images to fit standardized dimensions
* **Marketing materials**: Adapt hero images to various banner sizes and aspect ratios
### Expand images with Flux Pro
Submit an image with expansion parameters to extend it in any direction. The service returns a task ID for async polling or webhook notification.
Create a new image expansion task
List all image expansion tasks
Get task status and results by ID
### Parameters
| Parameter | Type | Required | Default | Description |
| ------------- | --------- | -------- | ------- | -------------------------------------------------------------------------------------- |
| `image` | `string` | Yes | - | Base64-encoded image to expand |
| `prompt` | `string` | No | - | Text description to guide the expanded areas (e.g., "sunset sky", "forest background") |
| `left` | `integer` | No | `0` | Pixels to expand on the left edge (0-2048) |
| `right` | `integer` | No | `0` | Pixels to expand on the right edge (0-2048) |
| `top` | `integer` | No | `0` | Pixels to expand on the top edge (0-2048) |
| `bottom` | `integer` | No | `0` | Pixels to expand on the bottom edge (0-2048) |
| `webhook_url` | `string` | No | - | URL for task completion notification |
## Frequently Asked Questions
Flux Pro Image Expand is an AI-powered outpainting API that extends images beyond their original boundaries. You submit a base64-encoded image with expansion values for each edge (left, right, top, bottom), receive a task ID immediately, then poll for results or receive a webhook notification. The API generates new content that seamlessly blends with the original image.
You can expand up to 2048 pixels on each edge (left, right, top, bottom) independently. Set any edge to 0 if you do not want to expand in that direction. For example, to only extend the width, set `left` and `right` values while keeping `top` and `bottom` at 0.
The API accepts base64-encoded images. Common formats like JPEG, PNG, and WebP can be encoded and submitted. The output is returned as a downloadable image URL.
The optional `prompt` parameter guides what the AI generates in the expanded areas. For example, "blue sky with clouds" will generate sky content, while "brick wall" will generate a wall background. If omitted, the AI infers appropriate content from the existing image context.
Yes, Flux Pro analyzes your image's style, lighting, color palette, and composition to generate expansions that blend seamlessly. The AI maintains visual consistency so the final image appears natural and cohesive.
Rate limits vary by subscription tier. See [Rate Limits](/ratelimits) for current limits.
See the [Pricing page](/pricing) for current rates and subscription options.
## Best practices
* **Balanced expansion**: For best results, avoid extreme asymmetric expansions; gradual extensions maintain better visual coherence
* **Prompt specificity**: Use descriptive prompts when you need specific content in expanded areas (e.g., "ocean waves" instead of just "water")
* **Image quality**: Higher resolution input images produce better expansion results
* **Edge content**: Ensure the edges of your original image have enough context for the AI to continue naturally
* **Production integration**: Use webhooks instead of polling for scalable applications
* **Error handling**: Implement retry logic with exponential backoff for 503 errors
## Related APIs
* **[Flux 2 Pro](/api-reference/text-to-image/post-flux-2-pro)**: Generate images from text descriptions
* **[Flux Kontext Pro](/api-reference/text-to-image/flux-kontext-pro/overview)**: Text-to-image with context understanding and image guidance
* **[Image Upscaler](/api-reference/image-upscaler-creative/post-image-upscaler)**: Enhance image resolution and quality
* **[Remove Background](/api-reference/remove-background/post-beta-remove-background)**: Remove image backgrounds for compositing
# Flux Pro - Expand image
Source: https://docs.magnific.com/api-reference/image-expand/post-flux-pro
post /v1/ai/image-expand/flux-pro
This endpoint allows you to expand an image using the AI Flux Pro model. The image will be expanded based on the provided parameters.
# Seedream V4.5 - Expand image
Source: https://docs.magnific.com/api-reference/image-expand/post-seedream-v4-5
post /v1/ai/image-expand/seedream-v4-5
This endpoint allows you to expand an image using the Seedream V4.5 AI model. The image will be expanded based on the provided pixel values for each side.
If no prompt is provided, the model will auto-generate one based on the image content.
# Seedream V4.5 Image Expand API
Source: https://docs.magnific.com/api-reference/image-expand/seedream-v4-5-overview
Expand images beyond their original boundaries with Seedream V4.5. AI-powered outpainting with directional control up to 2048 pixels per side, auto-prompt generation, and optional seed for reproducibility.
Powered by Seedream V4.5, this API expands images beyond their original boundaries with intelligent content generation that blends seamlessly with the original.
Seedream V4.5 Image Expand is an AI-powered outpainting API that extends images beyond their original boundaries using the Seedream V4.5 generative model. Specify how many pixels to add on each side (left, right, top, bottom) up to 2048 pixels, and optionally provide a text prompt to guide the generated content. If no prompt is provided, the model auto-generates one based on the image content. The API produces seamless expansions that maintain visual consistency with the original image, making it ideal for adapting images to different aspect ratios or adding creative space around subjects.
### Key capabilities
* **Directional expansion**: Independently control expansion on each edge (left, right, top, bottom) from 0 to 2048 pixels
* **Auto-prompt generation**: Automatically generates a prompt from the image content when no prompt is provided
* **Prompt-guided generation**: Optional text descriptions to guide what appears in expanded areas
* **Seamless blending**: AI-generated content matches the style, lighting, and composition of the original image
* **Reproducible results**: Optional seed parameter (0-2147483647) for consistent output across requests
* **Flexible input**: Accepts HTTPS URLs or base64-encoded images (max 10MB)
* **Async processing**: Webhook notifications or polling for task completion
### Use cases
* **Social media adaptation**: Convert landscape images to portrait format (or vice versa) for different platforms
* **Print production**: Add bleed area or extend backgrounds for large-format printing
* **Design workflows**: Create additional canvas space for text overlays, logos, or design elements
* **Photography enhancement**: Extend cropped photos to recover lost composition
* **E-commerce**: Expand product images to fit standardized dimensions
* **Marketing materials**: Adapt hero images to various banner sizes and aspect ratios
### Expand images with Seedream V4.5
Submit an image with expansion parameters to extend it in any direction. The service returns a task ID for async polling or webhook notification.
Create a new image expansion task
List all Seedream V4.5 image expansion tasks
Get task status and results by ID
### Parameters
| Parameter | Type | Required | Default | Description |
| ------------- | --------- | -------- | -------------- | ------------------------------------------------------------------------------------------------------------------------ |
| `image` | `string` | Yes | - | Image to expand. Accepts an HTTPS URL or a base64-encoded image (max 10MB) |
| `left` | `integer` | Yes | - | Pixels to expand on the left side (0-2048) |
| `right` | `integer` | Yes | - | Pixels to expand on the right side (0-2048) |
| `top` | `integer` | Yes | - | Pixels to expand on the top side (0-2048) |
| `bottom` | `integer` | Yes | - | Pixels to expand on the bottom side (0-2048) |
| `prompt` | `string` | No | auto-generated | Text prompt describing the desired expanded content. If not provided, the AI auto-generates a prompt based on the image. |
| `seed` | `integer` | No | random | Seed for reproducibility (0-2147483647) |
| `webhook_url` | `string` | No | - | URL for task completion notification |
## Frequently Asked Questions
Seedream V4.5 Image Expand is an AI-powered outpainting API that extends images beyond their original boundaries. You submit an image (URL or base64) with pixel expansion values for each edge (left, right, top, bottom), receive a task ID immediately, then poll for results or receive a webhook notification when processing completes. The API generates new content that seamlessly blends with the original image.
You can expand up to 2048 pixels on each edge (left, right, top, bottom) independently. All four directional parameters (left, right, top, bottom) are required. Set any edge to 0 if you do not want to expand in that direction.
If no prompt is provided, the Seedream V4.5 model automatically generates a prompt based on the image content. This auto-prompt feature analyzes the existing image and produces contextually appropriate content for the expanded areas.
The API accepts HTTPS URLs or base64-encoded images up to 10MB. Common formats like JPEG, PNG, and WebP are supported. The output is returned as a downloadable image URL.
Yes. Use the `seed` parameter with the same value (0-2147483647) across requests to generate reproducible results. Combined with identical images, expansion values, and prompts, you will get consistent outputs.
Rate limits vary by subscription tier. See [Rate Limits](/ratelimits) for current limits.
See the [Pricing page](/pricing) for current rates and subscription options.
## Best practices
* **Balanced expansion**: For best results, avoid extreme asymmetric expansions; gradual extensions maintain better visual coherence
* **Prompt specificity**: Use descriptive prompts when you need specific content in expanded areas (e.g., "sunset sky with orange clouds" instead of just "sky")
* **Auto-prompt for natural results**: Omit the prompt parameter to let the model analyze the image and generate contextually appropriate content
* **Image quality**: Higher resolution input images produce better expansion results
* **Seed for consistency**: Use the same seed value when you need reproducible results across multiple API calls
* **Production integration**: Use webhooks instead of polling for scalable applications
* **Error handling**: Implement retry logic with exponential backoff for 503 errors
## Related APIs
* **[Flux Pro Image Expand](/api-reference/image-expand/overview)**: Alternative image expansion API powered by Flux Pro
* **[Ideogram Image Expand](/api-reference/image-expand/ideogram/overview)**: Alternative image expansion API powered by Ideogram
* **[Image Upscaler](/api-reference/image-upscaler-creative/post-image-upscaler)**: Enhance image resolution and quality
* **[Remove Background](/api-reference/remove-background/post-beta-remove-background)**: Remove image backgrounds for compositing
# Relight - Get task status
Source: https://docs.magnific.com/api-reference/image-relight/get-image-relight
get /v1/ai/image-relight/{task-id}
Get the status of the relight task
# Relight - List tasks
Source: https://docs.magnific.com/api-reference/image-relight/get-image-relight-task
get /v1/ai/image-relight
Get the status of all relight tasks
# Overview
Source: https://docs.magnific.com/api-reference/image-relight/image-relight
Image Relight allows you to change the entire lighting of a scene and, optionally, the background using:
1. A prompt
2. A reference image
3. A light map
This tool can simulate different lighting scenarios, enhance details, and create artistic effects. Our API lets you transform your images with custom prompts and fine-tuned parameters for impressive results.
Image Relight uses Magnific.ai technology, now available as a comprehensive API service.
### Use Cases
The Image Relight can be applied to a wide range of image types and industries, including:
* Portraits: Change lighting to enhance facial features
* Product photography: Adjust lighting for better presentation
* Architectural renderings: Simulate different times of day
* Film stills: Create dramatic lighting effects
* Graphic design: Add creative lighting to designs
* Nature photography: Enhance natural light conditions
### Selecting Light Transfer Method
Choose one of these three ways to transfer light in Image Relight:
1. **Prompt** Describe the desired lighting using text. Specify characteristics like color, time of day, type and shape of light.
Example: "A sunlit forest clearing at golden hour" or "Under the water"
2. **Reference Image** Provide an image to transfer lighting from. Image Relight will replicate the light, colors, and shadows from this reference.
3. **Lightmap** Create custom lighting with your own lightmap image:
* Black represents absence of light
* Lighter colors (including white) indicate presence, color, and shape of light sources
Relight an image using AI
Get the status of a relighting task
Get the status of all relighting tasks
### Image Input Best Practices
For maximum quality results, how you send your image matters:
| Action | Quality Impact |
| ------------------------------------------ | -------------------------- |
| Send URL of original image | ✅ Maximum quality |
| Send base64 of original file read directly | ✅ Maximum quality |
| Use `canvas.toDataURL('image/jpeg')` | ❌ \~8% quality loss |
| Use `canvas.toDataURL('image/jpeg', 0.8)` | ❌ \~20% quality loss |
| Resize image before sending | ❌ Significant quality loss |
| Convert PNG → JPEG before sending | ❌ Quality loss |
**Recommended:** Send the original image via URL whenever possible. This ensures the AI receives the highest quality input, which directly impacts output quality.
### Frequently Asked Questions
Yes! Magnific.ai is part of Magnific and we are happy to offer the same technology in an API service. If you tried Magnific.ai before, you will get the same technology and its future updates.
The cost per image relight is a fixed cost of €0.10 per operation. This ensures that you have complete transparency and control over your usage.
# Relight - Adjust image lighting
Source: https://docs.magnific.com/api-reference/image-relight/post-image-relight
post /v1/ai/image-relight
Relight an image using AI. This endpoint accepts a variety of parameters to customize the generated images.
## Important
Upscaler endpoints are only available for premium API users. You can upgrade your account [here](https://www.magnific.com/api#pricing).
## Request
# Style Transfer - List tasks
Source: https://docs.magnific.com/api-reference/image-style-transfer/get-image-style-transfer
get /v1/ai/image-style-transfer
Get the status of all Style Transfer tasks
# Style Transfer - Get task status
Source: https://docs.magnific.com/api-reference/image-style-transfer/get-image-style-transfer-task
get /v1/ai/image-style-transfer/{task-id}
Get the status of the Style Transfer task
# Overview
Source: https://docs.magnific.com/api-reference/image-style-transfer/image-styletransfer
Image Style Transfer is a powerful AI-driven tool that allows you to transform any image by applying various artistic styles. This technology goes beyond simple filters, enabling you to control the amount of style transferred and maintain structural integrity. With our API, you can:
1. Apply predefined artistic styles
2. Use custom images as style references
3. Fine-tune the style transfer process with advanced parameters
4. Transform images while preserving important details
5. Combine style transfer with upscaling for high-resolution results
Whether you're a professional artist, game developer, or just looking to have fun with your photos, Image Style Transfer opens up a world of creative possibilities.
### Use Cases
Image Style Transfer can be applied to various industries and creative projects, some examples are:
* **Video Game Development**: Transform concept art and create stylized game assets
* **Film and VFX**: Create dramatic lighting effects and stylized scenes
* **Interior Design**: Visualize room makeovers with different design styles
* **3D Rendering**: Texturize and light 3D renders using reference images
* **Sketch Transformation**: Convert sketches into detailed, styled artwork
### Key Features
* **Control Over Style Intensity**: Adjust the strength of the style transfer to find the perfect balance between the original image and the new style.
* **Structure Preservation**: Maintain important details and structural elements of the original image while applying new styles.
* **Prompt-Guided Transformations**: Use text prompts to further refine and direct the style transfer process.
* **Multiple Style Engines**: Choose from various AI engines optimized for different types of style transfers.
By leveraging the power of AI, Image Style Transfer enables creators to push the boundaries of visual art and design, saving hours of manual work and opening up new realms of creative possibility.
API Reference: Image Style Transfer
### Image Input Best Practices
For maximum quality results, how you send your image matters:
| Action | Quality Impact |
| ------------------------------------------ | -------------------------- |
| Send URL of original image | ✅ Maximum quality |
| Send base64 of original file read directly | ✅ Maximum quality |
| Use `canvas.toDataURL('image/jpeg')` | ❌ \~8% quality loss |
| Use `canvas.toDataURL('image/jpeg', 0.8)` | ❌ \~20% quality loss |
| Resize image before sending | ❌ Significant quality loss |
| Convert PNG → JPEG before sending | ❌ Quality loss |
**Recommended:** Send the original image via URL whenever possible. This ensures the AI receives the highest quality input, which directly impacts output quality.
### Frequently Asked Questions
Yes! Magnific.ai is part of Magnific and we are happy to offer the same technology in an API service. If you tried Magnific.ai before, you will get the same technology and its future updates.
The cost per image style transfer is a fixed cost of €0.10 per operation. This ensures that you have complete transparency and control over your usage.
# Style Transfer - Transform image style
Source: https://docs.magnific.com/api-reference/image-style-transfer/post-image-style-transfer
post /v1/ai/image-style-transfer
# Image to Prompt - List tasks
Source: https://docs.magnific.com/api-reference/image-to-prompt/get-image-to-prompt
get /v1/ai/image-to-prompt
Get the status of all image-to-prompt tasks
# Image to Prompt - Get task status
Source: https://docs.magnific.com/api-reference/image-to-prompt/get-{task-id}-by-id
get /v1/ai/image-to-prompt/{task-id}
Get the status of one image-to-prompt task
# Image to Prompt - AI Image Analysis API | Magnific API
Source: https://docs.magnific.com/api-reference/image-to-prompt/overview
Generate descriptive prompts from images with Image to Prompt API. Extract detailed text descriptions for AI workflows. Perfect for prompt engineering and image cataloging.
Analyze any image and generate detailed text prompts that describe its content, style, and composition.
Image to Prompt is an AI-powered API that analyzes images and generates descriptive text prompts. Submit any image and receive a detailed text description suitable for use with AI image generation models. The API extracts visual elements, artistic styles, compositions, and contextual details to create prompts that can reproduce or inspire similar images.
### Key capabilities
* **Automatic image analysis**: AI extracts subjects, objects, colors, lighting, and composition from images
* **Prompt-ready output**: Generated descriptions formatted for direct use with text-to-image models
* **Flexible input**: Accepts images via URL or base64-encoded string
* **Style detection**: Identifies artistic styles, photography techniques, and visual aesthetics
* **Detail extraction**: Captures fine details including textures, materials, and environmental elements
* **Multi-format support**: Works with common image formats (JPEG, PNG, WebP)
* **Async processing**: Webhook notifications or polling for task completion
### Use cases
* **Prompt engineering**: Reverse-engineer prompts from reference images to recreate similar styles
* **Image cataloging**: Generate searchable text descriptions for image libraries
* **AI workflow automation**: Bridge image-to-text pipelines for automated content creation
* **Style transfer preparation**: Extract style descriptions for consistent AI image generation
* **Content moderation**: Generate text descriptions for image review and classification
* **Accessibility**: Create alt-text descriptions for images in web applications
### Generate prompts with Image to Prompt
Submit an image via URL or base64-encoded string. The service returns a task ID for async polling or webhook notification.
Create a new image analysis task
List all image-to-prompt tasks
Get task status and results by ID
### Parameters
| Parameter | Type | Required | Default | Description |
| ------------- | -------- | -------- | ------- | --------------------------------------------------------------------------------------------------- |
| `image` | `string` | Yes | - | Input image for analysis. Accepts URL or base64-encoded string (e.g., `data:image/jpeg;base64,...`) |
| `webhook_url` | `string` | No | - | URL for task completion notification |
### Response
When the task completes successfully, the response includes:
| Field | Type | Description |
| ----------- | -------- | --------------------------------------------------------------- |
| `task_id` | `string` | Unique identifier for the task (UUID format) |
| `status` | `string` | Task status: `CREATED`, `IN_PROGRESS`, `COMPLETED`, or `FAILED` |
| `generated` | `array` | Array containing the generated prompt text |
## Frequently Asked Questions
Image to Prompt is an AI-powered API that analyzes images and generates text descriptions suitable for AI image generation. You submit an image (via URL or base64), receive a task ID immediately, then poll for results or receive a webhook notification. The output is a detailed text prompt describing the image content, style, and composition.
Image to Prompt accepts common image formats including JPEG, PNG, and WebP. Images can be provided as publicly accessible URLs or as base64-encoded strings with the appropriate data URI prefix (e.g., `data:image/jpeg;base64,...`).
The generated prompts capture multiple aspects of the image including subjects, objects, colors, lighting, composition, artistic style, and fine details like textures and materials. The descriptions are formatted for direct use with AI image generation models like Flux, Seedream, or Mystic.
Yes, the prompts generated by Image to Prompt are designed to work with any text-to-image AI model. Use them directly with Magnific API models like [Flux](/api-reference/text-to-image/flux-kontext-pro/overview), [Seedream](/api-reference/text-to-image/seedream-4/overview), or [Mystic](/api-reference/mystic/mystic), or with external image generation services.
Processing time varies based on image complexity and current system load. Typical analysis completes within a few seconds. For production workflows, use webhooks instead of polling to receive instant notifications when processing completes.
Rate limits vary by subscription tier. See [Rate Limits](/ratelimits) for current limits.
See the [Pricing page](/pricing) for current rates and subscription options.
## Best practices
* **Image quality**: Higher resolution images with clear subjects produce more detailed and accurate prompts
* **URL accessibility**: Ensure image URLs are publicly accessible without authentication
* **Base64 encoding**: Include the proper data URI prefix when using base64 (e.g., `data:image/jpeg;base64,`)
* **Production integration**: Use webhooks instead of polling for scalable applications
* **Prompt refinement**: Use generated prompts as starting points and refine them for specific use cases
* **Error handling**: Implement retry logic with exponential backoff for 503 errors
## Related APIs
* **[Improve Prompt](/api-reference/improve-prompt/post-improve-prompt)**: Enhance and refine text prompts for better AI generation results
* **[Flux Kontext Pro](/api-reference/text-to-image/flux-kontext-pro/overview)**: Generate images from text prompts with advanced context understanding
* **[Seedream 4](/api-reference/text-to-image/seedream-4/overview)**: High-quality text-to-image generation with detailed prompt support
* **[Mystic](/api-reference/mystic/mystic)**: Magnific's flagship image generation model with style customization
# Image to Prompt - Generate prompt
Source: https://docs.magnific.com/api-reference/image-to-prompt/post-image-to-prompt
post /v1/ai/image-to-prompt
Generate descriptive prompts from input images using AI analysis
# Get all Veo 3.1 I2V tasks
Source: https://docs.magnific.com/api-reference/image-to-video/get-veo-3-1
get /v1/ai/image-to-video/veo-3-1
# Get all Veo 3.1 I2V Fast tasks
Source: https://docs.magnific.com/api-reference/image-to-video/get-veo-3-1-fast
get /v1/ai/image-to-video/veo-3-1-fast
# Get Veo 3.1 I2V Fast task by ID
Source: https://docs.magnific.com/api-reference/image-to-video/get-veo-3-1-fast-task
get /v1/ai/image-to-video/veo-3-1-fast/{task-id}
# Get all Veo 3.1 Lite I2V tasks
Source: https://docs.magnific.com/api-reference/image-to-video/get-veo-3-1-lite
get /v1/ai/image-to-video/veo-3-1-lite
# Get Veo 3.1 Lite I2V task by ID
Source: https://docs.magnific.com/api-reference/image-to-video/get-veo-3-1-lite-task
get /v1/ai/image-to-video/veo-3-1-lite/{task-id}
# Get Veo 3.1 I2V task by ID
Source: https://docs.magnific.com/api-reference/image-to-video/get-veo-3-1-task
get /v1/ai/image-to-video/veo-3-1/{task-id}
# Happy Horse 1.1 - Create video from image
Source: https://docs.magnific.com/api-reference/image-to-video/happy-horse-1-1/generate
post /v1/ai/image-to-video/happy-horse-1-1
Animate a single image into a high-quality AI video using Happy Horse 1.1, Alibaba's image-to-video model. The image is used as the first frame and an optional text prompt guides motion and style.
**Key features:**
- 720P and 1080P resolution support
- Duration: 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, or 15 seconds
- Optional prompt up to 2500 characters
# Happy Horse 1.1 I2V - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/happy-horse-1-1/happy-horse-1-1-i2v-tasks
get /v1/ai/image-to-video/happy-horse-1-1
Retrieve the list of all Happy Horse 1.1 image-to-video tasks for the authenticated user.
# Happy Horse 1.1 Image To Video API
Source: https://docs.magnific.com/api-reference/image-to-video/happy-horse-1-1/overview
Animate images into AI videos with Happy Horse 1.1. 720P and 1080P resolution, 3-15 second durations, prompt-guided motion, from Alibaba ATH.
Happy Horse 1.1 Image-to-Video animates a single image into a high-quality video, the latest iteration of Alibaba ATH's Happy Horse family with strong motion fidelity and prompt adherence.
Happy Horse 1.1 Image-to-Video is an AI video generation API that animates a single still image into an MP4 video. Built by Alibaba ATH (Taotian Innovation Unit, led by Zhang Di), the model uses your image as the first frame and an optional text prompt to guide motion and style, producing videos at 720P (1280x720) or 1080P (1920x1080) resolution with durations from 3 to 15 seconds.
### Key capabilities
* **State-of-the-art quality**: Latest iteration of the Alibaba ATH Happy Horse video family
* **First-frame animation**: Use any supported image as the starting frame for the video
* **Resolution options**: 720P (1280x720) and 1080P (1920x1080) output
* **Flexible durations**: 3 to 15 seconds of video output (default 5 seconds)
* **Prompt-guided motion**: Optional prompt (up to 2500 characters) controls motion and style
* **Wide image format support**: JPEG, JPG, PNG, BMP, WEBP (300px+ on each side, max 10 MB)
* **Reproducible results**: Fixed seed support (0 to 2147483647) for consistent generation
* **Async processing**: Webhook notifications or polling for task completion
### Use cases
* **Product animation**: Bring product imagery to life with smooth motion and camera movements
* **Marketing videos**: Animate brand visuals and hero shots into short-form video content
* **Social media content**: Create video posts from static images for TikTok, Instagram, and YouTube
* **Storyboarding**: Animate concept art or wireframes to preview motion sequences
* **Photography to motion**: Add subtle motion to still photos for cinemagraphs and immersive content
* **Creative exploration**: Experiment with motion prompts on the same image for varied results
### API operations
Generate videos by submitting an image URL and optional prompt to the API. The service returns a task ID for async polling or webhook notification.
Create a new image-to-video generation task
List all Happy Horse 1.1 I2V tasks with status
Get task status and results by ID
### Parameters
| Parameter | Type | Required | Default | Description |
| ------------- | --------- | -------- | --------- | ------------------------------------------------------------------------------------------------------------------ |
| `image_url` | `string` | Yes | - | URL of the image to use as the first frame (JPEG/JPG/PNG/BMP/WEBP, 300px+, max 10 MB, aspect ratio 1:2.5 to 2.5:1) |
| `prompt` | `string` | No | - | Text prompt to guide motion and style. Max 2500 characters |
| `resolution` | `string` | No | `"1080P"` | Output resolution: `"720P"` or `"1080P"` |
| `duration` | `integer` | No | `5` | Video length in seconds: 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 |
| `seed` | `integer` | No | Random | Seed for reproducibility (0 to 2147483647) |
| `webhook_url` | `string` | No | - | URL for async status notifications |
When the task completes, the generated MP4 video URL is returned in `data.generated`. The URL is valid for 24 hours — download and persist it to permanent storage immediately.
## Frequently Asked Questions
Happy Horse 1.1 Image-to-Video is an AI model from Alibaba ATH that animates a single image into an MP4 video. It uses your image as the first frame and applies natural motion guided by an optional text prompt. It is the latest iteration of the Happy Horse video family.
Happy Horse 1.1 I2V accepts JPEG, JPG, PNG, BMP, and WEBP images via publicly accessible URLs. Each side must be at least 300 pixels, the aspect ratio must be between 1:2.5 and 2.5:1, and the file size must not exceed 10 MB.
No. The `prompt` parameter is optional but recommended. Without a prompt, the model generates natural motion based on the image content. With a prompt, you can describe specific motions, camera movements, or style cues for better control.
Happy Horse 1.1 I2V supports integer durations from 3 to 15 seconds. The default is 5 seconds. Allowed values: 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15.
The output aspect ratio is determined automatically by the dimensions of the input `image_url`. Provide an image with the aspect ratio you want for the output video.
Rate limits depend on your subscription tier. See the [Rate Limits](/ratelimits) page for current limits by plan.
See the [Pricing page](/pricing) for current rates and subscription options.
## Best practices
* **Image quality**: Use high-resolution images with clear subjects and balanced lighting. Avoid heavily compressed or noisy inputs.
* **Aspect ratio**: Provide an image already cropped to the target output ratio — output ratio matches the input image.
* **Prompt writing**: Even though prompts are optional, adding motion and camera directions ("subject walks forward, slow zoom in") improves results.
* **Duration selection**: Start with shorter durations (3-5 seconds) for quick iterations, then increase for final outputs.
* **Production integration**: Use webhooks for scalable applications instead of polling.
* **Error handling**: Implement retry with exponential backoff for 503 errors during high-demand periods.
## Related APIs
* **[Happy Horse 1.1 Text-to-Video](/api-reference/text-to-video/happy-horse-1-1/overview)**: Generate videos purely from text prompts
* **[Happy Horse 1.1 Reference-to-Video](/api-reference/reference-to-video/happy-horse-1-1/overview)**: Generate videos from up to 9 character reference images
* **[Happy Horse 1.0 Image-to-Video](/api-reference/image-to-video/happy-horse-1/overview)**: Previous Happy Horse iteration, ranked #1 on the Artificial Analysis Video Arena (April 2026)
# Happy Horse 1.1 I2V - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/happy-horse-1-1/task-by-id
get /v1/ai/image-to-video/happy-horse-1-1/{task-id}
Retrieve the status and result of a specific Happy Horse 1.1 image-to-video task by its ID.
# Happy Horse 1.0 - Create video from image
Source: https://docs.magnific.com/api-reference/image-to-video/happy-horse-1/generate
post /v1/ai/image-to-video/happy-horse-1
Animate a single image into a high-quality AI video using Happy Horse 1.0, Alibaba's image-to-video model. The image is used as the first frame and an optional text prompt guides motion and style.
**Key features:**
- 720P and 1080P resolution support
- Duration: 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, or 15 seconds
- Optional prompt up to 2500 characters
# Happy Horse 1.0 I2V - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/happy-horse-1/happy-horse-1-i2v-tasks
get /v1/ai/image-to-video/happy-horse-1
Retrieve the list of all Happy Horse 1.0 image-to-video tasks for the authenticated user.
# Happy Horse 1.0 Image To Video API
Source: https://docs.magnific.com/api-reference/image-to-video/happy-horse-1/overview
Animate images into AI videos with Happy Horse 1.0, ranked #1 on the Artificial Analysis Video Arena (April 2026). 720P and 1080P resolution, 3-15 second durations, prompt-guided motion.
Happy Horse 1.0 Image-to-Video animates a single image into a high-quality video, with #1 ranking on the Artificial Analysis Video Arena (April 2026) for I2V quality and motion fidelity.
Happy Horse 1.0 Image-to-Video is an AI video generation API that animates a single still image into an MP4 video. Built by Alibaba ATH (Taotian Innovation Unit, led by Zhang Di), it currently ranks #1 on the Artificial Analysis Video Arena leaderboard (April 2026) for image-to-video. The model uses your image as the first frame and an optional text prompt to guide motion and style, producing videos at 720P (1280x720) or 1080P (1920x1080) resolution with durations from 3 to 15 seconds.
### Key capabilities
* **State-of-the-art quality**: #1 on Artificial Analysis Video Arena (April 2026) for image-to-video
* **First-frame animation**: Use any supported image as the starting frame for the video
* **Resolution options**: 720P (1280x720) and 1080P (1920x1080) output
* **Flexible durations**: 3 to 15 seconds of video output (default 5 seconds)
* **Prompt-guided motion**: Optional prompt (up to 2500 characters) controls motion and style
* **Wide image format support**: JPEG, JPG, PNG, BMP, WEBP (300px+ on each side, max 10 MB)
* **Reproducible results**: Fixed seed support (0 to 2147483647) for consistent generation
* **Async processing**: Webhook notifications or polling for task completion
### Use cases
* **Product animation**: Bring product imagery to life with smooth motion and camera movements
* **Marketing videos**: Animate brand visuals and hero shots into short-form video content
* **Social media content**: Create video posts from static images for TikTok, Instagram, and YouTube
* **Storyboarding**: Animate concept art or wireframes to preview motion sequences
* **Photography to motion**: Add subtle motion to still photos for cinemagraphs and immersive content
* **Creative exploration**: Experiment with motion prompts on the same image for varied results
### API operations
Generate videos by submitting an image URL and optional prompt to the API. The service returns a task ID for async polling or webhook notification.
Create a new image-to-video generation task
List all Happy Horse 1.0 I2V tasks with status
Get task status and results by ID
### Parameters
| Parameter | Type | Required | Default | Description |
| ------------- | --------- | -------- | --------- | ------------------------------------------------------------------------------------------------------------------ |
| `image_url` | `string` | Yes | - | URL of the image to use as the first frame (JPEG/JPG/PNG/BMP/WEBP, 300px+, max 10 MB, aspect ratio 1:2.5 to 2.5:1) |
| `prompt` | `string` | No | - | Text prompt to guide motion and style. Max 2500 characters |
| `resolution` | `string` | No | `"1080P"` | Output resolution: `"720P"` or `"1080P"` |
| `duration` | `integer` | No | `5` | Video length in seconds: 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 |
| `seed` | `integer` | No | Random | Seed for reproducibility (0 to 2147483647) |
| `webhook_url` | `string` | No | - | URL for async status notifications |
## Frequently Asked Questions
Happy Horse 1.0 Image-to-Video is an AI model from Alibaba ATH that animates a single image into an MP4 video. It uses your image as the first frame and applies natural motion guided by an optional text prompt. As of April 2026, it ranks #1 on the Artificial Analysis Video Arena leaderboard for image-to-video quality.
Happy Horse 1.0 I2V accepts JPEG, JPG, PNG, BMP, and WEBP images via publicly accessible URLs. Each side must be at least 300 pixels, the aspect ratio must be between 1:2.5 and 2.5:1, and the file size must not exceed 10 MB.
No. The `prompt` parameter is optional but recommended. Without a prompt, the model generates natural motion based on the image content. With a prompt, you can describe specific motions, camera movements, or style cues for better control.
Happy Horse 1.0 I2V supports integer durations from 3 to 15 seconds. The default is 5 seconds. Allowed values: 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15.
The output aspect ratio is determined automatically by the dimensions of the input `image_url`. Provide an image with the aspect ratio you want for the output video.
Rate limits depend on your subscription tier. See the [Rate Limits](/ratelimits) page for current limits by plan.
See the [Pricing page](/pricing) for current rates and subscription options.
## Best practices
* **Image quality**: Use high-resolution images with clear subjects and balanced lighting. Avoid heavily compressed or noisy inputs.
* **Aspect ratio**: Provide an image already cropped to the target output ratio — output ratio matches the input image.
* **Prompt writing**: Even though prompts are optional, adding motion and camera directions ("subject walks forward, slow zoom in") improves results.
* **Duration selection**: Start with shorter durations (3-5 seconds) for quick iterations, then increase for final outputs.
* **Production integration**: Use webhooks for scalable applications instead of polling.
* **Error handling**: Implement retry with exponential backoff for 503 errors during high-demand periods.
## Related APIs
* **[Happy Horse 1.0 Text-to-Video](/api-reference/text-to-video/happy-horse-1/overview)**: Generate videos purely from text prompts
* **[Happy Horse 1.0 Reference-to-Video](/api-reference/reference-to-video/happy-horse-1/overview)**: Generate videos from up to 9 character reference images
* **[Happy Horse 1.0 Video Edit](/api-reference/video-edit/happy-horse-1/overview)**: Edit videos with natural-language instructions
* **[WAN 2.7 Image-to-Video](/api-reference/image-to-video/wan-2-7/overview)**: Alibaba WAN I2V with first+last frame and video continuation modes
# Happy Horse 1.0 I2V - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/happy-horse-1/task-by-id
get /v1/ai/image-to-video/happy-horse-1/{task-id}
Retrieve the status and result of a specific Happy Horse 1.0 image-to-video task by its ID.
# Kling Elements Pro - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/kling-elements-pro/get-kling-elements-pro
get /v1/ai/image-to-video/kling-elements-pro
Get the list of the kling-elements-pro tasks
# Kling Elements - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/kling-elements-pro/get-kling-elements-pro-task
get /v1/ai/image-to-video/kling-elements/{task-id}
Get the status of the kling-elements task
# Kling Elements Pro - Create video from image
Source: https://docs.magnific.com/api-reference/image-to-video/kling-elements-pro/post-kling-elements-pro
post /v1/ai/image-to-video/kling-elements-pro
Generate a video from an image using the Kling Elements Pro model.
## Important
The service allows up to 3 concurrent requests per user.
# Kling Elements Standard - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/kling-elements-std/get-kling-elements-std
get /v1/ai/image-to-video/kling-elements-std
Get the list of the kling-elements-std tasks
# Kling Elements - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/kling-elements-std/get-kling-elements-std-task
get /v1/ai/image-to-video/kling-elements/{task-id}
Get the status of the kling-elements task
# Kling Elements Standard - Create video from image
Source: https://docs.magnific.com/api-reference/image-to-video/kling-elements-std/post-kling-elements-std
post /v1/ai/image-to-video/kling-elements-std
Generate a video from an image using the Kling Elements Std model.
## Important
The service allows up to 3 concurrent requests per user.
# Kling O1 Pro - Create video from image
Source: https://docs.magnific.com/api-reference/image-to-video/kling-o1-pro
post /v1/ai/image-to-video/kling-o1-pro
# Kling O1 Pro - Create video with reference
Source: https://docs.magnific.com/api-reference/image-to-video/kling-o1-pro-video-reference
post /v1/ai/image-to-video/kling-o1-pro-video-reference
# Kling O1 Standard - Create video from image
Source: https://docs.magnific.com/api-reference/image-to-video/kling-o1-std
post /v1/ai/image-to-video/kling-o1-std
# Kling O1 Standard - Create video with reference
Source: https://docs.magnific.com/api-reference/image-to-video/kling-o1-std-video-reference
post /v1/ai/image-to-video/kling-o1-std-video-reference
# Kling O1 - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/kling-o1-tasks
get /v1/ai/image-to-video/kling-o1
Get the list of the kling-o1 tasks
# Kling O1 – Image-to-Video API
Source: https://docs.magnific.com/api-reference/image-to-video/kling-o1/overview
Create cinematic videos with first-to-last frame interpolation using Kling O1. Smooth transitions, reference image support, and Pro or Standard quality modes for 5 or 10 second outputs.
Generate smooth video sequences using first frame and last frame interpolation, with optional reference images for character and style consistency.
Kling O1 is an image-to-video API that creates cinematic video sequences by interpolating between a first frame and last frame. It delivers smooth transitions with controlled start and end points, suitable for creative professionals and automated workflows. Choose between Pro quality for premium results or Standard for faster, cost-effective generation.
### Key capabilities
* **Frame interpolation**: Generate smooth transitions between first and last frame images
* **Reference image support**: Maintain character and style consistency with up to 7 reference images
* **Dual quality modes**: Pro for professional-grade output, Standard for efficient generation
* **Flexible durations**: 5-second or 10-second video outputs
* **Multiple aspect ratios**: `16:9` (widescreen), `9:16` (vertical), `1:1` (square)
* **Prompt guidance**: Text descriptions up to 2500 characters to guide motion and style
* **Async processing**: Webhook notifications or polling for task completion
### Use cases
* **Film and animation**: Create smooth scene transitions and animated sequences
* **Marketing content**: Generate cinematic product reveals and brand videos
* **Social media**: Produce vertical and square videos optimized for Instagram, TikTok, and YouTube Shorts
* **E-commerce**: Animate static product images with controlled motion
* **Storytelling**: Build narrative sequences with consistent character appearance
* **Motion design**: Create abstract transitions and visual effects
### API endpoints
Generate videos by submitting a request to one of the Kling O1 endpoints. The service returns a task ID for async polling or webhook notification.
Pro quality video from first/last frame
Standard quality video from first/last frame
Pro quality with reference images
Standard quality with reference images
List all Kling O1 tasks
Get task status by ID
### Parameters
#### Image-to-Video (first/last frame)
| Parameter | Type | Required | Default | Description |
| -------------- | --------- | -------- | ------- | --------------------------------------------------------------- |
| `first_frame` | `string` | No\* | - | Starting image (URL or Base64). Min 300x300px, max 10MB |
| `last_frame` | `string` | No\* | - | Ending image (URL or Base64). Same requirements as first\_frame |
| `prompt` | `string` | No | - | Motion description up to 2500 characters |
| `aspect_ratio` | `string` | No | `16:9` | Video ratio: `16:9`, `9:16`, or `1:1` |
| `duration` | `integer` | No | `5` | Video length: `5` or `10` seconds |
| `webhook_url` | `string` | No | - | URL for completion notification |
\*At least one frame (first\_frame or last\_frame) is required.
#### Video Reference
| Parameter | Type | Required | Default | Description |
| ------------------ | --------- | -------- | ------- | ---------------------------------------- |
| `prompt` | `string` | Yes | - | Video description up to 2500 characters |
| `reference_images` | `array` | No | - | Up to 7 reference images for consistency |
| `aspect_ratio` | `string` | No | `16:9` | Video ratio: `16:9`, `9:16`, or `1:1` |
| `duration` | `integer` | No | `5` | Video length: `5` or `10` seconds |
| `webhook_url` | `string` | No | - | URL for completion notification |
## Frequently Asked Questions
Kling O1 is an image-to-video model that generates smooth video sequences through frame interpolation. You provide a first frame, last frame, or both, and the model creates a cinematic transition between them. Optionally, add a text prompt to guide the motion style. Processing is asynchronous: submit a request, receive a task ID, then poll for results or receive a webhook notification.
Pro mode generates higher-fidelity videos with better motion quality, detail retention, and temporal consistency. Standard mode offers faster processing at lower cost, suitable for prototyping or high-volume use cases. Both support the same parameters and output formats.
Kling O1 accepts JPEG and PNG images via URL (publicly accessible) or Base64 encoding. Requirements: minimum resolution 300x300px, maximum file size 10MB, aspect ratio between 1:2.5 and 2.5:1.
The video reference endpoints accept up to 7 reference images that help maintain character and style consistency. Use these when you need the same subject to appear consistently across multiple video generations or shots.
Processing time varies based on duration and mode. Typical generation: 30-120 seconds for 5-second videos, longer for 10-second outputs. Pro mode takes longer than Standard. Use webhooks for production workflows instead of polling.
Rate limits depend on your subscription tier. See the [Rate Limits](/ratelimits) page for current limits by plan.
Pricing varies by mode (Pro vs Standard) and duration. See the [Pricing page](/pricing) for current rates and subscription options.
## Best practices
* **Image quality**: Use high-resolution images (1080p or higher) with clear subjects and balanced lighting for best results
* **Frame similarity**: When using both first and last frames, ensure similar compositions for smoother interpolation
* **Prompt specificity**: Describe the desired motion clearly (camera movement, subject action, mood) rather than just the scene
* **Reference consistency**: For video reference mode, use images with similar lighting and style for better character consistency
* **Production integration**: Implement webhooks instead of polling for scalable applications
* **Error handling**: Implement retry logic with exponential backoff for 503 (service unavailable) responses
## Related APIs
* **[Kling 2.6](/api-reference/image-to-video/kling-v2-6-pro)**: Latest Kling model with motion control capabilities
* **[Kling 2.5 Turbo Pro](/api-reference/image-to-video/kling-v2.5-pro/overview)**: Fast cinematic generation with 5-10 second outputs
* **[Kling 2.1 Pro](/api-reference/image-to-video/kling-v2.1-pro/overview)**: High-fidelity motion with strong temporal consistency
* **[Kling Elements](/api-reference/image-to-video/kling-elements-pro/post-kling-elements-pro)**: Element-based video generation for specific use cases
# Kling 1.6 Pro - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/kling-pro/get-kling-pro
get /v1/ai/image-to-video/kling-pro
Get the list of the kling-pro tasks
# Kling 1.6 - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/kling-pro/get-kling-pro-task
get /v1/ai/image-to-video/kling/{task-id}
Get the status of the kling task
# Kling 1.6 Pro - Create video from image
Source: https://docs.magnific.com/api-reference/image-to-video/kling-pro/post-kling-pro
post /v1/ai/image-to-video/kling-pro
Generate a video from an image using the Kling 1.6 Pro model.
## Important
The service allows up to 3 concurrent requests per user.
# Kling 1.6 Pro - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/kling-std/get-kling-std
get /v1/ai/image-to-video/kling-std
Get the list of the kling-pro tasks
# Kling 1.6 - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/kling-std/get-kling-std-task
get /v1/ai/image-to-video/kling/{task-id}
Get the status of the kling task
# Kling 1.6 Standard - Create video from image
Source: https://docs.magnific.com/api-reference/image-to-video/kling-std/post-kling-std
post /v1/ai/image-to-video/kling-std
Generate a video from an image using the Kling 1.6 Std model.
## Important
The service allows up to 3 concurrent requests per user.
# Kling 2.6 Pro - Create video from text or image
Source: https://docs.magnific.com/api-reference/image-to-video/kling-v2-6-pro
post /v1/ai/image-to-video/kling-v2-6-pro
# Kling 2.6 Pro - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/kling-v2-6-pro-tasks
get /v1/ai/image-to-video/kling-v2-6
# Kling 2.6 Pro - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/kling-v2-6/task-by-id
get /v1/ai/image-to-video/kling-v2-6/{task-id}
# Kling 2.1 Standard - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/kling-v2.1-master/get-kling-v2-1-master
get /v1/ai/image-to-video/kling-v2-1-master
Get the list of the kling-v2-1-std tasks
# Kling 2.1 Master - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/kling-v2.1-master/get-kling-v2-1-master-task
get /v1/ai/image-to-video/kling-v2-1-master/{task-id}
Get the status of the kling-v2-1-master task
# Kling 2.1 Master - Create video from image
Source: https://docs.magnific.com/api-reference/image-to-video/kling-v2.1-master/post-kling-v2-1-master
post /v1/ai/image-to-video/kling-v2-1-master
Generate a video from an image using the Kling 2.1 Master model.
# Kling 2.1 Pro - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/kling-v2.1-pro/get-kling-v2-1-pro
get /v1/ai/image-to-video/kling-v2-1-pro
Get the list of the kling-v2-1-pro tasks
# Kling 2.1 - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/kling-v2.1-pro/get-kling-v2-1-pro-task
get /v1/ai/image-to-video/kling-v2-1/{task-id}
Get the status of the kling-v2-1 task
# Kling Pro v2.1 – Image‑to‑Video API
Source: https://docs.magnific.com/api-reference/image-to-video/kling-v2.1-pro/overview
Advanced image‑to‑video generation from a single image with higher fidelity, richer motion control, and strong temporal consistency for premium results.
Kling Pro v2.1 builds on the stability of the Std variant with enhanced fidelity and more expressive motion. It delivers higher detail retention, smoother transitions, and stronger control over subject and camera movement—ideal for premium marketing assets, cinematic previews, and design showcases. Prefer general‑purpose results? See the Kling Std v2.1 overview.
### Key capabilities
* High‑fidelity motion and detail from a single image
* Strong temporal consistency with minimal flicker
* Improved texture, edges, and lighting continuity
* Better retention of fine details on faces, products, and environments
### Use cases
* Premium product spots: dynamic hero shots with refined motion
* Cinematic promos: richer parallax and lighting transitions
* High-end social posts and ads: crisp detail and smooth movement
* Design/3D previews: bring still renders to life with controlled motion
* Brand storytelling: subtle camera work with consistent identity
### Generate a video with Kling Pro v2.1
Create an image-to-video task using the Kling v2.1 Pro model.
Generate video from an image
List image-to-video tasks
Check task status
## Frequently Asked Questions
Use high‑resolution images with clear subjects and balanced lighting. PNG/JPEG are recommended. Avoid heavy compression and noisy inputs to maximize detail retention.
Duration depends on API parameters. Kling Pro v2.1 is optimized for short clips suitable for premium previews, ads, and social formats.
Yes. Pro supports expressive motion with strong temporal stability. Complex motion may require careful prompting, masks, or parameter tuning.
Std focuses on dependable, general‑purpose results. Pro increases fidelity and motion expressiveness. Master targets top‑tier quality and advanced control for cinematic applications.
## Best practices for image‑to‑video (Pro)
* Use clean, well‑lit images at sufficient resolution to capture micro‑detail.
* Keep the main subject clear of clutter; plan composition for parallax.
* Start with subtle motion; iterate to increase complexity and camera movement.
* Protect brand/face detail—avoid occlusions and extreme crops.
* Validate at target aspect ratios/durations and compress for delivery platforms.
# Kling 2.1 Pro - Create video from image
Source: https://docs.magnific.com/api-reference/image-to-video/kling-v2.1-pro/post-kling-v2-1-pro
post /v1/ai/image-to-video/kling-v2-1-pro
Generate a video from an image using the Kling 2.1 Pro model.
# Kling 2.1 Standard - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/kling-v2.1-std/get-kling-v2-1-std
get /v1/ai/image-to-video/kling-v2-1-std
Get the list of the kling-v2-1-std tasks
# Kling 2.1 - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/kling-v2.1-std/get-kling-v2-1-std-task
get /v1/ai/image-to-video/kling-v2-1/{task-id}
Get the status of the kling-v2-1 task
# Kling Std v2.1 – Image‑to‑Video API
Source: https://docs.magnific.com/api-reference/image-to-video/kling-v2.1-std/overview
Image‑to‑video generation from a single image with smooth motion and temporal consistency. Ideal for product demos, concept visualizations, and social content.
Kling Std v2.1 is a robust image-to-video model that generates short, consistent videos from a single image. It focuses on temporal stability, smooth motion, and faithful visual detail, making it a dependable choice for product demos, concept visualizations, and social media content. Need higher fidelity and more expressive motion? Try Kling Pro v2.1.
### Key capabilities
* Smooth, realistic motion generation from one input image
* Strong temporal consistency with minimal flicker
* Natural color and lighting preservation
* Good detail retention on faces, products, and environments
### Use cases
* Product showcases: animate angles or subtle movements from a hero image
* Marketing and social: create short video loops for ads and posts
* Concept visualization: bring static artwork or renders to life
* UI/UX motion previews: generate simple motion studies from mockups
* Educational content: illustrate processes with gentle camera moves
### Generate a video with Kling Std v2.1
Create an image-to-video task using the Kling v2.1 Standard model.
Generate video from an image
List image-to-video tasks
Check task status
## Frequently Asked Questions
Use high-resolution images with clear subjects, clean backgrounds, and balanced lighting. JPEG/PNG are recommended. Avoid heavy compression and noisy inputs.
Video duration depends on model defaults and parameters from the API. Kling Std v2.1 is geared toward short clips ideal for previews and social formats.
Yes. The model can synthesize gentle camera moves and subject motion while maintaining temporal stability. Complex motion may require careful prompting and tuning.
Std focuses on reliable, general‑purpose quality with good consistency. Pro and Master variants target higher fidelity or more advanced motion control. Choose Std for dependable everyday use cases.
## Best practices for image‑to‑video
* Start with clean, well‑lit images at sufficient resolution.
* Keep subjects centered and avoid busy backgrounds for clearer motion focus.
* Use moderate motion expectations; evaluate results before increasing complexity.
* Ensure branding, faces, and key details are unobstructed for better consistency.
* Validate outputs at target aspect ratios and durations for your platform.
# Kling 2.1 Standard - Create video from image
Source: https://docs.magnific.com/api-reference/image-to-video/kling-v2.1-std/post-kling-v2-1-std
post /v1/ai/image-to-video/kling-v2-1-std
Generate a video from an image using the Kling 2.1 Std model.
# Kling 2.5 720p - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/kling-v2.5-pro/get-kling-v2-5-720p
get /v1/ai/image-to-video/kling-v2-5-720p
Get the list of the kling-v2-5-720p tasks
# Kling 2.5 Pro - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/kling-v2.5-pro/get-kling-v2-5-pro
get /v1/ai/image-to-video/kling-v2-5-pro
Get the list of the kling-v2-5-pro tasks
# Kling 2.5 Pro - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/kling-v2.5-pro/get-{task-id}-by-id
get /v1/ai/image-to-video/kling-v2-5-pro/{task-id}
Get the status of the kling-v2-5-pro task
# Kling 2.5 720p - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/kling-v2.5-pro/get-{task-id}-by-id-720p
get /v1/ai/image-to-video/kling-v2-5-720p/{task-id}
Get the status of the kling-v2-5-720p task
# Kling 2.5 Turbo Pro – Image‑to‑Video API
Source: https://docs.magnific.com/api-reference/image-to-video/kling-v2.5-pro/overview
Cinematic image‑to‑video from a single image with smoother motion, sharper detail, stable style/color, and faster rendering. 5s and 10s outputs.
Kling 2.5 Turbo Pro generates cinematic videos from a single image with dramatically improved motion quality, sharper detail, and stable style and color. It offers 5s and 10s outputs, faster rendering than previous versions, and more reliable prompt adherence—ideal for marketing assets, trailers, and high‑end social content.
### Choosing a resolution
The model is served at two resolutions, one endpoint each. Both take the same
request body and differ only in output resolution and price per second.
| Resolution | Endpoint | When to use |
| ---------- | --------------------------------------- | ----------------------------------------------------------------------- |
| 1080p | `/v1/ai/image-to-video/kling-v2-5-pro` | Final deliverables, cinematic promos, anything that will be shown large |
| 720p | `/v1/ai/image-to-video/kling-v2-5-720p` | Drafts, iteration on prompts, social formats where 720p is enough |
### Key capabilities
* Smooth, expressive motion and professional camera work
* Sharper, cinematic imagery with improved clarity and texture
* Stable style and color; better subject consistency across frames
* Strong instruction adherence for look, tone, and motion
* Better static preservation and camera perspective response
* Improved subject understanding and finer emotional expression
* Cost‑efficient credit usage compared to earlier versions
* 5s and 10s duration options
### Use cases
* Short films, teasers, and cinematic promos
* YouTube/TikTok/Instagram videos (short‑ and long‑form)
* Product and brand videos with consistent visuals
* Educational explainers and motion studies
* Experimental art and abstract motion
Generate video from an image
Check task status
List image-to-video tasks
Generate video from an image at 720p
Check 720p task status
List 720p tasks
## Frequently Asked Questions
Both resolutions support 5s and 10s outputs.
Only the output resolution and the price per second. Same model, same request body, same durations — pick `kling-v2-5-720p` while you iterate and `kling-v2-5-pro` for the final render.
Use a high‑resolution image with clear subjects and balanced lighting. Avoid heavy compression or clutter that can reduce perceived motion quality.
Audio support is planned in an upcoming upgrade of the model.
Yes. The model targets professional‑grade cinematic quality with stable style/color and reliable prompt adherence.
# Kling 2.5 720p - Create video from image
Source: https://docs.magnific.com/api-reference/image-to-video/kling-v2.5-pro/post-kling-v2-5-720p
post /v1/ai/image-to-video/kling-v2-5-720p
Generate a video from an image using the Kling 2.5 model at 720p resolution. For 1080p, use `/v1/ai/image-to-video/kling-v2-5-pro`.
# Kling 2.5 Pro - Create video from image
Source: https://docs.magnific.com/api-reference/image-to-video/kling-v2.5-pro/post-kling-v2-5-pro
post /v1/ai/image-to-video/kling-v2-5-pro
Generate a video from an image using the Kling 2.5 Pro model.
# Kling 2.0 - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/kling-v2/get-kling-v2
get /v1/ai/image-to-video/kling-v2
Get the list of the kling-v2 tasks
# Kling 2.0 - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/kling-v2/get-kling-v2-task
get /v1/ai/image-to-video/kling-v2/{task-id}
Get the status of the kling-v2 task
# Kling 2.0 - Create video from image
Source: https://docs.magnific.com/api-reference/image-to-video/kling-v2/post-kling-v2
post /v1/ai/image-to-video/kling-v2
Create a video from an image using the Kling v2 model
## Important
The service allows up to 3 concurrent requests per user.
# Kling 3.0 Turbo I2V 1080p - Generate video
Source: https://docs.magnific.com/api-reference/image-to-video/kling-v3-turbo/generate-1080p
post /v1/ai/image-to-video/kling-v3-turbo-1080p
Generate AI video from a first-frame image using Kling 3.0 Turbo at 1080p resolution, a fast image-to-video model from the Kling 3.0 family.
**Features:**
- **Image-to-video**: Animate a static image into a dynamic video
- **Optional prompt**: Guide the motion and animation style with text
- **Resolution**: Fixed 1080p output
- **Duration**: 3-15 seconds
**How it works:**
1. Submit an image (URL or Base64) to use as the first frame, with an optional prompt
2. Receive a task ID to track progress
3. Poll the status endpoint or use a `webhook_url` to get notified when the task completes
4. Download the generated video from the result URL (valid for 24 hours)
# Kling 3.0 Turbo I2V 720p - Generate video
Source: https://docs.magnific.com/api-reference/image-to-video/kling-v3-turbo/generate-720p
post /v1/ai/image-to-video/kling-v3-turbo-720p
Generate AI video from a first-frame image using Kling 3.0 Turbo at 720p resolution, a fast image-to-video model from the Kling 3.0 family.
**Features:**
- **Image-to-video**: Animate a static image into a dynamic video
- **Optional prompt**: Guide the motion and animation style with text
- **Resolution**: Fixed 720p output
- **Duration**: 3-15 seconds
**How it works:**
1. Submit an image (URL or Base64) to use as the first frame, with an optional prompt
2. Receive a task ID to track progress
3. Poll the status endpoint or use a `webhook_url` to get notified when the task completes
4. Download the generated video from the result URL (valid for 24 hours)
# Kling 3.0 Turbo Image To Video API
Source: https://docs.magnific.com/api-reference/image-to-video/kling-v3-turbo/overview
Animate a single image into video fast with Kling 3.0 Turbo. Dedicated 720p and 1080p generate endpoints, 3-15 second durations, and optional prompt-guided motion control.
Kling 3.0 Turbo is the fast generation model from the Kling 3.0 family, animating a first-frame image into smooth, high-fidelity video with short processing times.
Kling 3.0 Turbo image-to-video generates a video from a single first-frame image, optionally guided by a text prompt. It outputs high-fidelity video with durations from 3 to 15 seconds, and is optimized for fast generation, making it well suited for animating product shots, artwork, and social media content at scale.
Resolution is selected at generation time: use the dedicated **720p** generate endpoint for standard high definition or the **1080p** generate endpoint for full high definition. Task status and listing use a single generic endpoint, regardless of the resolution. For the full model overview, including the text-to-video mode, see the [Kling 3.0 Turbo overview](/api-reference/text-to-video/kling-v3-turbo/overview).
### Key capabilities
* **Image animation**: Turn a single first-frame image into motion
* **Resolution by generate endpoint**: Dedicated `720p` and `1080p` generate endpoints
* **Unified task tracking**: One generic list endpoint and one generic status endpoint for tasks of any resolution
* **Fast generation**: Turbo-optimized pipeline for shorter processing times
* **Flexible durations**: Any whole number from 3 to 15 seconds, default `5`
* **Optional prompt**: Guide motion and style with up to 2500 characters, or omit it to infer motion from the image
* **Async processing**: Webhook notifications or polling for task completion
* **24-hour delivery**: Generated MP4 video is returned via a URL valid for 24 hours
### Use cases
* **Product videos**: Animate static product photography for ads and listings
* **Social media content**: Bring images to life for Reels, Shorts, and Stories
* **Creative exploration**: Add motion to illustrations, concept art, and designs
* **Rapid prototyping**: Quickly preview how a still composition moves
## API Operations
Generate a 720p video from a first-frame image
Generate a 1080p video from a first-frame image
List all Kling 3.0 Turbo I2V tasks (any resolution)
Get I2V task status and result by ID
### Endpoint structure
| Operation | Endpoint |
| ------------------ | ---------------------------------------------------- |
| **Generate 720p** | `POST /v1/ai/image-to-video/kling-v3-turbo-720p` |
| **Generate 1080p** | `POST /v1/ai/image-to-video/kling-v3-turbo-1080p` |
| **List tasks** | `GET /v1/ai/image-to-video/kling-v3-turbo` |
| **Get task** | `GET /v1/ai/image-to-video/kling-v3-turbo/{task-id}` |
### Parameters
Resolution is determined by the generate endpoint you call (`-720p` or `-1080p`) and is not a body parameter.
| Parameter | Type | Required | Default | Description |
| ------------- | -------- | -------- | ------- | --------------------------------------------------------------------------------------------------------------------------- |
| `image` | `string` | Yes | - | First-frame image as a public URL or Base64 string. JPG, JPEG, or PNG; min 300x300px; max 50MB; aspect ratio 1:2.5 to 2.5:1 |
| `prompt` | `string` | No | - | Motion and style guidance. Up to 2500 characters. If omitted, motion is inferred from the image |
| `duration` | `string` | No | `5` | Video length in seconds, any whole number from `3` to `15` |
| `webhook_url` | `string` | No | - | URL for async status notifications |
## Frequently Asked Questions
Resolution is selected by the generate endpoint, not by a body parameter. Call `POST /v1/ai/image-to-video/kling-v3-turbo-720p` for standard high definition or `POST /v1/ai/image-to-video/kling-v3-turbo-1080p` for full high definition. Listing and status use the single generic endpoint `GET /v1/ai/image-to-video/kling-v3-turbo` (and `/{task-id}`).
Image-to-video accepts JPG, JPEG, and PNG, provided as a publicly accessible URL or a Base64-encoded string (without the data URI prefix). Requirements: minimum 300x300 pixels, maximum 50MB, and an aspect ratio between 1:2.5 and 2.5:1. Only the first frame is supported.
No. The prompt is optional in image-to-video. If you omit it, motion is inferred from the source image. Provide a prompt (up to 2500 characters) to guide the movement, camera behavior, and visual style.
No. Image-to-video does not accept an aspect ratio parameter; the output ratio is inherited from the source image. Use text-to-video if you need to choose `16:9`, `9:16`, or `1:1`.
Any whole-number duration from 3 to 15 seconds (default `5`). Shorter durations generate faster.
Submit the request to receive a task ID, then poll the generic GET task endpoint or provide a `webhook_url` to be notified on completion. The result MP4 is delivered via a URL that remains valid for 24 hours.
Rate limits depend on your subscription tier (see [Rate Limits](/ratelimits)). Pricing varies by resolution and duration (see [Pricing](/pricing)).
## Related APIs
* **[Kling 3.0 Turbo (Text to Video)](/api-reference/text-to-video/kling-v3-turbo/overview)**: Generate video from a text prompt with aspect ratio control
* **[Kling 3](/api-reference/video/kling-v3/overview)**: Standard Kling 3.0 model for higher-fidelity output
* **[Runway Gen-4 Turbo](/api-reference/image-to-video/runway-gen4-turbo)**: Fast i2v alternative with cinematic quality
# Kling 3.0 Turbo I2V - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/kling-v3-turbo/task-by-id
get /v1/ai/image-to-video/kling-v3-turbo/{task-id}
Retrieve the status and result of a specific Kling 3.0 Turbo I2V task by its task ID, regardless of the resolution it was created at.
# Kling 3.0 Turbo I2V - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/kling-v3-turbo/tasks
get /v1/ai/image-to-video/kling-v3-turbo
Retrieve the list of all Kling 3.0 Turbo I2V tasks for the authenticated user, across all resolutions.
# LTX Video 2.0 Fast - Create video from image
Source: https://docs.magnific.com/api-reference/image-to-video/ltx-2-fast
post /v1/ai/image-to-video/ltx-2-fast
Generate a video from an image using the LTX Video 2.0 Fast model.
**Features:**
- Fast video generation with resolutions up to 4K (2160p)
- Extended duration options: 6-20 seconds in 2-second increments
- Uses the provided image as the first frame
- Optional synchronized audio generation
- **Note:** Durations longer than 10 seconds require 25 FPS and 1080p resolution
# LTX Video 2.0 Fast I2V - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/ltx-2-fast-tasks
get /v1/ai/image-to-video/ltx-2-fast
# LTX Video 2.0 Fast I2V - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/ltx-2-fast/task-by-id
get /v1/ai/image-to-video/ltx-2-fast/{task-id}
# LTX Video 2.0 Pro - Create video from image
Source: https://docs.magnific.com/api-reference/image-to-video/ltx-2-pro
post /v1/ai/image-to-video/ltx-2-pro
Generate a video from an image using the LTX Video 2.0 Pro model.
**Features:**
- High-quality video generation with resolutions up to 4K (2160p)
- Duration options: 6, 8, or 10 seconds
- Uses the provided image as the first frame
- Optional synchronized audio generation
- Reproducible results with seed parameter
# LTX Video 2.0 Pro I2V - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/ltx-2-pro-tasks
get /v1/ai/image-to-video/ltx-2-pro
# LTX Video 2.0 Pro I2V - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/ltx-2-pro/task-by-id
get /v1/ai/image-to-video/ltx-2-pro/{task-id}
# MiniMax Hailuo 02 1080p - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/minimax-hailuo-02-1080p/get-minimax-hailuo-02-1080p
get /v1/ai/image-to-video/minimax-hailuo-02-1080p
Get the list of MiniMax Hailuo-02 1080p tasks
# MiniMax Hailuo 02 1080p - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/minimax-hailuo-02-1080p/get-minimax-hailuo-02-1080p-task
get /v1/ai/image-to-video/minimax-hailuo-02-1080p/{task-id}
Get the status of the MiniMax Hailuo-02 1080p task
# MiniMax Hailuo 02 1080p - Create video from text or image
Source: https://docs.magnific.com/api-reference/image-to-video/minimax-hailuo-02-1080p/post-minimax-hailuo-02-1080p
post /v1/ai/image-to-video/minimax-hailuo-02-1080p
Generate a video from text or image using the MiniMax Hailuo-02 1080p model.
# MiniMax Hailuo 02 768p - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/minimax-hailuo-02-768p/get-minimax-hailuo-02-768p
get /v1/ai/image-to-video/minimax-hailuo-02-768p
Get the list of MiniMax Hailuo-02 768p tasks
# MiniMax Hailuo 02 768p - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/minimax-hailuo-02-768p/get-minimax-hailuo-02-768p-task
get /v1/ai/image-to-video/minimax-hailuo-02-768p/{task-id}
Get the status of the MiniMax Hailuo-02 768p task
# MiniMax Hailuo 02 768p - Create video from text or image
Source: https://docs.magnific.com/api-reference/image-to-video/minimax-hailuo-02-768p/post-minimax-hailuo-02-768p
post /v1/ai/image-to-video/minimax-hailuo-02-768p
Generate a video from text or image using the MiniMax Hailuo-02 768p model.
# MiniMax Hailuo 2.3 1080p Fast - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/minimax-hailuo-2-3-1080p-fast/get-minimax-hailuo-2-3-1080p-fast
get /v1/ai/image-to-video/minimax-hailuo-2-3-1080p-fast
Get the list of MiniMax Hailuo 2.3 1080p Fast tasks
# MiniMax Hailuo 2.3 1080p Fast - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/minimax-hailuo-2-3-1080p-fast/get-minimax-hailuo-2-3-1080p-fast-task
get /v1/ai/image-to-video/minimax-hailuo-2-3-1080p-fast/{task-id}
Get the status of the MiniMax Hailuo 2.3 1080p Fast task
# MiniMax Hailuo 2.3 1080p Fast - Create video from text or image
Source: https://docs.magnific.com/api-reference/image-to-video/minimax-hailuo-2-3-1080p-fast/post-minimax-hailuo-2-3-1080p-fast
post /v1/ai/image-to-video/minimax-hailuo-2-3-1080p-fast
Generate a video from text or image using the MiniMax Hailuo 2.3 1080p model with fast prompt optimization.
# MiniMax Hailuo 2.3 1080p - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/minimax-hailuo-2-3-1080p/get-minimax-hailuo-2-3-1080p
get /v1/ai/image-to-video/minimax-hailuo-2-3-1080p
Get the list of MiniMax Hailuo 2.3 1080p tasks
# MiniMax Hailuo 2.3 1080p - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/minimax-hailuo-2-3-1080p/get-minimax-hailuo-2-3-1080p-task
get /v1/ai/image-to-video/minimax-hailuo-2-3-1080p/{task-id}
Get the status of the MiniMax Hailuo 2.3 1080p task
# MiniMax Hailuo 2.3 1080p - Create video from text or image
Source: https://docs.magnific.com/api-reference/image-to-video/minimax-hailuo-2-3-1080p/post-minimax-hailuo-2-3-1080p
post /v1/ai/image-to-video/minimax-hailuo-2-3-1080p
Generate a video from text or image using the MiniMax Hailuo 2.3 1080p model.
# MiniMax Hailuo 2.3 768p Fast - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/minimax-hailuo-2-3-768p-fast/get-minimax-hailuo-2-3-768p-fast
get /v1/ai/image-to-video/minimax-hailuo-2-3-768p-fast
Get the list of MiniMax Hailuo 2.3 768p Fast tasks
# MiniMax Hailuo 2.3 768p Fast - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/minimax-hailuo-2-3-768p-fast/get-minimax-hailuo-2-3-768p-fast-task
get /v1/ai/image-to-video/minimax-hailuo-2-3-768p-fast/{task-id}
Get the status of the MiniMax Hailuo 2.3 768p Fast task
# MiniMax Hailuo 2.3 768p Fast - Create video from text or image
Source: https://docs.magnific.com/api-reference/image-to-video/minimax-hailuo-2-3-768p-fast/post-minimax-hailuo-2-3-768p-fast
post /v1/ai/image-to-video/minimax-hailuo-2-3-768p-fast
Generate a video from text or image using the MiniMax Hailuo 2.3 768p model with fast prompt optimization.
# MiniMax Hailuo 2.3 768p - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/minimax-hailuo-2-3-768p/get-minimax-hailuo-2-3-768p
get /v1/ai/image-to-video/minimax-hailuo-2-3-768p
Get the list of MiniMax Hailuo 2.3 768p tasks
# MiniMax Hailuo 2.3 768p - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/minimax-hailuo-2-3-768p/get-minimax-hailuo-2-3-768p-task
get /v1/ai/image-to-video/minimax-hailuo-2-3-768p/{task-id}
Get the status of the MiniMax Hailuo 2.3 768p task
# MiniMax Hailuo 2.3 768p - Create video from text or image
Source: https://docs.magnific.com/api-reference/image-to-video/minimax-hailuo-2-3-768p/post-minimax-hailuo-2-3-768p
post /v1/ai/image-to-video/minimax-hailuo-2-3-768p
Generate a video from text or image using the MiniMax Hailuo 2.3 768p model.
# MiniMax Video 01 Live - Create video from image
Source: https://docs.magnific.com/api-reference/image-to-video/minimax-live
post /v1/ai/image-to-video/minimax-live
Generate a video from an image using MiniMax Video-01-Live model (Live Illustrations).
**Features:**
- Supports camera movements in square brackets: [Truck left], [Pan right], [Push in], [Pull out], [Zoom in], [Tracking shot], [Static shot]
- Optional prompt optimization for better results
- Works best with illustrations and artwork
# MiniMax Video 01 Live - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/minimax-live-tasks
get /v1/ai/image-to-video/minimax-live
# MiniMax Video 01 Live - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/minimax-live/task-by-id
get /v1/ai/image-to-video/minimax-live/{task-id}
# Video Generation API
Source: https://docs.magnific.com/api-reference/image-to-video/overview
Generate AI videos from text prompts or images. Multiple models available including Kling, WAN, MiniMax, Runway, PixVerse, and LTX with various quality tiers and resolutions.
Generate videos from text prompts or images using state-of-the-art AI models. Choose the model that best fits your quality, speed, and budget requirements.
The Video Generation API provides access to multiple AI video models through a unified async workflow: submit a request, receive a task ID, then poll for results or get notified via webhook.
### Available models
| Model | Modes | Resolutions | Durations | Highlights |
| ------------------------------------------------------------------ | -------- | ----------- | --------- | -------------------------------- |
| **[Kling 3](/api-reference/video/kling-v3/overview)** | T2V, I2V | up to 1080p | 3-15s | Multi-shot, element consistency |
| **[Kling 3 Omni](/api-reference/video/kling-v3-omni/overview)** | T2V, I2V | up to 1080p | 3-15s | Video reference for motion/style |
| **[Kling O1](/api-reference/image-to-video/kling-o1/overview)** | T2V, I2V | up to 1080p | 5-10s | High-performance generation |
| **[WAN 2.6](/api-reference/wan-v2-6-i2v/overview)** | T2V, I2V | 720p, 1080p | 5-15s | High resolution, long duration |
| **[WAN 2.5](/api-reference/wan-2-5-t2v/overview)** | T2V, I2V | 480p-1080p | 5-15s | Multiple resolution tiers |
| **[Runway Gen 4.5](/api-reference/video/runway-gen-4-5/overview)** | T2V, I2V | up to 1080p | 5-10s | Cinematic quality |
| **[MiniMax Live](/api-reference/image-to-video/minimax-live)** | I2V | 720p, 1080p | 5s | Fast generation |
| **[LTX 2.0](/api-reference/image-to-video/ltx-2-fast)** | T2V, I2V | 768p | 3-9s | Fast and Pro tiers |
### How it works
All video models follow the same async pattern:
1. **POST** a generation request with your prompt and/or image
2. Receive a `task_id` immediately
3. **Poll** with `GET /v1/ai/{model}/{task_id}` or receive a **webhook** notification
4. Download the resulting video from the `video_url` in the response
### Common parameters
| Parameter | Description |
| -------------------------- | ------------------------------------------ |
| `prompt` | Text description of the video to generate |
| `image_url` / `image_list` | Source image(s) for image-to-video modes |
| `aspect_ratio` | Video aspect ratio (`16:9`, `9:16`, `1:1`) |
| `duration` | Video length in seconds |
| `webhook_url` | URL for async completion notification |
Parameter names and accepted values vary by model. Check each model's endpoint reference for exact specifications.
### Choosing a model
* **Highest quality**: Kling 3 Pro, Runway Gen 4.5
* **Best value**: Kling 3 Standard, LTX 2.0 Fast
* **Longest videos**: WAN 2.6 (up to 15s at 1080p)
* **Fastest generation**: LTX 2.0 Fast, MiniMax Live
* **Multi-scene narratives**: Kling 3 (multi-shot mode)
* **Motion/style reference**: Kling 3 Omni (video reference input)
# PixVerse V5 Transition - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/pixverse-transition/get-pixverse-v5-transition
get /v1/ai/image-to-video/pixverse-v5-transition
List PixVerse-V5 Transition tasks.
# PixVerse V5 Transition - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/pixverse-transition/get-{task-id}-by-id
get /v1/ai/image-to-video/pixverse-v5-transition/{task-id}
# PixVerse V5 - Video transition
Source: https://docs.magnific.com/api-reference/image-to-video/pixverse-transition/post-pixverse-v5-transition
post /v1/ai/image-to-video/pixverse-v5-transition
Generate a video transition between two images using the PixVerse-V5 model.
# PixVerse V5.5 - Video transition
Source: https://docs.magnific.com/api-reference/image-to-video/pixverse-v5-5-transition/create
post /v1/ai/image-to-video/pixverse-v5-5-transition
Generate a video transition using the PixVerse-V5.5 model. Provide a `first_image_url` and an `end_image_url` to animate a seamless transition between the two frames.
PixVerse-V5.5 transition supports native audio (`generate_audio_switch`), camera movement control and prompt reasoning enhancement (`thinking_type`).
# PixVerse V5.5 Transition API
Source: https://docs.magnific.com/api-reference/image-to-video/pixverse-v5-5-transition/overview
Generate first-to-last frame video transitions with PixVerse V5.5. Interpolate between two images with camera movement, native audio, and 5-10s durations.
## Overview
PixVerse V5.5 Transition is an image-to-video API that interpolates a video between two keyframes. Provide a `first_image_url` and an `end_image_url`, and PixVerse V5.5 generates a smooth transition between the two frames guided by your `prompt`. Both images are required. It supports camera movement presets, native synchronized audio, prompt reasoning, and 5, 8, or 10 second durations.
### Key capabilities
* **First-to-last frame transition**: interpolate between the required `first_image_url` and `end_image_url` in a single request
* **Camera movement presets**: 20 options including `zoom_in`, `zoom_out`, `pan_left`, `pan_right`, `crane_up`, `hitchcock`, `whip_pan`, `camera_rotation`
* **Native synchronized audio**: enable `generate_audio_switch` to produce music, sound effects, or dialogue together with the video
* **Prompt reasoning (`thinking_type`)**: choose `enabled` (default), `disabled`, or `auto` to control prompt rewriting
* **Duration (5, 8, or 10 seconds)**: `5` (default), `8`, or `10`; 8s costs double, 10s is available up to 720p, and 1080p is limited to 5 or 8 seconds
* **Resolutions**: `360p`, `540p`, `720p`, `1080p`
* **Aspect ratios**: `widescreen_16_9` (default), `classic_4_3`, `square_1_1`, `traditional_3_4`, `social_story_9_16`
* **Async processing**: poll the task endpoint or receive a webhook notification on completion
### Use cases
* **Story transitions**: scene-to-scene cuts and morphs that bridge two shots
* **Product reveals**: transition between a closed and open, or before and after, product state
* **Marketing and ads**: dynamic transitions with camera movement and synchronized audio
* **Social content**: vertical `social_story_9_16` transitions for TikTok, Instagram Reels, and YouTube Shorts
* **Creative experimentation**: stylized morphs (`anime`, `cyberpunk`, `clay`) between keyframes
Generate a first/last frame transition with PixVerse V5.5
Get task status and result by ID
List all PixVerse V5.5 Transition tasks
### Parameters
| Parameter | Type | Required | Default | Description |
| ----------------------- | -------------- | -------- | ----------------- | ----------------------------------------------------------------------------------------------------- |
| `prompt` | `string` | Yes | - | Prompt describing the video transition to generate |
| `first_image_url` | `string` (uri) | Yes | - | URL of the image to use as the first frame |
| `end_image_url` | `string` (uri) | Yes | - | URL of the image to use as the last frame |
| `resolution` | `string` | No | - | Output resolution: `360p`, `540p`, `720p`, `1080p` |
| `aspect_ratio` | `string` | No | `widescreen_16_9` | `widescreen_16_9`, `classic_4_3`, `square_1_1`, `traditional_3_4`, `social_story_9_16` |
| `duration` | `integer` | No | `5` | Video length in seconds: `5`, `8`, or `10`. 8s costs double; 10s up to 720p; 1080p limited to 5 or 8s |
| `negative_prompt` | `string` | No | `""` | Negative prompt for the generation |
| `style` | `string` | No | - | Visual style: `anime`, `3d_animation`, `clay`, `cyberpunk`, `comic` |
| `seed` | `integer` | No | - | Reproducibility seed; same seed + same prompt yields the same video |
| `camera_movement` | `string` | No | - | Camera preset (e.g., `zoom_in`, `pan_left`, `crane_up`, `hitchcock`, `whip_pan`, `camera_rotation`) |
| `generate_audio_switch` | `boolean` | No | `false` | When `true`, generates synchronized audio (music, SFX, or dialogue) with the video |
| `thinking_type` | `string` | No | `enabled` | Prompt reasoning mode: `enabled`, `disabled`, or `auto` |
| `webhook_url` | `string` (uri) | No | - | Optional callback URL that receives task status notifications |
## Frequently Asked Questions
Provide a `first_image_url` and an `end_image_url`. PixVerse V5.5 interpolates a video between the two frames using your `prompt` as guidance, producing the transition in a single request.
Yes. PixVerse V5.5 Transition requires both `first_image_url` (first frame) and `end_image_url` (last frame). Requests without an end frame are rejected.
PixVerse V5.5 Transition supports `5` (default), `8`, or `10` second durations and resolutions of `360p`, `540p`, `720p`, and `1080p`. 8-second videos cost double, 10-second videos are available up to 720p, and 1080p is limited to 5 or 8 seconds.
20 presets are supported, including `zoom_in`, `zoom_out`, `pan_left`, `pan_right`, `crane_up`, `hitchcock`, `whip_pan`, and `camera_rotation`. Leave `camera_movement` unset for a static camera.
Set `generate_audio_switch` to `true` and PixVerse V5.5 produces synchronized audio (background music, sound effects, or dialogue) together with the video in a single request.
Rate limits and pricing depend on your subscription tier. See [Rate Limits](/ratelimits) and the [Pricing page](/pricing) for current values.
## Best practices
* **Frame consistency**: choose two frames that share scene context (subject, framing, lighting) for the smoothest interpolation
* **Input quality**: provide sharp, well-lit images with a clear subject for the strongest motion and style stability
* **Camera movement**: combine a `camera_movement` preset with the transition for more dynamic results, or leave it unset for a clean morph
* **Duration selection**: use `5` seconds for most transitions to reduce cost; request 10s only at 720p or lower
* **Production integration**: use `webhook_url` instead of polling for scalable workflows
* **Error handling**: implement retry with exponential backoff for 503 responses
## Related APIs
* **PixVerse V6 Transition**: newer transition endpoint with flexible 1-15 second durations and multi-clip output. See the [PixVerse V6 Transition overview](/api-reference/image-to-video/pixverse-v6-transition/overview).
* **PixVerse V5.5 (image-to-video)**: animate a single image without a transition. See the [PixVerse V5.5 overview](/api-reference/image-to-video/pixverse-v5-5/overview).
* **PixVerse V5.5 Text to Video**: generate a video from a text prompt with no input image. See the [PixVerse V5.5 Text to Video overview](/api-reference/text-to-video/pixverse-v5-5/overview).
# PixVerse V5.5 Transition - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/pixverse-v5-5-transition/pixverse-v5-5-transition-tasks
get /v1/ai/image-to-video/pixverse-v5-5-transition
List PixVerse-V5.5 Transition tasks.
# PixVerse V5.5 Transition - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/pixverse-v5-5-transition/task-by-id
get /v1/ai/image-to-video/pixverse-v5-5-transition/{task-id}
# PixVerse V6 - Video transition
Source: https://docs.magnific.com/api-reference/image-to-video/pixverse-v6-transition/create
post /v1/ai/image-to-video/pixverse-v6-transition
Generate a video transition using the PixVerse-V6 model. Provide a `first_image_url` and an `end_image_url` to animate a seamless transition between the two frames.
PixVerse-V6 transition supports flexible duration (`1`-`15` seconds), native audio (`generate_audio_switch`), multi-clip output (`generate_multi_clip_switch`), camera movement control and prompt reasoning enhancement (`thinking_type`).
# PixVerse V6 Transition API
Source: https://docs.magnific.com/api-reference/image-to-video/pixverse-v6-transition/overview
Generate first-to-last frame video transitions with PixVerse V6. Interpolate between two images with flexible 1-15s durations, camera movement, and native audio.
## Overview
PixVerse V6 Transition is an image-to-video API that interpolates a video between two keyframes. Provide a `first_image_url` and an `end_image_url`, and PixVerse V6 generates a smooth transition between the two frames guided by your `prompt`. Both images are required. Compared to PixVerse V5.5 Transition, version 6 unlocks flexible 1-15 second durations and adds multi-clip output, while keeping camera movement presets, native audio, and prompt reasoning.
### Key capabilities
* **First-to-last frame transition**: interpolate between the required `first_image_url` and `end_image_url` in a single request
* **Flexible duration (1-15 seconds)**: any integer length from `1` to `15`, with default `5` (previously fixed to `5`, `8`, or `10`)
* **Camera movement presets**: 20 options including `zoom_in`, `zoom_out`, `pan_left`, `pan_right`, `crane_up`, `hitchcock`, `whip_pan`, `camera_rotation`
* **Multi-clip with dynamic cameras**: enable `generate_multi_clip_switch` for multi-clip output with camera changes in a single generation
* **Native synchronized audio**: enable `generate_audio_switch` to produce music, sound effects, or dialogue together with the video
* **Prompt reasoning (`thinking_type`)**: choose `enabled` (default), `disabled`, or `auto` to control prompt rewriting
* **Resolutions**: `360p`, `540p`, `720p`, `1080p`
* **Aspect ratios**: `widescreen_16_9` (default), `classic_4_3`, `square_1_1`, `traditional_3_4`, `social_story_9_16`
* **Async processing**: poll the task endpoint or receive a webhook notification on completion
### Use cases
* **Story transitions**: scene-to-scene cuts and morphs that bridge two shots in any duration
* **Product reveals**: transition between a closed and open, or before and after, product state
* **Marketing and ads**: dynamic transitions with camera movement, multi-clip output, and synchronized audio
* **Social content**: vertical `social_story_9_16` transitions for TikTok, Instagram Reels, and YouTube Shorts
* **Short films and teasers**: longer 10-15 second transition sequences with camera changes
Generate a first/last frame transition with PixVerse V6
Get task status and result by ID
List all PixVerse V6 Transition tasks
### Parameters
| Parameter | Type | Required | Default | Description |
| ---------------------------- | -------------- | -------- | ----------------- | --------------------------------------------------------------------------------------------------- |
| `prompt` | `string` | Yes | - | Prompt describing the video transition to generate |
| `first_image_url` | `string` (uri) | Yes | - | URL of the image to use as the first frame |
| `end_image_url` | `string` (uri) | Yes | - | URL of the image to use as the last frame |
| `resolution` | `string` | No | - | Output resolution: `360p`, `540p`, `720p`, `1080p` |
| `aspect_ratio` | `string` | No | `widescreen_16_9` | `widescreen_16_9`, `classic_4_3`, `square_1_1`, `traditional_3_4`, `social_story_9_16` |
| `duration` | `integer` | No | `5` | Video length in seconds. Any integer from `1` to `15` |
| `negative_prompt` | `string` | No | `""` | Negative prompt for the generation |
| `style` | `string` | No | - | Visual style: `anime`, `3d_animation`, `clay`, `cyberpunk`, `comic` |
| `seed` | `integer` | No | - | Reproducibility seed; same seed + same prompt yields the same video |
| `camera_movement` | `string` | No | - | Camera preset (e.g., `zoom_in`, `pan_left`, `crane_up`, `hitchcock`, `whip_pan`, `camera_rotation`) |
| `generate_audio_switch` | `boolean` | No | `false` | When `true`, generates synchronized audio (music, SFX, or dialogue) with the video |
| `generate_multi_clip_switch` | `boolean` | No | `false` | When `true`, produces multi-clip output with dynamic camera changes in a single generation |
| `thinking_type` | `string` | No | `enabled` | Prompt reasoning mode: `enabled`, `disabled`, or `auto` |
| `webhook_url` | `string` (uri) | No | - | Optional callback URL that receives task status notifications |
## Frequently Asked Questions
PixVerse V6 Transition adds flexible duration (any integer from `1` to `15` seconds instead of fixed `5`, `8`, or `10`) and multi-clip output (`generate_multi_clip_switch`). Camera movement, native audio, and prompt reasoning work the same as in V5.5 Transition.
Provide a `first_image_url` and an `end_image_url`. PixVerse V6 interpolates a video between the two frames using your `prompt` as guidance, producing the transition in a single request. Both images are required.
PixVerse V6 Transition accepts any integer duration from `1` to `15` seconds, with a default of `5`. You are no longer limited to fixed steps, so you can match the exact length of your transition.
20 presets are supported, including `zoom_in`, `zoom_out`, `pan_left`, `pan_right`, `crane_up`, `hitchcock`, `whip_pan`, and `camera_rotation`. Leave `camera_movement` unset for a static camera.
When set to `true`, PixVerse V6 produces multi-clip output with dynamic camera changes inside a single generation, simulating cuts and camera moves without stitching multiple requests.
Rate limits and pricing depend on your subscription tier. See [Rate Limits](/ratelimits) and the [Pricing page](/pricing) for current values.
## Best practices
* **Frame consistency**: choose two frames that share scene context (subject, framing, lighting) for the smoothest interpolation
* **Input quality**: provide sharp, well-lit images with a clear subject for the strongest motion and style stability
* **Duration selection**: use the shortest duration that conveys the transition to reduce cost; reserve 10-15s for narrative sequences
* **Camera and multi-clip**: combine `camera_movement` and `generate_multi_clip_switch` for dynamic, multi-shot transitions
* **Production integration**: use `webhook_url` instead of polling for scalable workflows
* **Error handling**: implement retry with exponential backoff for 503 responses
## Related APIs
* **PixVerse V5.5 Transition**: prior transition endpoint with fixed `5`/`8`/`10` second durations and no multi-clip output. See the [PixVerse V5.5 Transition overview](/api-reference/image-to-video/pixverse-v5-5-transition/overview).
* **PixVerse V6 (image-to-video)**: animate a single image or run a transition natively via `last_frame_image`. See the [PixVerse V6 overview](/api-reference/image-to-video/pixverse-v6/overview).
* **PixVerse V6 Text to Video**: generate a video from a text prompt with no input image. See the [PixVerse V6 Text to Video overview](/api-reference/text-to-video/pixverse-v6/overview).
# PixVerse V6 Transition - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/pixverse-v6-transition/pixverse-v6-transition-tasks
get /v1/ai/image-to-video/pixverse-v6-transition
List PixVerse-V6 Transition tasks.
# PixVerse V6 Transition - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/pixverse-v6-transition/task-by-id
get /v1/ai/image-to-video/pixverse-v6-transition/{task-id}
# PixVerse V5 - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/pixverse/get-pixverse-v5
get /v1/ai/image-to-video/pixverse-v5
List PixVerse-V5 tasks filtered by resolution provided in the request body.
# PixVerse V5 - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/pixverse/get-{task-id}-by-id
get /v1/ai/image-to-video/pixverse-v5/{task-id}
# PixVerse V5 – Image‑to‑Video API
Source: https://docs.magnific.com/api-reference/image-to-video/pixverse/overview
Generate cinematic videos from a single image with smooth, expressive motion, stable style and color, and strong instruction adherence. Faster rendering and multiple output options.
## Overview
PixVerse V5 generates videos from a single image with cinematic quality and smooth, expressive motion. It improves rendering speed, maintains style and color across frames, and follows instructions reliably—ideal for creative exploration and production pipelines.
### Key capabilities
* Smooth, natural motion from one input image
* Cinematic imagery with sharper details and clarity
* Stable style and color across sequences (subject consistency)
* Strong instruction adherence for look, tone, and motion
* Faster rendering versus prior versions, with multiple output options
### Use cases
* Short films, teasers, and cinematic promos
* YouTube/TikTok/Instagram content (short- and long‑form)
* Product and brand videos with consistent subjects
* Educational explainers and motion studies
* Experimental art and abstract motion
Generate video from an image
Check task status
List image-to-video tasks
## Frequently Asked Questions
Use a high‑resolution image with clear subjects and balanced lighting. Avoid heavy compression and cluttered backgrounds to maximize motion quality.
Common outputs include 360p, 540p, 720p, and 1080p. For extreme resolutions, pair results with an upscaler to reach 4K.
Yes. V5 improves style/color stability and subject consistency for more coherent sequences and narratives.
# PixVerse V5 - Create video from image
Source: https://docs.magnific.com/api-reference/image-to-video/pixverse/post-pixverse-v5
post /v1/ai/image-to-video/pixverse-v5
Generate a video using the PixVerse-V5 model. Resolution is specified in the request body.
# Create video from image - Veo 3.1
Source: https://docs.magnific.com/api-reference/image-to-video/post-veo-3-1
post /v1/ai/image-to-video/veo-3-1
Generate a video from an image using Google Veo 3.1 model. Supports multiple resolutions (720p, 1080p, 4K) and optional audio generation.
# Create video from image - Veo 3.1 Fast
Source: https://docs.magnific.com/api-reference/image-to-video/post-veo-3-1-fast
post /v1/ai/image-to-video/veo-3-1-fast
Generate a video from an image using Google Veo 3.1 Fast model. Faster generation at a lower cost.
# Create video from image - Veo 3.1 Lite
Source: https://docs.magnific.com/api-reference/image-to-video/post-veo-3-1-lite
post /v1/ai/image-to-video/veo-3-1-lite
Generate a video from an image using Google Veo 3.1 Lite. A cost-efficient variant of Veo 3.1 supporting 720p and 1080p resolutions with optional native audio generation.
# RunWay Gen4 Turbo - Create video from image
Source: https://docs.magnific.com/api-reference/image-to-video/runway-gen4-turbo
post /v1/ai/image-to-video/runway-gen4-turbo
Generate a video from an image using RunWay Gen4 Turbo model.
# RunWay Gen4 Turbo - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/runway-gen4-turbo-tasks
get /v1/ai/image-to-video/runway-gen4-turbo
# RunWay Gen4 Turbo - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/runway-gen4-turbo/task-by-id
get /v1/ai/image-to-video/runway-gen4-turbo/{task-id}
# Veo 3.1 Lite – Image-to-Video API | Magnific API
Source: https://docs.magnific.com/api-reference/image-to-video/veo-3-1-lite/overview
Animate images into cinematic videos with Google Veo 3.1 Lite. A cost-efficient variant supporting 720p and 1080p resolutions with optional native audio.
Cost-efficient image-to-video generation powered by Google's Veo 3.1 Lite model with 720p and 1080p output and optional audio synthesis.
Veo 3.1 Lite is the cost-efficient variant of Google's Veo 3.1 model. It animates a source image into a high-quality cinematic video at 720p or 1080p resolution, guided by a text prompt, with durations of 4-8 seconds and optional native audio generation. Choose Veo 3.1 Lite when you want the Veo 3.1 look at a lower cost for prototyping, iteration, and high-volume workflows.
### Key capabilities
* **Image-driven generation**: Animate a source image into video guided by a text prompt
* **Cost-efficient generation**: The lightweight Veo 3.1 variant for prototyping and high-volume workflows
* **Multi-resolution output**: Generate videos in 720p or 1080p resolution
* **Audio generation**: Optional synchronized audio for complete multimedia content
* **Flexible durations**: 4, 6, or 8 second video outputs
* **Aspect ratio control**: 16:9 (landscape) or 9:16 (portrait) formats
* **Negative prompts**: Specify elements to avoid in generation
* **Long prompts**: Up to 20,000 characters for detailed descriptions
* **Reproducible results**: Seed parameter for consistent outputs
### Use cases
* **Product animation**: Bring product photos to life for marketing and ads
* **Social media**: Turn images into engaging short-form content for TikTok, Reels, and Shorts
* **Storytelling**: Animate concept art, illustrations, and stills
* **Advertising**: Produce video ads from a key visual
* **Prototyping**: Quickly test motion from an image before committing to a higher-fidelity model
### Generate with Veo 3.1 Lite
Submit a source image and a text prompt describing the motion you want. The service returns a task ID for async polling or webhook notification.
Create a new image-to-video task
List all Veo 3.1 Lite tasks
Get task status by ID
### Parameters
| Parameter | Type | Required | Description |
| ----------------- | --------- | -------- | ------------------------------------------------------------------------- |
| `image` | `string` | Yes | Input image as a Base64-encoded string or a publicly accessible HTTPS URL |
| `prompt` | `string` | Yes | Text describing the video to generate (max 20,000 chars) |
| `negative_prompt` | `string` | No | Text describing what to avoid in the video (max 2,000 chars) |
| `duration` | `integer` | No | Video duration: `4`, `6`, or `8` seconds (default: `8`) |
| `resolution` | `string` | No | Output resolution: `"720p"` or `"1080p"` (default: `"720p"`) |
| `aspect_ratio` | `string` | No | Video format: `"16:9"` or `"9:16"` (default: `"16:9"`) |
| `generate_audio` | `boolean` | No | Generate synchronized audio (default: `true`) |
| `seed` | `integer` | No | Random seed for reproducibility (0-4294967295) |
| `webhook_url` | `string` | No | URL for task completion notification |
## Frequently Asked Questions
Veo 3.1 Lite is the cost-efficient variant of Veo 3.1. It supports 720p and 1080p resolutions (Veo 3.1 also offers 4K) and is optimized for lower-cost, high-volume generation. Use Veo 3.1 Lite for prototyping and iteration, and Veo 3.1 Standard when you need maximum fidelity or 4K output.
Provide the `image` as a Base64-encoded string or a publicly accessible HTTPS URL. The image is used as the starting frame that Veo 3.1 Lite animates according to your prompt.
Veo 3.1 Lite supports **720p** (HD) and **1080p** (Full HD). For 4K output, use the standard Veo 3.1 model.
When `generate_audio` is set to `true` (the default), Veo 3.1 Lite synthesizes synchronized audio that matches the visual content. This includes ambient sounds, music, and effects appropriate to the scene.
Generation time varies based on resolution, duration, and server load. Use webhooks for production workflows to avoid polling.
Yes, set `aspect_ratio` to `"9:16"` to generate vertical videos optimized for TikTok, Instagram Reels, and YouTube Shorts.
## Best practices
* **Input quality**: Provide a sharp, well-lit source image with a clear subject for the strongest motion
* **Prompt detail**: Describe the motion, camera movement, and atmosphere you want applied to the image
* **Negative prompts**: Use `negative_prompt` to exclude unwanted elements like "blurry, low quality, distorted"
* **Resolution selection**: Choose 720p for fast iteration and 1080p for social media and final delivery
* **Audio control**: Disable `generate_audio` if you plan to add custom audio in post-production
* **Webhook integration**: Use webhooks instead of polling for scalable production applications
## Related APIs
* **[Veo 3.1 Image-to-Video](/api-reference/image-to-video/veo-3-1/overview)**: The standard Veo 3.1 model with 4K support and Fast mode
* **[Veo 3.1 Lite Text-to-Video](/api-reference/text-to-video/veo-3-1-lite/overview)**: Generate videos from a text prompt with Veo 3.1 Lite
* **[Kling 2.6 Pro](/api-reference/image-to-video/kling-v2-6-pro)**: Alternative image-to-video with motion control
* **[WAN 2.6](/api-reference/text-to-video/wan-v2-6-720p)**: Text-to-video at 720p and 1080p resolutions
# Veo 3.1 – Image-to-Video API | Magnific API
Source: https://docs.magnific.com/api-reference/image-to-video/veo-3-1/overview
Transform images into cinematic videos with Google Veo 3.1. Supports 720p, 1080p, and 4K resolutions with optional audio. Standard and Fast modes available.
State-of-the-art image-to-video generation powered by Google's Veo 3.1 model with multi-resolution output and optional audio synthesis.
Veo 3.1 Image-to-Video transforms static images into dynamic, cinematic videos guided by text prompts. It supports resolutions up to 4K, durations of 4-8 seconds, and optional audio generation. Choose between **Standard** mode for maximum quality or **Fast** mode for quicker generation at lower cost.
### Key capabilities
* **Image animation**: Bring any image to life with natural motion and dynamics
* **Start and end frame**: Animate from `image` towards an optional `image_end`, and Veo 3.1 interpolates the transition between both frames
* **Multi-resolution output**: Generate videos in 720p, 1080p, or 4K resolution
* **Audio generation**: Optional synchronized audio for complete multimedia content
* **Flexible durations**: 4, 6, or 8 second video outputs
* **Aspect ratio control**: 16:9 (landscape) or 9:16 (portrait) formats
* **Motion guidance**: Use prompts to direct how the image animates
* **Two generation modes**: Standard (highest quality) and Fast (cost-efficient)
* **Flexible input**: Accept Base64 encoded images or HTTPS URLs
### Use cases
* **Product animation**: Animate product photos for e-commerce and advertising
* **Social media content**: Transform static posts into engaging video content
* **Portrait animation**: Bring photos of people to life with natural movement
* **Art animation**: Animate artwork, illustrations, and digital creations
* **Marketing visuals**: Convert campaign images into dynamic video ads
* **Storytelling**: Create video sequences from storyboard images
### Generate with Veo 3.1 Standard
High-quality video generation with maximum fidelity and detail.
Create a new image-to-video task
List all Veo 3.1 tasks
Get task status by ID
### Generate with Veo 3.1 Fast
Faster generation at reduced cost, ideal for prototyping and high-volume workflows.
Create a fast image-to-video task
List all Veo 3.1 Fast tasks
Get task status by ID
### Parameters
| Parameter | Type | Required | Description |
| ----------------- | --------- | -------- | ----------------------------------------------------------------------------------------------------------------- |
| `image` | `string` | Yes | Input image as Base64 string or HTTPS URL (must be publicly accessible). Used as the first frame |
| `image_end` | `string` | No | Optional last frame as Base64 string or HTTPS URL. Veo 3.1 interpolates from `image` towards it. Requires `image` |
| `prompt` | `string` | Yes | Text describing the motion and animation (max 20,000 chars) |
| `negative_prompt` | `string` | No | Text describing what to avoid in the video |
| `duration` | `integer` | No | Video duration: `4`, `6`, or `8` seconds (default: `8`) |
| `resolution` | `string` | No | Output resolution: `"720p"`, `"1080p"`, or `"4k"` (default: `"720p"`) |
| `aspect_ratio` | `string` | No | Video format: `"16:9"` or `"9:16"` (default: `"16:9"`) |
| `generate_audio` | `boolean` | No | Generate synchronized audio (default: `true`) |
| `seed` | `integer` | No | Random seed for reproducibility |
| `webhook_url` | `string` | No | URL for task completion notification |
## Frequently Asked Questions
Veo 3.1 accepts images via **HTTPS URLs** (must be publicly accessible) or **Base64 encoded strings**. Common formats like JPEG, PNG, and WebP are supported.
**Standard mode** produces the highest quality output with maximum detail and natural motion, ideal for final production content. **Fast mode** generates videos more quickly at a lower cost, perfect for prototyping and high-volume workflows.
Yes. Send an optional `image_end` alongside `image` and Veo 3.1 interpolates the transition, so the video starts on `image` and lands on `image_end`. It works in both **Standard** and **Fast** modes and at every resolution, including 4K.
`image` remains required — the model needs a first frame to interpolate from, so `image_end` on its own returns a `400`. Both frames accept HTTPS URLs or Base64, and they can differ in format (for example a PNG first frame and a JPEG last frame). Use the prompt to describe the transition itself, such as *"the scene morphs smoothly from the first frame to the last"*.
The prompt guides how the image animates. Describe the desired motion, such as *"The subject slowly turns their head and smiles"* or *"Camera slowly zooms in while leaves blow in the wind"*. Be specific about movement direction and speed.
Veo 3.1 supports **720p** (HD), **1080p** (Full HD), and **4K** (Ultra HD). The output resolution is independent of your input image resolution.
When `generate_audio` is enabled (default), Veo 3.1 synthesizes audio that matches the visual content and motion. This includes ambient sounds and effects appropriate to the scene.
Yes, set `aspect_ratio` to `"9:16"` to generate vertical videos. For best results, use portrait-oriented source images when creating vertical content.
## Best practices
* **Image quality**: Use high-resolution, well-lit images with clear subjects for best results
* **Motion prompts**: Describe specific movements like "slowly pans left" or "subject walks forward"
* **Negative prompts**: Use to avoid unwanted artifacts like "blurry, distorted, flickering"
* **Resolution matching**: Consider your source image quality when selecting output resolution
* **Audio control**: Disable `generate_audio` if adding custom audio in post-production
* **End frame framing**: When using `image_end`, keep both frames in the same aspect ratio and with a consistent subject and lighting — the closer they are, the smoother the interpolation. `aspect_ratio` still governs the output, so a mismatch is adapted rather than rejected
* **Webhook integration**: Use webhooks for production workflows to handle async completion
* **Seed for consistency**: Use the same seed to reproduce similar animation results
## Related APIs
* **[Veo 3.1 Text-to-Video](/api-reference/text-to-video/veo-3-1/overview)**: Generate videos from text prompts with Veo 3.1
* **[Veo 3.1 Reference-to-Video](/api-reference/reference-to-video/veo-3-1/overview)**: Generate videos with consistent characters using reference images
* **[Kling 2.6 Pro](/api-reference/image-to-video/kling-v2-6-pro)**: Image-to-video with advanced motion control
* **[Kling O1](/api-reference/image-to-video/kling-o1/overview)**: Alternative image-to-video model
* **[MiniMax Live](/api-reference/image-to-video/minimax-live)**: Fast image-to-video generation
# WAN 2.5 1080p - Create video from image
Source: https://docs.magnific.com/api-reference/image-to-video/wan-2-5-i2v-1080p
post /v1/ai/image-to-video/wan-2-5-i2v-1080p
Generate a 1080p video from image using the WAN 2.5 model.
# WAN 2.5 I2V 1080p - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/wan-2-5-i2v-1080p-tasks
get /v1/ai/image-to-video/wan-2-5-i2v-1080p
Get the list of WAN 2.5 Image-to-Video 1080p tasks
# WAN 2.5 480p - Create video from image
Source: https://docs.magnific.com/api-reference/image-to-video/wan-2-5-i2v-480p
post /v1/ai/image-to-video/wan-2-5-i2v-480p
Generate a 480p video from image using the WAN 2.5 model.
# WAN 2.5 I2V 480p - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/wan-2-5-i2v-480p-tasks
get /v1/ai/image-to-video/wan-2-5-i2v-480p
Get the list of WAN 2.5 Image-to-Video 480p tasks
# WAN 2.5 720p - Create video from image
Source: https://docs.magnific.com/api-reference/image-to-video/wan-2-5-i2v-720p
post /v1/ai/image-to-video/wan-2-5-i2v-720p
Generate a 720p video from image using the WAN 2.5 model.
# WAN 2.5 I2V 720p - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/wan-2-5-i2v-720p-tasks
get /v1/ai/image-to-video/wan-2-5-i2v-720p
Get the list of WAN 2.5 Image-to-Video 720p tasks
# WAN 2.5 I2V 1080p - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/wan-2-5/task-by-id-1080p
get /v1/ai/image-to-video/wan-2-5-i2v-1080p/{task-id}
Get the status of a WAN 2.5 Image-to-Video 1080p task
# WAN 2.5 I2V 480p - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/wan-2-5/task-by-id-480p
get /v1/ai/image-to-video/wan-2-5-i2v-480p/{task-id}
Get the status of a WAN 2.5 Image-to-Video 480p task
# WAN 2.5 I2V 720p - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/wan-2-5/task-by-id-720p
get /v1/ai/image-to-video/wan-2-5-i2v-720p/{task-id}
Get the status of a WAN 2.5 Image-to-Video 720p task
# WAN 2.7 - Create video from image
Source: https://docs.magnific.com/api-reference/image-to-video/wan-2-7/generate
post /v1/ai/image-to-video/wan-2-7
Generate a video from an image or extend an existing video using WAN 2.7.
**Three generation modes:**
- **First frame**: Provide `start_image_url` alone to animate from a starting image
- **First + last frame**: Provide both `start_image_url` and `end_image_url` for controlled start-to-end animation
- **Video continuation**: Provide `video_url` to extend an existing video, optionally with `end_image_url` as the target ending frame
**Key features:**
- 720P and 1080P resolution support
- Optional audio-guided generation
- Duration range: 2-15 seconds
# WAN 2.7 Image To Video API
Source: https://docs.magnific.com/api-reference/image-to-video/wan-2-7/overview
Generate AI videos from images with WAN 2.7. First frame, first+last frame, and video continuation modes. 720P and 1080P resolution, 2-15 second durations, and audio-guided generation.
WAN 2.7 Image-to-Video supports three generation modes: animate from a first frame, control start-to-end animation, or extend existing videos with optional audio guidance.
WAN 2.7 Image-to-Video is an AI video generation API that creates MP4 videos from images or extends existing videos. It supports three distinct generation modes: first-frame animation, first+last frame controlled animation, and video continuation. Output is available at 720P (1280x720) or 1080P (1920x1080) resolution with durations from 2 to 15 seconds. The model also supports optional audio input and automatic prompt expansion.
### Key capabilities
* **Three generation modes**: First frame only, first+last frame, and video continuation
* **Resolution options**: 720P (1280x720) and 1080P (1920x1080) output
* **Flexible durations**: 2 to 15 seconds of video output
* **Audio-guided generation**: Provide a WAV or MP3 audio file (2-30 seconds, max 15MB) to guide video creation
* **Prompt expansion**: AI optimizer expands short prompts into detailed scripts for richer output
* **Video extension**: Continue an existing MP4/MOV video (2-10 seconds, max 100MB) with new content
* **Image constraints**: Supports JPEG, PNG, BMP, WEBP images (240-8000px per side, max 20MB)
* **Async processing**: Webhook notifications or polling for task completion
### Generation modes
| Mode | Required inputs | Best for |
| ---------------------- | ------------------------------------------ | ------------------------------------------------- |
| **First frame** | `start_image_url` | Animating a still image with AI-generated motion |
| **First + last frame** | `start_image_url` + `end_image_url` | Controlled transition between two keyframes |
| **Video continuation** | `video_url` (optionally + `end_image_url`) | Extending an existing video clip with new content |
### Use cases
* **Product animation**: Bring product images to life with smooth motion and camera movements
* **Marketing videos**: Animate brand imagery into short-form video content
* **Social media content**: Create video posts from static images for TikTok, Instagram, and YouTube
* **Video extension**: Extend short clips into longer narratives using video continuation
* **Storyboarding**: Animate concept art or wireframes to preview motion sequences
* **Creative exploration**: Experiment with first+last frame mode for controlled visual transitions
### API operations
Generate videos by submitting an image or video to the API. The service returns a task ID for async polling or webhook notification.
Create a new image-to-video generation task
List all WAN 2.7 I2V tasks with status
Get task status and results by ID
### Parameters
| Parameter | Type | Required | Default | Description |
| ----------------------------------- | --------- | ----------- | --------- | ------------------------------------------------------------------------------------- |
| `prompt` | `string` | No | - | Text description to guide video motion and style. Max 5000 characters |
| `negative_prompt` | `string` | No | - | Elements to avoid (e.g., "blurry, watermark"). Max 500 characters |
| `start_image_url` | `string` | Conditional | - | URL of first-frame image (JPEG/PNG/BMP/WEBP, 240-8000px, max 20MB) |
| `end_image_url` | `string` | No | - | URL of last-frame image. Use with `start_image_url` or `video_url` |
| `video_url` | `string` | Conditional | - | URL of existing video to extend (MP4/MOV, 2-10s, max 100MB) |
| `audio_url` | `string` | No | - | URL of audio file (WAV/MP3, 2-30s, max 15MB) to guide generation |
| `resolution` | `string` | No | `"1080P"` | Output resolution: `"720P"` or `"1080P"` |
| `duration` | `integer` | No | `5` | Video length in seconds: 2 to 15. For video continuation, this is total output length |
| `seed` | `integer` | No | Random | Seed for reproducibility (0 to 2147483647) |
| `additional_settings.prompt_extend` | `boolean` | No | `true` | Enable AI prompt expansion for richer output |
| `webhook_url` | `string` | No | - | URL for async status notifications |
## Frequently Asked Questions
WAN 2.7 Image-to-Video is an AI video generation API developed by Alibaba. You submit an image or video URL, receive a task ID immediately, then poll for results or receive a webhook notification when processing completes. The model generates MP4 video at 720P or 1080P resolution in durations from 2 to 15 seconds.
**First frame**: Provide `start_image_url` alone to animate from a starting image. **First + last frame**: Provide both `start_image_url` and `end_image_url` for controlled start-to-end animation. **Video continuation**: Provide `video_url` to extend an existing video, optionally with `end_image_url` as the target ending frame.
WAN 2.7 accepts JPEG, PNG, BMP, and WEBP images via publicly accessible URLs. Images must be 240-8000 pixels per side with an aspect ratio between 1:8 and 8:1, and a maximum file size of 20MB.
Video continuation accepts MP4 and MOV files via publicly accessible URLs. Input videos must be 2-10 seconds long, 240-4096 pixels per side, and under 100MB.
Provide a WAV or MP3 audio file URL via the `audio_url` parameter. The audio must be 2-30 seconds long and under 15MB. WAN 2.7 uses the audio to influence the visual content and motion of the generated video.
Rate limits depend on your subscription tier. See the [Rate Limits](/ratelimits) page for current limits by plan.
See the [Pricing page](/pricing) for current rates and subscription options.
## Best practices
* **Image quality**: Use high-resolution images with clear subjects and balanced lighting. Avoid heavily compressed or noisy inputs.
* **First + last frame**: Ensure both images share a similar visual style and subject for smooth transitions.
* **Video continuation**: Input video duration (2-10s) counts toward total output duration. Plan accordingly.
* **Prompt writing**: Even though prompts are optional for I2V, adding motion and camera directions improves results.
* **Negative prompts**: Always include: "blurry, low quality, watermark, text, distortion, extra limbs"
* **Production integration**: Use webhooks for scalable applications instead of polling.
* **Error handling**: Implement retry with exponential backoff for 503 errors during high-demand periods.
## Related APIs
* **[WAN 2.7 Text-to-Video](/api-reference/text-to-video/wan-2-7/overview)**: Generate videos purely from text prompts with WAN 2.7
* **[WAN 2.7 Reference-to-Video](/api-reference/reference-to-video/wan-2-7/overview)**: Generate videos featuring characters from reference images or videos
* **[WAN 2.6 Image-to-Video](/api-reference/wan-v2-6-i2v/overview)**: Previous WAN generation with multi-shot sequences
* **[Kling 2.5 Turbo Pro](/api-reference/image-to-video/kling-v2.5-pro/overview)**: Alternative I2V model with cinematic quality
# WAN 2.7 I2V - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/wan-2-7/task-by-id
get /v1/ai/image-to-video/wan-2-7/{task-id}
Retrieve the status and result of a specific WAN 2.7 image-to-video task by its ID.
# WAN 2.7 I2V - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/wan-2-7/wan-2-7-i2v-tasks
get /v1/ai/image-to-video/wan-2-7
Retrieve the list of all WAN 2.7 image-to-video tasks for the authenticated user.
# WAN 2.2 480p - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/wan-v2-2-480p/get-wan-v2-2-480p
get /v1/ai/image-to-video/wan-v2-2-480p
Get the list of WAN 2.2 480p tasks
# WAN 2.2 480p - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/wan-v2-2-480p/get-wan-v2-2-480p-task
get /v1/ai/image-to-video/wan-v2-2-480p/{task-id}
Get the status of the WAN 2.2 480p task
# WAN 2.2 480p - Create video from image
Source: https://docs.magnific.com/api-reference/image-to-video/wan-v2-2-480p/post-wan-v2-2-480p
post /v1/ai/image-to-video/wan-v2-2-480p
Generate a video from image using the WAN 2.2 480p model.
# WAN 2.2 580p - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/wan-v2-2-580p/get-wan-v2-2-580p
get /v1/ai/image-to-video/wan-v2-2-580p
Get the list of WAN 2.2 580p tasks
# WAN 2.2 580p - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/wan-v2-2-580p/get-wan-v2-2-580p-task
get /v1/ai/image-to-video/wan-v2-2-580p/{task-id}
Get the status of the WAN 2.2 580p task
# WAN 2.2 580p - Create video from image
Source: https://docs.magnific.com/api-reference/image-to-video/wan-v2-2-580p/post-wan-v2-2-580p
post /v1/ai/image-to-video/wan-v2-2-580p
Generate a video from image using the WAN 2.2 580p model.
# WAN 2.2 720p - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/wan-v2-2-720p/get-wan-v2-2-720p
get /v1/ai/image-to-video/wan-v2-2-720p
Get the list of WAN 2.2 720p tasks
# WAN 2.2 720p - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/wan-v2-2-720p/get-wan-v2-2-720p-task
get /v1/ai/image-to-video/wan-v2-2-720p/{task-id}
Get the status of the WAN 2.2 720p task
# WAN 2.2 720p - Create video from image
Source: https://docs.magnific.com/api-reference/image-to-video/wan-v2-2-720p/post-wan-v2-2-720p
post /v1/ai/image-to-video/wan-v2-2-720p
Generate a video from image using the WAN 2.2 720p model.
# WAN 2.6 1080p - Create video from image
Source: https://docs.magnific.com/api-reference/image-to-video/wan-v2-6-1080p
post /v1/ai/image-to-video/wan-v2-6-1080p
Generate a 1080p video from image using the WAN 2.6 model.
# WAN 2.6 I2V 1080p - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/wan-v2-6-1080p-tasks
get /v1/ai/image-to-video/wan-v2-6-1080p
Get the list of WAN 2.6 Image-to-Video 1080p tasks
# WAN 2.6 720p - Create video from image
Source: https://docs.magnific.com/api-reference/image-to-video/wan-v2-6-720p
post /v1/ai/image-to-video/wan-v2-6-720p
Generate a 720p video from image using the WAN 2.6 model.
# WAN 2.6 I2V 720p - List tasks
Source: https://docs.magnific.com/api-reference/image-to-video/wan-v2-6-720p-tasks
get /v1/ai/image-to-video/wan-v2-6-720p
Get the list of WAN 2.6 Image-to-Video 720p tasks
# WAN 2.6 I2V 1080p - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/wan-v2-6/task-by-id-1080p
get /v1/ai/image-to-video/wan-v2-6-1080p/{task-id}
Get the status of a WAN 2.6 Image-to-Video 1080p task
# WAN 2.6 I2V 720p - Get task status
Source: https://docs.magnific.com/api-reference/image-to-video/wan-v2-6/task-by-id-720p
get /v1/ai/image-to-video/wan-v2-6-720p/{task-id}
Get the status of a WAN 2.6 Image-to-Video 720p task
# Upscaler Creative - Get task status
Source: https://docs.magnific.com/api-reference/image-upscaler-creative/get-image-upscaler
get /v1/ai/image-upscaler/{task-id}
Get the status of the upscaling task
# Upscaler Creative - List tasks
Source: https://docs.magnific.com/api-reference/image-upscaler-creative/get-image-upscaler-task
get /v1/ai/image-upscaler
Get the status of all upscaling tasks
# Magnific Upscaler Creative API
Source: https://docs.magnific.com/api-reference/image-upscaler-creative/image-upscaler
Best AI image upscaler to enlarge pictures without losing quality. Prompt-guided enhancement, stylization, and 2x/4x/8x/16x upscaling.
Creative mode adds or infers new detail guided by your prompt, enabling stylized, higher‑impact upscales.
The Magnific Upscaler enhances images to higher resolutions. This powerful tool does more than just increase image size - it also improves quality and adds detail. By leveraging advanced upscaling technology, our API allows you to transform your images with custom prompts and fine-tuned parameters, achieving impressive results. Need faithful upscaling without adding new elements? See Upscaler Precision.
### Key capabilities
* Prompt‑guided enhancement that can introduce or infer new detail
* Stylization options to match aesthetics or art directions
* Controls to balance fidelity vs creativity
* Resolution growth (2x/4x/8x/16x) with quality improvement
* Ideal for concept art, marketing creatives, and visual ideation
### Use Cases
The Magnific Upscaler can be applied to a wide range of image types and industries, including:
* Portraits: Enhance facial details and skin textures
* Illustrations: Sharpen lines and improve color vibrancy
* Video game assets: Upscale textures and character models
* Landscapes: Bring out intricate details in nature scenes
* Science fiction imagery: Enhance futuristic and space-themed visuals
* Fantasy art: Improve magical and mythical elements
* Film stills: Increase resolution for better visual quality
* Graphic design: Upscale logos and marketing materials
* Architectural renderings: Enhance building details and textures, jumping from quick sketches to high quality renders
* Interior design: Improve quality of room layouts and furniture details
* Food photography: Bring out textures and colors in culinary images
### Upscale an Image with Magnific
Create an upscaling task for an image.
Upscale an image using Magnific
## Image Input Best Practices
For maximum quality results, how you send your image matters:
| Action | Quality Impact |
| ------------------------------------------ | -------------------------- |
| Send URL of original image | ✅ Maximum quality |
| Send base64 of original file read directly | ✅ Maximum quality |
| Use `canvas.toDataURL('image/jpeg')` | ❌ \~8% quality loss |
| Use `canvas.toDataURL('image/jpeg', 0.8)` | ❌ \~20% quality loss |
| Resize image before sending | ❌ Significant quality loss |
| Convert PNG → JPEG before sending | ❌ Quality loss |
**Recommended:** Send the original image via URL whenever possible. This ensures the upscaler receives the highest quality input, which directly impacts output quality.
## Frequently Asked Questions
Yes! Magnific.ai is part of Magnific and we are happy to offer the same technology in an API service. If you tried Magnific.ai before, you will get the same technology and its future updates.
The cost per image upscale is based on the output image area in pixels. This depends on two key factors:
* The dimensions of the input image
* The upscale factor applied (e.g.: 2x, 4x, 8x, 16x)
The larger the output image area, the higher the cost per upscale. Our pricing tiers are applied based on the final output size, so you have complete transparency and control over your usage.
Some examples:
| Input Size | Output Size | Upscale Factor | Price |
| ---------- | ----------- | -------------- | ----- |
| 640x480 | 1280x960 | 2x | €0.10 |
| 640x480 | 2560x1920 | 4x | €0.20 |
| 640x480 | 5120x3840 | 8x | €0.50 |
| 1280x720 | 2560x1440 | 2x | €0.10 |
| 1280x720 | 5120x2880 | 4x | €0.40 |
| 1920x1080 | 3840x2160 | 2x | €0.20 |
The pricing structure ensures that you only pay for the level of upscaling you need.
Use Upscaler Precision for faithful super‑resolution without hallucinations (best for logos, UI, text, and product photos). Choose Creative when you want to add or infer detail and stylize results via prompts.
# Upscaler Creative - Upscale image
Source: https://docs.magnific.com/api-reference/image-upscaler-creative/post-image-upscaler
post /v1/ai/image-upscaler
This asynchronous endpoint enables image upscaling using advanced AI algorithms. Upon submission, it returns a unique `task_id` which can be used to track the progress of the upscaling process. For real-time production use, include the optional `webhook_url` parameter to receive an automated notification once the task has been completed. This allows for seamless integration and efficient task management without the need for continuous polling.
## Important
For a comprehensive guide on this service, including use cases and detailed functionality, check out our [Image Upscaler Guide](/api-reference/image-upscaler-creative/image-upscaler).
## Request
# Upscaler Precision V2 - List tasks
Source: https://docs.magnific.com/api-reference/image-upscaler-precision-v2/get-image-upscaler-precision-v2
get /v1/ai/image-upscaler-precision-v2
Returns a list of all precision upscaler V2 tasks. Each task includes its ID, current status, and output URL if completed.
# Upscaler Precision V2 - Get task status
Source: https://docs.magnific.com/api-reference/image-upscaler-precision-v2/get-{task-id}-by-id
get /v1/ai/image-upscaler-precision-v2/{task-id}
Returns the current status and output URL of a specific precision upscaler V2 task. The output URL is included only if the task has completed successfully.
# Upscaler Precision V2 – AI Image Upscaling API
Source: https://docs.magnific.com/api-reference/image-upscaler-precision-v2/overview
Upscale images with Precision V2. Advanced detail enhancement with sharpen, smart grain, and ultra detail controls. Scale 2x to 16x with photo and illustration flavors.
Precision V2 delivers enhanced upscaling with fine-grained controls for sharpness, texture, and detail while preserving image fidelity.
Upscaler Precision V2 is an advanced image upscaling API that enhances resolution while intelligently adding details and improving image quality. Building on the original Precision upscaler, V2 introduces granular control over sharpness, grain texture, and ultra-fine detail enhancement. The API supports multiple image types through specialized processing flavors optimized for photos, illustrations, and noisy images. Looking for creative, prompt-guided upscaling? See Upscaler Creative.
### Key capabilities
* **Scale factors 2x to 16x**: Multiply image dimensions from 2x up to 16x (up to 256x total pixels)
* **Sharpen control**: Adjustable sharpening intensity (0-100, default 7) for edge definition and clarity
* **Smart grain**: Intelligent texture enhancement (0-100, default 7) to preserve natural film grain and prevent artificial smoothness
* **Ultra detail**: Fine detail enhancement level (0-100, default 30) for textures, patterns, and micro-details
* **Processing flavors**: Three optimized modes: `sublime` for illustrations, `photo` for photographs, `photo_denoiser` for noisy images
* **Async processing**: Webhook notifications or polling for task completion
* **Flexible input**: Accepts HTTPS URLs or base64-encoded images
### Use cases
* **E-commerce**: Upscale product photos with enhanced sharpness while preserving color accuracy and texture
* **Photography restoration**: Enhance old photos with smart grain to maintain natural film characteristics
* **Print production**: Scale digital images for large-format printing with ultra detail for crisp output
* **Illustration enhancement**: Upscale digital art with the sublime flavor for smooth gradients and vibrant colors
* **Real estate**: Enhance property photos with the photo flavor for realistic detail preservation
* **Archival digitization**: Restore scanned documents and photos with noise reduction via photo\_denoiser
### Upscale images with Precision V2
Create an upscaling task by submitting a request to the API. The service returns a task ID for async polling or webhook notification.
Create a new image upscaling task
List all Precision V2 tasks
Get task status and results by ID
### Parameters
| Parameter | Type | Required | Default | Description |
| -------------- | --------------------- | -------- | ------- | ------------------------------------------------------------------------- |
| `image` | `string` | Yes | - | Source image as HTTPS URL or base64-encoded string |
| `scale_factor` | `integer` or `string` | No | - | Scaling multiplier: 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, or 16 |
| `sharpen` | `integer` | No | `7` | Sharpness intensity (0-100). Higher values increase edge definition |
| `smart_grain` | `integer` | No | `7` | Grain/texture enhancement (0-100). Preserves natural film grain |
| `ultra_detail` | `integer` | No | `30` | Fine detail level (0-100). Controls textures and micro-details |
| `flavor` | `string` | No | - | Processing mode: `sublime`, `photo`, or `photo_denoiser` |
| `webhook_url` | `string` | No | - | URL for completion notification with task status and output URL |
## Frequently Asked Questions
Upscaler Precision V2 is an AI-powered image upscaling API that increases image resolution while intelligently enhancing details. You submit an image via URL or base64, receive a task ID, then poll for results or receive a webhook notification when processing completes. The API adds fine details based on the content type and your parameter settings.
Precision V2 introduces granular control parameters that V1 does not have: sharpen (edge definition), smart\_grain (texture preservation), and ultra\_detail (micro-detail enhancement). V2 also supports processing flavors optimized for different image types. Use V2 when you need fine-tuned control over the upscaling output.
The three flavors are: **sublime** for artistic and illustrated images with smooth gradients and vibrant colors; **photo** for photographic images preserving natural colors and realistic details; **photo\_denoiser** for photos with noise reduction, ideal for low-light or grainy photographs. Choose based on your source image type.
**Sharpen** (default 7) controls edge clarity and definition. **Smart grain** (default 7) adds natural texture to prevent artificial smoothness. **Ultra detail** (default 30) enhances fine patterns and micro-details. All range from 0-100. Start with defaults and adjust based on your specific image needs.
Precision V2 supports scale factors from 2 to 16. A scale factor of 2 doubles dimensions (4x total pixels), while 16 increases dimensions 16-fold (256x total pixels). Higher scale factors increase processing time and output file size.
Rate limits vary by subscription tier. See the Rate Limits page for current limits by plan.
Pricing is based on output image area in pixels, determined by input dimensions and scale factor. See the Pricing page for current rates and subscription options.
**Precision V2** focuses on faithful upscaling with controlled detail enhancement, preserving the original content while adding sharpness and texture. **Creative** uses prompts to introduce or infer new visual elements and stylization. Choose Precision V2 when fidelity matters; choose Creative when you want artistic enhancement.
## Best practices
* **Input quality**: Start from the highest-quality source available. Avoid heavily compressed images as artifacts may be amplified
* **Flavor selection**: Use `sublime` for illustrations and digital art, `photo` for natural photographs, `photo_denoiser` for noisy or low-light images
* **Parameter tuning**: Start with default values (sharpen: 7, smart\_grain: 7, ultra\_detail: 30) and adjust incrementally based on results
* **Scale factor**: Begin with 2x-4x for most use cases. Higher factors (8x-16x) work best with high-quality source images
* **Grain for realism**: Increase smart\_grain for photographic images to avoid the "plastic" look common in AI upscaling
* **Production integration**: Use webhooks instead of polling for scalable, event-driven applications
* **Error handling**: Implement retry logic with exponential backoff for 503 errors during high traffic
## Related APIs
* **[Upscaler Creative](/api-reference/image-upscaler-creative/image-upscaler)**: Prompt-guided upscaling with creative detail generation and stylization
* **[Upscaler Precision](/api-reference/image-upscaler-precision/image-upscaler)**: Original precision upscaler without V2's granular controls
# Upscaler Precision V2 - Upscale image
Source: https://docs.magnific.com/api-reference/image-upscaler-precision-v2/post-image-upscaler-precision-v2
post /v1/ai/image-upscaler-precision-v2
Upscales an image while adding new visual elements or details (V2).
This endpoint may modify the original image content based on the prompt and inferred context.
# Upscaler Precision - List tasks
Source: https://docs.magnific.com/api-reference/image-upscaler-precision/get-image-upscaler-precision
get /v1/ai/image-upscaler-precision
Returns a list of all precision upscaler tasks. Each task includes its ID, current status, and output URL if completed.
# Upscaler Precision - Get task status
Source: https://docs.magnific.com/api-reference/image-upscaler-precision/get-{task-id}-by-id
get /v1/ai/image-upscaler-precision/{task-id}
Returns the current status and output URL of a specific precision upscaler task. The output URL is included only if the task has completed successfully.
# Upscaler Precision – High‑Fidelity Super‑Resolution (No Hallucinations)
Source: https://docs.magnific.com/api-reference/image-upscaler-precision/image-upscaler
High‑fidelity AI upscaling that preserves original content, small text/UI, and fine details without adding new elements. Ideal for logos, UI, and product photos.
Precision mode focuses on faithful super‑resolution without hallucinations—best choice when preserving content is critical.
The Magnific Upscaler Precision focuses on faithful, high-fidelity upscaling. It increases resolution while preserving the original content, texture, and structure of the image. Unlike creative upscaling, Precision prioritizes clarity, sharpness, and detail recovery without inventing new elements. Looking for stylized or prompt‑guided enhancement? See Upscaler Creative.
With advanced super-resolution techniques, Upscaler Precision:
* Preserves edges and fine details while minimizing halos
* Reduces noise and compression artifacts
* Maintains color consistency and natural look
* Enhances readability for small text and UI elements
### Use cases (Precision)
Upscaler Precision is ideal when you need quality improvements without altering the content:
* E‑commerce product photos: sharpen edges, remove artifacts, preserve true colors
* Branding and logos: upscale raster logos and icons with crisp lines
* UI assets and screenshots: improve sharpness while keeping pixel-accurate layouts
* Photography restoration and scans: reduce noise and recover fine detail
* Technical diagrams and architectural drawings: preserve thin lines and text
* Social media and web images: upscale for higher-DPI displays without distortion
### Upscale an image with Upscaler Precision
Create a precision upscaling task for an image.
Upscale an image with Precision mode
## Frequently Asked Questions
Yes! Magnific.ai is part of Magnific and we are happy to offer the same technology in an API service. If you tried Magnific.ai before, you will get the same technology and its future updates.
The cost per image upscale is based on the output image area in pixels. This depends on two key factors:
* The dimensions of the input image
* The upscale factor applied (e.g.: 2x, 4x, 8x, 16x)
The larger the output image area, the higher the cost per upscale. Our pricing tiers are applied based on the final output size, so you have complete transparency and control over your usage.
Some examples:
| Input Size | Output Size | Upscale Factor | Price |
| ---------- | ----------- | -------------- | ----- |
| 640x480 | 1280x960 | 2x | €0.10 |
| 640x480 | 2560x1920 | 4x | €0.20 |
| 640x480 | 5120x3840 | 8x | €0.50 |
| 1280x720 | 2560x1440 | 2x | €0.10 |
| 1280x720 | 5120x2880 | 4x | €0.40 |
| 1920x1080 | 3840x2160 | 2x | €0.20 |
The pricing structure ensures that you only pay for the level of upscaling you need.
Precision preserves the original content and improves clarity, detail, and sharpness without inventing new elements. It is ideal for logos, UI assets, product photos, scans, and technical diagrams.
Creative can introduce or infer new visual details guided by prompts or context. It is better for artistic enhancement, stylization, or imaginative detail addition.
Choose Precision when fidelity is critical: brand consistency, readable text, pixel-accurate UI, and product authenticity. Choose Creative when you want stylistic enhancements or new visual elements.
Prefer PNG for graphics/logos and high-quality JPEG/PNG for photos. Avoid heavily compressed sources. For best results, use inputs large enough to contain the essential detail (e.g., at least 256–512 px on the shortest edge), then upscale 2x–4x.
Precision improves edge sharpness and micro-contrast, which can make small text and UI icons more legible. Extremely low-resolution or heavily blurred originals may still have limits.
## Best practices for Upscaler Precision
Follow these recommendations to get the best, most faithful results:
* Start from the highest-quality source you have (avoid heavy-compressed inputs).
* Prefer PNG or high-quality JPEG; keep artifacts minimal in the input.
* Choose moderate upscale factors first (2x–4x) to avoid amplifying noise; iterate if needed.
* Disable any creative prompts or stylization when fidelity is critical.
* For logos/UI, use crisp sources with strong contrast; avoid anti-aliased tiny originals.
* When upscaling scans, pre-trim borders and rotate/crop to the correct orientation.
* Compare results at 100% zoom to validate line sharpness and color consistency.
### Image Input Quality
How you send your image directly impacts the output quality:
| Action | Quality Impact |
| ------------------------------------------ | -------------------------- |
| Send URL of original image | ✅ Maximum quality |
| Send base64 of original file read directly | ✅ Maximum quality |
| Use `canvas.toDataURL('image/jpeg')` | ❌ \~8% quality loss |
| Use `canvas.toDataURL('image/jpeg', 0.8)` | ❌ \~20% quality loss |
| Resize image before sending | ❌ Significant quality loss |
| Convert PNG → JPEG before sending | ❌ Quality loss |
**Recommended:** Send the original image via URL whenever possible. This ensures the upscaler receives the highest quality input.
# Upscaler Precision - Upscale image
Source: https://docs.magnific.com/api-reference/image-upscaler-precision/post-image-upscaler-precision
post /v1/ai/image-upscaler-precision
Upscales an image while adding new visual elements or details.
This endpoint may modify the original image content based on the prompt and inferred context.
# Improve Prompt - List tasks
Source: https://docs.magnific.com/api-reference/improve-prompt/get-improve-prompt
get /v1/ai/improve-prompt
Get the status of all improve-prompt tasks
# Improve Prompt - Get task status
Source: https://docs.magnific.com/api-reference/improve-prompt/get-{task-id}-by-id
get /v1/ai/improve-prompt/{task-id}
Get the status of one improve-prompt task
# Improve Prompt - AI Prompt Enhancement API | Magnific API
Source: https://docs.magnific.com/api-reference/improve-prompt/overview
Enhance text prompts for AI image and video generation. Transform basic descriptions into detailed, optimized prompts with language support. Improve generation results automatically.
Transform simple text descriptions into optimized prompts for AI image and video generation, improving output quality automatically.
Improve Prompt is an AI-powered prompt enhancement API that transforms basic text descriptions into detailed, optimized prompts for AI generation. Submit a simple prompt like "a cat" and receive an enhanced version with specific details about lighting, composition, style, and atmosphere. The API supports both image and video generation prompts, with multi-language output capabilities.
### Key capabilities
* **Dual-mode enhancement**: Optimize prompts for either image or video generation with mode-specific improvements
* **Multi-language support**: Output enhanced prompts in any language using ISO 639-1 codes (e.g., `en`, `es`, `fr`, `de`)
* **Creative generation**: Submit an empty prompt to generate creative ideas from scratch
* **Maximum prompt length**: Input prompts up to 2,500 characters for comprehensive enhancement
* **Context-aware improvements**: Adds relevant details for lighting, composition, style, mood, and technical parameters
* **Async processing**: Webhook notifications or polling for task completion
### Use cases
* **Text-to-image workflows**: Enhance prompts before sending to Flux, Mystic, or other image generation APIs
* **Video generation preparation**: Optimize prompts for Kling, WAN, or other video generation models
* **Creative brainstorming**: Generate detailed creative prompts from minimal input or ideas
* **Non-English content creation**: Create prompts in your preferred language for localized projects
* **Batch processing pipelines**: Automate prompt enhancement in production workflows
* **Quality improvement**: Consistently achieve better AI generation results with optimized prompts
### Enhance prompts with Improve Prompt
Submit a text prompt with the target generation type (image or video). The service returns a task ID for async polling or webhook notification.
Create a new prompt enhancement task
List all prompt enhancement tasks
Get task status and results by ID
### Parameters
| Parameter | Type | Required | Default | Description |
| ------------- | -------- | -------- | ------- | ----------------------------------------------------------------------------------------------------------------------- |
| `prompt` | `string` | Yes | - | Text prompt to improve for AI generation. Can be empty to generate a creative prompt. Maximum length: 2,500 characters. |
| `type` | `string` | Yes | - | Type of generation to optimize for: `"image"` or `"video"` |
| `language` | `string` | No | `"en"` | Language code for the improved prompt (ISO 639-1 format, e.g., `"en"`, `"es"`, `"fr"`) |
| `webhook_url` | `string` | No | - | URL for task completion notification |
## Frequently Asked Questions
Improve Prompt is an AI-powered API that enhances basic text descriptions into detailed, optimized prompts for AI image or video generation. You submit a simple prompt (e.g., "a sunset") with the target type (image or video), receive a task ID immediately, then poll for results or receive a webhook notification. The output is an enhanced prompt with added details about composition, lighting, style, and technical parameters.
The `type` parameter determines how the prompt is optimized. For `"image"` prompts, the API adds details about composition, lighting, color palette, and visual style. For `"video"` prompts, it includes motion descriptions, camera movements, temporal flow, and cinematic elements that help video generation models produce better results.
Yes. Use the `language` parameter with any ISO 639-1 language code (e.g., `"es"` for Spanish, `"fr"` for French, `"de"` for German, `"ja"` for Japanese). The enhanced prompt will be returned in your specified language. Default is English (`"en"`).
When you submit an empty prompt, the API generates a creative prompt from scratch. This is useful for brainstorming or when you want AI-generated creative ideas for image or video generation.
Input prompts can be up to 2,500 characters. This allows you to provide detailed context that the API will further enhance and optimize.
Prompt enhancement typically completes within 2-5 seconds. For production workflows, use webhooks instead of polling to receive immediate notification when tasks complete.
Rate limits vary by subscription tier. See [Rate Limits](/ratelimits) for current limits.
See the [Pricing page](/pricing) for current rates and subscription options.
## Best practices
* **Be specific**: Even simple prompts benefit from context - include subject, action, or mood hints
* **Choose the right type**: Use `"image"` for static visuals and `"video"` for motion content
* **Language matching**: Set the language parameter to match your target audience or downstream model preferences
* **Chain with generation**: Pipe enhanced prompts directly to Flux, Mystic, Kling, or other generation APIs
* **Production integration**: Use webhooks instead of polling for scalable applications
* **Error handling**: Implement retry logic with exponential backoff for 503 errors
## Related APIs
* **[Magnific Mystic](/api-reference/mystic/mystic)**: Generate photorealistic images in 1K/2K/4K with LoRA styles
* **[Flux Pro](/api-reference/text-to-image/flux-pro-v1-1/post-flux-pro-v1-1)**: High-quality text-to-image generation with Flux Pro
* **[Kling 2.6 Pro](/api-reference/image-to-video/kling-v2.5-pro/overview)**: Generate videos from images with Kling
* **[Image to Prompt](/api-reference/image-to-prompt/post-image-to-prompt)**: Reverse process - generate prompts from images
# Improve Prompt - Enhance prompt
Source: https://docs.magnific.com/api-reference/improve-prompt/post-improve-prompt
post /v1/ai/improve-prompt
Enhance user prompts for AI image or video generation using advanced AI models.
- **Image prompts**: Improve a prompt for image generation
- **Video prompts**: Improve a prompt for video generation
# Kling O1 - Get task status
Source: https://docs.magnific.com/api-reference/kling-o1/task-by-id
get /v1/ai/image-to-video/kling-o1/{task-id}
# Latent Sync - List tasks
Source: https://docs.magnific.com/api-reference/lip-sync/latent-sync/get-latent-sync
get /v1/ai/lip-sync/latent-sync
Get the status of all Latent-Sync lip-sync tasks
# Latent Sync - Get task status
Source: https://docs.magnific.com/api-reference/lip-sync/latent-sync/get-{task-id}-by-id
get /v1/ai/lip-sync/latent-sync/{task-id}
Get the status of one Latent-Sync lip-sync task
# Latent Sync – Lip Sync API
Source: https://docs.magnific.com/api-reference/lip-sync/latent-sync/overview
Advanced AI-powered lip synchronization technology for realistic facial animation and speech-to-video matching with high-quality, production-ready outputs.
Powered by Latent Sync technology, this API provides state-of-the-art lip synchronization capabilities for creating realistic talking avatar videos from audio input.
Latent Sync is an advanced AI-powered lip synchronization solution that creates realistic facial animations synchronized with audio input. It generates high-quality talking avatar videos by intelligently matching mouth movements to speech patterns, delivering natural and believable results suitable for production environments.
### Key capabilities
* High-quality lip synchronization with natural facial movements
* Support for multiple languages and accents
* Realistic expression preservation during speech animation
* Production-ready video outputs with consistent quality
* Fast processing times optimized for real-time applications
### Use cases
* Avatar creation for virtual presentations and digital content
* Video dubbing and localization with synchronized lip movements
* Interactive chatbots and virtual assistants with realistic speech
* Educational content with animated instructors or characters
* Marketing videos with personalized spokesperson animations
Create a Latent Sync lip sync task
Check Latent Sync task status
List Latent Sync tasks
## Frequently Asked Questions
Latent Sync supports common audio formats including MP3, WAV, and AAC. The API automatically processes the audio to extract speech patterns for optimal lip synchronization.
Latent Sync uses advanced AI models trained specifically for speech-to-lip mapping, providing highly accurate synchronization that maintains natural facial expressions and realistic mouth movements.
Yes, you can provide your own base images or videos that will be animated with synchronized lip movements. The system works best with clear, front-facing portraits.
Latent Sync supports multiple languages and can handle various accents and speech patterns. The AI model adapts to different linguistic characteristics for optimal results.
Yes, Latent Sync generates production-quality videos suitable for commercial applications, marketing content, and professional presentations.
# Latent Sync - Lip-sync video generation
Source: https://docs.magnific.com/api-reference/lip-sync/latent-sync/post-latent-sync
post /v1/ai/lip-sync/latent-sync
Generate lip-synced video by synchronizing a video with an audio file using AI Latent-Sync technology
# Veed Fabric 1.0 Fast - Generate talking video
Source: https://docs.magnific.com/api-reference/lip-sync/veed-fabric-1-0-fast/generate
post /v1/ai/lip-sync/veed-fabric-1-0-fast
Generate a realistic talking video by combining a static portrait image with an audio file using Veed Fabric 1.0 Fast.
This is the faster variant of Veed Fabric 1.0, optimized for reduced generation time while maintaining quality lip synchronization.
Ideal for workflows requiring quick turnaround on talking head video generation.
# Veed Fabric 1.0 Fast API
Source: https://docs.magnific.com/api-reference/lip-sync/veed-fabric-1-0-fast/overview
Generate talking videos with faster processing using Veed Fabric 1.0 Fast. Lip-synced MP4 output at 720p or 480p from a portrait image and audio file.
Powered by Veed Fabric 1.0 Fast technology, this API generates talking head videos with optimized processing time for faster turnaround.
Veed Fabric 1.0 Fast is an AI-powered lip synchronization API optimized for reduced generation time. It creates talking videos from a static portrait image and an audio file, producing an MP4 video with natural lip movements synchronized to the speech. This variant prioritizes faster processing while maintaining quality lip-sync results, making it suitable for workflows that require quick turnaround. Output resolution is configurable at 720p (1280x720) or 480p (854x480).
### Key capabilities
* **Faster processing**: Optimized generation pipeline for reduced turnaround time compared to Veed Fabric 1.0
* **Image + audio input**: Combine a portrait photo with an audio file (MP3, WAV, M4A) to generate a talking video
* **Resolution options**: Output at `720p` (1280x720) for production use or `480p` (854x480) for drafts
* **Natural lip sync**: AI-driven mouth movement generation that matches speech patterns
* **Async processing**: Webhook notifications or polling for task completion
### Use cases
* **Rapid prototyping**: Quickly preview talking head videos before committing to full-quality generation
* **High-volume production**: Process large batches of lip-sync videos with faster turnaround
* **Real-time content**: Create time-sensitive marketing or social media videos
* **A/B testing**: Generate multiple video variants quickly for testing different audio or images
* **Live campaigns**: Produce personalized video responses at scale with minimal latency
### Generate talking video with Veed Fabric 1.0 Fast
Submit a portrait image URL and audio file URL along with the desired resolution. The service returns a task ID for async polling or webhook notification.
Create a new fast lip-sync video generation task
List all Veed Fabric 1.0 Fast tasks
Get task status and results by ID
### Parameters
| Parameter | Type | Required | Default | Description |
| ------------- | -------- | -------- | ------- | ------------------------------------------------------------------------------------------------------------------- |
| `image_url` | `string` | Yes | - | URL of the portrait image to animate. Must be publicly accessible. Use a clear, front-facing photo for best results |
| `audio_url` | `string` | Yes | - | URL of the audio file for lip synchronization. Supported formats: MP3, WAV, M4A. Must be publicly accessible |
| `resolution` | `string` | Yes | - | Output video resolution: `"720p"` (1280x720) or `"480p"` (854x480) |
| `webhook_url` | `string` | No | - | HTTPS URL for task completion notification |
## Frequently Asked Questions
Veed Fabric 1.0 Fast is an optimized variant of Veed Fabric 1.0 designed for faster lip-sync video generation. You submit an image URL and audio URL via the API, receive a task ID immediately, then poll for results or receive a webhook notification when processing completes. The output is an MP4 video with the person speaking in sync with the provided audio.
Veed Fabric 1.0 Fast accepts common image formats via a publicly accessible URL. For best lip-sync results, use a clear, front-facing portrait photo where the face is fully visible and well-lit.
Veed Fabric 1.0 Fast supports MP3, WAV, and M4A audio formats. The audio file must be hosted at a publicly accessible URL.
Two resolutions are available: `720p` (1280x720) for production-quality output and `480p` (854x480) for drafts or faster processing.
Veed Fabric 1.0 Fast is optimized for reduced generation time while maintaining quality lip synchronization. Veed Fabric 1.0 prioritizes maximum generation fidelity. Choose Veed Fabric 1.0 Fast when speed and throughput are the priority, or Veed Fabric 1.0 when you need the highest quality output.
Rate limits vary by subscription tier. See [Rate Limits](/ratelimits) for current limits.
See the [Pricing page](/pricing) for current rates and subscription options.
## Best practices
* **Image quality**: Use well-lit, front-facing portrait photos with a clearly visible face for the most accurate lip sync
* **Audio clarity**: Clean audio with minimal background noise produces better lip-sync accuracy
* **Resolution choice**: Use `720p` for final production videos and `480p` for quick previews or prototyping
* **Speed vs quality**: Use Veed Fabric 1.0 Fast for high-volume or time-sensitive workflows; switch to Veed Fabric 1.0 for maximum quality
* **Production integration**: Use webhooks instead of polling for scalable applications
* **Error handling**: Implement retry logic with exponential backoff for 503 errors
## Related APIs
* **[Veed Fabric 1.0](/api-reference/lip-sync/veed-fabric-1-0/overview)**: Higher fidelity lip-sync generation for quality-focused workflows
* **[Latent Sync](/api-reference/lip-sync/latent-sync/overview)**: Alternative lip synchronization technology
* **[Voiceover](/api-reference/voiceover/overview)**: Generate speech audio from text to use as lip-sync input
* **[Sound Effects](/api-reference/sound-effects/overview)**: Generate sound effects from text descriptions
# Veed Fabric 1.0 Fast - Get task status
Source: https://docs.magnific.com/api-reference/lip-sync/veed-fabric-1-0-fast/task-by-id
get /v1/ai/lip-sync/veed-fabric-1-0-fast/{task-id}
Retrieve a specific Veed Fabric 1.0 Fast lip-sync task by its ID, including generation status and result URL when completed.
# Veed Fabric 1.0 Fast - List tasks
Source: https://docs.magnific.com/api-reference/lip-sync/veed-fabric-1-0-fast/veed-fabric-1-0-fast-tasks
get /v1/ai/lip-sync/veed-fabric-1-0-fast
Retrieve all Veed Fabric 1.0 Fast lip-sync tasks for the authenticated user.
# Veed Fabric 1.0 - Generate talking video
Source: https://docs.magnific.com/api-reference/lip-sync/veed-fabric-1-0/generate
post /v1/ai/lip-sync/veed-fabric-1-0
Generate a realistic talking video by combining a static portrait image with an audio file using Veed Fabric 1.0.
The model produces a lip-synced video (MP4) where the person in the image speaks naturally in sync with the provided audio.
Ideal for creating talking head videos from a single photo and voice recording.
# Veed Fabric 1.0 API
Source: https://docs.magnific.com/api-reference/lip-sync/veed-fabric-1-0/overview
Generate realistic talking videos from a portrait image and audio file with Veed Fabric 1.0. Lip-synced MP4 output at 720p or 480p resolution for marketing, e-learning, and content creation.
Powered by Veed Fabric 1.0 technology, this API generates realistic talking head videos by synchronizing lip movements to audio input.
Veed Fabric 1.0 is an AI-powered lip synchronization API that creates realistic talking videos from a static portrait image and an audio file. The model analyzes the speech patterns in the audio and animates the person in the image with natural lip movements, producing an MP4 video where the subject appears to speak in sync with the provided audio. Output resolution is configurable at 720p (1280x720) or 480p (854x480).
### Key capabilities
* **Image + audio input**: Combine a portrait photo with an audio file (MP3, WAV, M4A) to generate a talking video
* **Resolution options**: Output at `720p` (1280x720) for production use or `480p` (854x480) for drafts and faster processing
* **Natural lip sync**: AI-driven mouth movement generation that matches speech patterns accurately
* **MP4 video output**: Generates a downloadable MP4 video file with the animated portrait
* **Async processing**: Webhook notifications or polling for task completion
### Use cases
* **Marketing videos**: Create personalized spokesperson videos from a single photo
* **E-learning**: Animate instructors for training materials and educational content
* **Social media**: Generate talking head content at scale for multiple platforms
* **Customer support**: Build video responses with consistent brand representatives
* **Localization**: Produce dubbed videos with lip-synced speech in different languages
### Generate talking video with Veed Fabric 1.0
Submit a portrait image URL and audio file URL along with the desired resolution. The service returns a task ID for async polling or webhook notification.
Create a new lip-sync video generation task
List all Veed Fabric 1.0 tasks
Get task status and results by ID
### Parameters
| Parameter | Type | Required | Default | Description |
| ------------- | -------- | -------- | ------- | ------------------------------------------------------------------------------------------------------------------- |
| `image_url` | `string` | Yes | - | URL of the portrait image to animate. Must be publicly accessible. Use a clear, front-facing photo for best results |
| `audio_url` | `string` | Yes | - | URL of the audio file for lip synchronization. Supported formats: MP3, WAV, M4A. Must be publicly accessible |
| `resolution` | `string` | Yes | - | Output video resolution: `"720p"` (1280x720) or `"480p"` (854x480) |
| `webhook_url` | `string` | No | - | HTTPS URL for task completion notification |
## Frequently Asked Questions
Veed Fabric 1.0 is an AI lip-sync API that generates realistic talking videos from a static portrait image and an audio file. You submit an image URL and audio URL via the API, receive a task ID immediately, then poll for results or receive a webhook notification when processing completes. The output is an MP4 video where the person in the image speaks in sync with the provided audio.
Veed Fabric 1.0 accepts common image formats via a publicly accessible URL. For best lip-sync results, use a clear, front-facing portrait photo where the face is fully visible and well-lit.
Veed Fabric 1.0 supports MP3, WAV, and M4A audio formats. The audio file must be hosted at a publicly accessible URL. The model analyzes speech patterns in the audio to generate matching lip movements.
Two resolutions are available: `720p` (1280x720) for production-quality output and `480p` (854x480) for drafts or faster processing. The resolution is set via the required `resolution` parameter.
Veed Fabric 1.0 prioritizes generation quality with higher fidelity lip synchronization. Veed Fabric 1.0 Fast is optimized for reduced generation time while maintaining quality lip-sync results. Choose Veed Fabric 1.0 when output quality is the priority, or Veed Fabric 1.0 Fast when speed is more important.
Rate limits vary by subscription tier. See [Rate Limits](/ratelimits) for current limits.
See the [Pricing page](/pricing) for current rates and subscription options.
## Best practices
* **Image quality**: Use well-lit, front-facing portrait photos with a clearly visible face for the most accurate lip sync
* **Audio clarity**: Clean audio with minimal background noise produces better lip-sync accuracy
* **Resolution choice**: Use `720p` for final production videos and `480p` for quick previews or prototyping
* **Production integration**: Use webhooks instead of polling for scalable applications
* **Error handling**: Implement retry logic with exponential backoff for 503 errors
## Related APIs
* **[Veed Fabric 1.0 Fast](/api-reference/lip-sync/veed-fabric-1-0-fast/overview)**: Faster lip-sync generation with optimized processing time
* **[Latent Sync](/api-reference/lip-sync/latent-sync/overview)**: Alternative lip synchronization technology
* **[Voiceover](/api-reference/voiceover/overview)**: Generate speech audio from text to use as lip-sync input
* **[Sound Effects](/api-reference/sound-effects/overview)**: Generate sound effects from text descriptions
# Veed Fabric 1.0 - Get task status
Source: https://docs.magnific.com/api-reference/lip-sync/veed-fabric-1-0/task-by-id
get /v1/ai/lip-sync/veed-fabric-1-0/{task-id}
Retrieve a specific Veed Fabric 1.0 lip-sync task by its ID, including generation status and result URL when completed.
# Veed Fabric 1.0 - List tasks
Source: https://docs.magnific.com/api-reference/lip-sync/veed-fabric-1-0/veed-fabric-1-0-tasks
get /v1/ai/lip-sync/veed-fabric-1-0
Retrieve all Veed Fabric 1.0 lip-sync tasks for the authenticated user.
# Music Generation - Generate from text
Source: https://docs.magnific.com/api-reference/music-generation/generate
post /v1/ai/music-generation
Generate original music tracks from text descriptions using AI.
Create high-quality music compositions based on your text prompts. Specify genre, mood, instruments, and tempo to get exactly the sound you need. Perfect for video production, game development, podcasts, and multimedia projects.
**Tips for effective prompts:**
- Include genre: "jazz", "electronic", "classical", "rock"
- Describe mood: "upbeat", "melancholic", "energetic", "peaceful"
- Mention instruments: "piano", "guitar", "drums", "synthesizer"
- Add tempo hints: "slow", "fast-paced", "moderate groove"
# Google Lyria - Generate music from text
Source: https://docs.magnific.com/api-reference/music-generation/google-lyria/generate
post /v1/ai/music-generation/google-lyria
Generate original 30-second music tracks from text descriptions using Google Lyria.
Create high-quality instrumental music by describing the genre, mood, instruments, and tempo you want. Ideal for video production, games, podcasts, and multimedia projects.
Each request produces a single track with a fixed duration of 30 seconds.
**Tips for effective prompts:**
- Include genre: "lo-fi hip hop", "orchestral", "synthwave", "acoustic folk"
- Describe mood: "uplifting", "melancholic", "energetic", "relaxed"
- Mention instruments: "piano", "strings", "electric guitar", "808 drums"
- Add tempo hints: "slow tempo", "upbeat", "driving rhythm"
# Google Lyria - List tasks
Source: https://docs.magnific.com/api-reference/music-generation/google-lyria/google-lyria-tasks
get /v1/ai/music-generation/google-lyria
Get the status of all Google Lyria music generation tasks
# Google Lyria API
Source: https://docs.magnific.com/api-reference/music-generation/google-lyria/overview
Generate original 30-second music tracks from text with Google Lyria. Describe genre, mood, and instruments to create instrumental audio for video, games, and ads.
Powered by Google Lyria, this API generates original instrumental music tracks from text descriptions.
Google Lyria is an AI-powered music generation API that creates original instrumental music from text descriptions. Describe the genre, mood, instruments, and tempo you want, and receive an audio track delivered as a URL. Each request produces a single track with a fixed duration of 30 seconds, making it ideal for video production, games, podcasts, and multimedia projects.
### Key capabilities
* **Text-guided generation**: describe any music style to generate (e.g., "Uplifting orchestral score with soaring strings", "Warm lo-fi hip hop beat with vinyl crackle")
* **Fixed 30-second tracks**: each request produces a single 30-second instrumental track
* **Negative prompt**: exclude unwanted instruments, styles, or moods with `negative_prompt`
* **Reproducible output**: pass a `seed` to get a consistent result for the same prompt
* **Audio URL output**: the generated track is delivered via a URL for download
* **Async processing**: webhook notifications or polling for task completion
### Use cases
* **Video production**: background music for videos and presentations
* **Game development**: custom instrumental loops for games and apps
* **Content creation**: unique music beds for podcasts, streams, and social media
* **Advertising**: original background tracks for ads
* **Film production**: temp tracks or production music for films
### Generate music with Google Lyria
Submit a text description of the music you want to create. The service returns a task ID for async polling or webhook notification.
Create a new Google Lyria music generation task
List all Google Lyria tasks
Get task status and results by ID
### Parameters
| Parameter | Type | Required | Default | Description |
| ----------------- | -------------- | -------- | ------- | -------------------------------------------------------------------------------------------------------------------- |
| `prompt` | `string` | Yes | - | Text description of the music to generate (1-2500 characters). Be specific about genre, mood, instruments, and tempo |
| `negative_prompt` | `string` | No | - | Elements to avoid in the generated track (e.g., `"vocals, distortion, dissonance"`) |
| `seed` | `integer` | No | - | Seed for reproducible generation; same prompt + seed returns a consistent result. Omit for a random seed |
| `webhook_url` | `string` (uri) | No | - | Optional callback URL that receives task status notifications |
### Prompt tips
For best results, include details about:
* **Genre**: lo-fi hip hop, orchestral, synthwave, acoustic folk, etc.
* **Mood**: uplifting, melancholic, energetic, relaxed
* **Instruments**: piano, strings, electric guitar, 808 drums, etc.
* **Tempo**: slow tempo, upbeat, driving rhythm
**Example prompts:**
* "Uplifting orchestral score with soaring strings and triumphant brass"
* "Warm lo-fi hip hop beat with vinyl crackle and mellow keys"
* "Energetic synthwave track with driving bass and retro leads"
* "Peaceful acoustic folk with fingerpicked guitar and soft strings"
## Frequently Asked Questions
Google Lyria is an AI-powered text-to-music API. You submit a text description of the music you want (genre, mood, instruments, tempo), receive a task ID immediately, then poll for results or receive a webhook notification. Each request returns a single 30-second instrumental track delivered via a URL.
Every Google Lyria request produces a single track with a fixed duration of 30 seconds. There is no duration parameter.
Google Lyria returns an audio track delivered via a URL that remains accessible for download after task completion.
Pass the same `seed` together with the same `prompt`. Identical inputs return a consistent result across requests. Omit `seed` to get a random seed on each request.
Use `negative_prompt` to describe elements to avoid, such as unwanted instruments, styles, or moods (for example `"vocals, distortion, harsh percussion"`).
Rate limits vary by subscription tier. See [Rate Limits](/ratelimits) for current limits.
See the [Pricing page](/pricing) for current rates and subscription options.
## Best practices
* **Prompt specificity**: use detailed descriptions of genre, mood, instruments, and tempo for better accuracy
* **Negative prompts**: exclude unwanted elements to steer the composition
* **Reproducibility**: fix `seed` to compare prompt variations against a stable baseline
* **Production integration**: use webhooks instead of polling for scalable applications
* **Error handling**: implement retry logic with exponential backoff for 503 errors
## Related APIs
* **Lyria 3**: text-to-music with selectable `clip` or `pro` model variants and optional reference images. See the [Lyria 3 overview](/api-reference/music-generation/lyria-3/overview).
* **[ElevenLabs Music](/api-reference/music-generation/overview)**: generate 10-240 second music tracks from text
* **[Sound Effects](/api-reference/sound-effects/overview)**: generate sound effects from text descriptions
* **[Audio Isolation](/api-reference/audio-isolation/overview)**: isolate specific sounds from audio files
# Google Lyria - Get task status
Source: https://docs.magnific.com/api-reference/music-generation/google-lyria/task-by-id
get /v1/ai/music-generation/google-lyria/{task-id}
Get the status of one Google Lyria music generation task
# Lyria 3 - Generate music from text
Source: https://docs.magnific.com/api-reference/music-generation/lyria-3/generate
post /v1/ai/music-generation/lyria-3
Generate original music tracks from text descriptions using Lyria 3, with optional image references to guide mood and style.
Describe the genre, mood, instruments, and tempo you want, and optionally attach reference images that inform the atmosphere of the composition. Ideal for video production, games, podcasts, and multimedia projects.
**Tips for effective prompts:**
- Include genre: "cinematic", "jazz", "electronic", "ambient"
- Describe mood: "dramatic", "playful", "tense", "peaceful"
- Mention instruments: "grand piano", "saxophone", "synth pads", "percussion"
- Add tempo hints: "andante", "fast-paced", "steady groove"
# Lyria 3 - List tasks
Source: https://docs.magnific.com/api-reference/music-generation/lyria-3/lyria-3-tasks
get /v1/ai/music-generation/lyria-3
Get the status of all Lyria 3 music generation tasks
# Google Lyria 3 API
Source: https://docs.magnific.com/api-reference/music-generation/lyria-3/overview
Generate original music from text with Google Lyria 3. Choose clip or pro model variants and guide the mood with optional reference images for video, games, and ads.
Powered by Google Lyria 3, this API generates original music tracks from text descriptions with selectable model variants.
Google Lyria 3 is an AI-powered music generation API that creates original music from text descriptions. Describe the genre, mood, instruments, and tempo you want, choose between the `clip` and `pro` model variants, and optionally attach reference images to inform the atmosphere of the composition. The generated track is delivered as a URL, making it ideal for video production, games, podcasts, and multimedia projects.
### Key capabilities
* **Text-guided generation**: describe any music style to generate (e.g., "Cinematic ambient track with warm synth pads and soft piano")
* **Model variants (`clip` or `pro`)**: `clip` for faster generation optimized for short clips (default), `pro` for higher-fidelity, professional-quality tracks
* **Reference images**: guide mood and style with optional reference images (PNG, JPEG, or WebP) via public URL or GCS format
* **Audio URL output**: the generated track is delivered via a URL for download
* **Async processing**: webhook notifications or polling for task completion
### Use cases
* **Video production**: background music tailored to a scene's visual mood
* **Game development**: custom soundtracks for games and apps
* **Content creation**: unique music for podcasts, streams, and social media
* **Advertising**: original background tracks and cues for ads
* **Film production**: temp tracks or production music guided by reference imagery
### Generate music with Lyria 3
Submit a text description of the music you want to create, choose a model variant, and optionally attach reference images. The service returns a task ID for async polling or webhook notification.
Create a new Lyria 3 music generation task
List all Lyria 3 tasks
Get task status and results by ID
### Parameters
| Parameter | Type | Required | Default | Description |
| ------------------ | -------------- | -------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `prompt` | `string` | Yes | - | Text description of the music to generate (10-2000 characters). Be specific about genre, mood, instruments, and tempo |
| `model` | `string` | No | `clip` | Model variant: `clip` (faster, optimized for short clips) or `pro` (higher-fidelity, professional-quality) |
| `reference_images` | `array` | No | - | Optional reference images to guide mood and style. Each entry requires `image` (public URL or GCS) and `mime_type` (`image/png`, `image/jpeg`, or `image/webp`) |
| `webhook_url` | `string` (uri) | No | - | Optional callback URL that receives task status notifications |
The `reference_images` array items have the following shape:
| Field | Type | Required | Description |
| ----------- | -------- | -------- | ---------------------------------------------------------------------------- |
| `image` | `string` | Yes | Image URL (publicly accessible URL or GCS format) |
| `mime_type` | `string` | Yes | MIME type of the reference image: `image/png`, `image/jpeg`, or `image/webp` |
### Prompt tips
For best results, include details about:
* **Genre**: cinematic, jazz, electronic, ambient, etc.
* **Mood**: dramatic, playful, tense, peaceful
* **Instruments**: grand piano, saxophone, synth pads, percussion, etc.
* **Tempo**: andante, fast-paced, steady groove
**Example prompts:**
* "Cinematic ambient track with warm synth pads, soft piano, and a gentle build"
* "Dramatic orchestral cue with rising strings and deep percussion"
* "Playful jazz trio with upright bass, brushed drums, and grand piano"
* "Tense electronic score with pulsing synths and a steady groove"
## Frequently Asked Questions
Google Lyria 3 is an AI-powered text-to-music API built on Google's Lyria music generation model. You submit a text description of the music you want, choose a model variant, and optionally attach reference images. You receive a task ID immediately, then poll for results or receive a webhook notification. The generated track is delivered via a URL.
`clip` (default) is optimized for faster generation of short clips, while `pro` produces higher-fidelity, professional-quality tracks. Select the variant with the `model` parameter.
Attach one or more entries in `reference_images` to guide the mood and style of the composition. Each entry needs a publicly accessible `image` URL (or GCS format) and its `mime_type` (`image/png`, `image/jpeg`, or `image/webp`).
Lyria 3 returns an audio track delivered via a URL that remains accessible for download after task completion.
The `prompt` must be between 10 and 2000 characters. Be specific about genre, mood, instruments, and tempo for the best results.
Rate limits vary by subscription tier. See [Rate Limits](/ratelimits) for current limits.
See the [Pricing page](/pricing) for current rates and subscription options.
## Best practices
* **Model selection**: use `clip` for fast iteration and short clips; switch to `pro` for final, professional-quality tracks
* **Reference images**: attach imagery that captures the target atmosphere to steer mood and style
* **Prompt specificity**: describe genre, mood, instruments, and tempo in detail for better accuracy
* **Production integration**: use webhooks instead of polling for scalable applications
* **Error handling**: implement retry logic with exponential backoff for 503 errors
## Related APIs
* **Google Lyria**: text-to-music that produces fixed 30-second instrumental tracks. See the [Google Lyria overview](/api-reference/music-generation/google-lyria/overview).
* **[ElevenLabs Music](/api-reference/music-generation/overview)**: generate 10-240 second music tracks from text
* **[Sound Effects](/api-reference/sound-effects/overview)**: generate sound effects from text descriptions
* **[Audio Isolation](/api-reference/audio-isolation/overview)**: isolate specific sounds from audio files
# Lyria 3 - Get task status
Source: https://docs.magnific.com/api-reference/music-generation/lyria-3/task-by-id
get /v1/ai/music-generation/lyria-3/{task-id}
Get the status of one Lyria 3 music generation task
# Music Generation - List tasks
Source: https://docs.magnific.com/api-reference/music-generation/music-generation-tasks
get /v1/ai/music-generation
Get the status of all music-generation tasks
# ElevenLabs Music API
Source: https://docs.magnific.com/api-reference/music-generation/overview
Generate original music from text with ElevenLabs Music. Create 10-240 second tracks in any genre for videos, games, and ads.
Powered by ElevenLabs technology, this API generates original music tracks from text descriptions.
ElevenLabs Music is an AI-powered music generation API that creates original music tracks from text descriptions. Describe the style, mood, instruments, and tempo you want, and receive a high-quality MP3 audio file. The API supports customizable track durations from 10 seconds to 4 minutes, with typical generation times of 30-90 seconds.
### Key capabilities
* **Text-guided generation**: Describe any music style to generate (e.g., "Upbeat jazz with piano and drums", "Cinematic orchestral soundtrack")
* **Customizable duration**: Generate tracks from 10 seconds to 240 seconds (4 minutes)
* **High-quality output**: Professional-grade MP3 audio files suitable for production use
* **Genre flexibility**: Support for any music genre, style, or mood
* **Async processing**: Webhook notifications or polling for task completion
### Use cases
* **Video production**: Create background music for videos and presentations
* **Game development**: Generate custom soundtracks for games and apps
* **Content creation**: Produce unique music for podcasts, streams, and social media
* **Advertising**: Create original jingles and background tracks for ads
* **Film production**: Generate temp tracks or production music for films
### Generate music with ElevenLabs
Submit a text description of the music you want to create along with the desired duration. The service returns a task ID for async polling or webhook notification.
Create a new music generation task
List all music generation tasks
Get task status and results by ID
### Parameters
| Parameter | Type | Required | Default | Description |
| ---------------------- | --------- | -------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `prompt` | `string` | Yes | - | Text description of the music to generate (e.g., "Upbeat jazz with piano", "Melancholic piano ballad") |
| `music_length_seconds` | `integer` | Yes | - | Duration of the generated track in seconds (10-240) |
| `webhook_url` | `string` | No | - | HTTPS URL for task completion notification |
### Prompt tips
For best results, include details about:
* **Genre**: jazz, electronic, classical, rock, ambient, etc.
* **Mood**: upbeat, melancholic, energetic, peaceful, dramatic
* **Instruments**: piano, guitar, drums, synthesizer, strings, etc.
* **Tempo**: slow, moderate, fast-paced, groove
**Example prompts:**
* "A Blues guitar solo with emotional bends and slides"
* "Upbeat electronic dance music with synthesizers and heavy bass"
* "Peaceful ambient piano with gentle strings in the background"
* "Cinematic orchestral piece building to an epic climax"
* "Modern corporate background music with light piano and subtle electronic elements"
## Frequently Asked Questions
ElevenLabs Music is an AI-powered text-to-music API. You submit a text description of the music you want (genre, mood, instruments, tempo) along with the desired duration, receive a task ID immediately, then poll for results or receive a webhook notification. The output is a high-quality MP3 audio file.
You can generate music tracks from 10 seconds (minimum) to 240 seconds / 4 minutes (maximum). The duration is specified in the `music_length_seconds` parameter.
Be specific about genre, mood, instruments, and tempo. Good examples: "Upbeat jazz with piano and brushed drums", "Melancholic acoustic guitar ballad", "Epic orchestral soundtrack with building tension". Avoid vague prompts like just "music" or "song".
ElevenLabs Music outputs MP3 audio files at professional quality. The generated audio is delivered via a URL that remains accessible for download after task completion.
Generation typically takes 30-90 seconds depending on track duration. Shorter tracks (10-30 seconds) usually complete in under a minute, while maximum-length tracks (4 minutes) may take 1-2 minutes. For production workflows, use webhooks for efficient notification.
Rate limits vary by subscription tier. See [Rate Limits](/ratelimits) for current limits.
See the [Pricing page](/pricing) for current rates and subscription options.
## Best practices
* **Prompt specificity**: Use detailed descriptions for better generation accuracy
* **Duration planning**: Consider your use case when selecting track length
* **Genre mixing**: Combine styles for unique results (e.g., "jazz-influenced electronic")
* **Production integration**: Use webhooks instead of polling for scalable applications
* **Error handling**: Implement retry logic with exponential backoff for 503 errors
## Related APIs
* **[Sound Effects](/api-reference/sound-effects/post-sound-effects)**: Generate sound effects from text descriptions
* **[Audio Isolation](/api-reference/audio-isolation/overview)**: Isolate specific sounds from audio files
* **[Lip Sync](/api-reference/lip-sync/latent-sync/overview)**: Synchronize lip movements to audio tracks
* **[OmniHuman 1.5](/api-reference/video/omni-human-1-5)**: Generate human animations driven by audio
# Music Generation - Get task status
Source: https://docs.magnific.com/api-reference/music-generation/task-by-id
get /v1/ai/music-generation/{task-id}
Get the status of one music-generation task
# Download music
Source: https://docs.magnific.com/api-reference/music/download-music
get /v1/music/{music-id}/download
Get a direct download URL for a music audio file. Returns the music ID, title, and a CDN-hosted download link.
Get a direct download URL for a music audio file. See the [Music API overview](/api-reference/music/overview) for authentication and usage guidance.
# Get detailed music information by ID
Source: https://docs.magnific.com/api-reference/music/get-music-by-id
get /v1/music/{music-id}
Retrieve full details for a music item including artist biography, genre and mood metadata, popularity score, and download statistics.
Retrieve full details for a music item including artist biography, genre and mood metadata, popularity score, and download statistics. See the [Music API overview](/api-reference/music/overview) for authentication and usage guidance.
# Magnific Music API
Source: https://docs.magnific.com/api-reference/music/overview
Search, filter, and download royalty-free music from the Magnific Music catalog via the Magnific API.
The Magnific Music API gives you programmatic access to the Magnific Music catalog. Search music by keyword, filter by genre and mood, and download audio files for use in your applications.
### What you can do
* Search music with full-text queries across titles and tags
* Filter by genre, mood, premium status, and creation date
* Sort results by relevance, popularity, creation date, duration, or tempo
* Get detailed music metadata including artist biography, download stats, and playlist count
* Download music audio files via CDN-hosted URLs
### Authentication
All requests require an API key via the `x-magnific-api-key` header. See the [Quickstart](/quickstart) and [Authentication](/authentication).
### Endpoints
Search and filter music
Get detailed music information by ID
Download a music audio file
### Parameters overview
The search endpoint supports the following filters:
| Parameter | Type | Description |
| ----------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `q` | `string` | Full-text search across titles and tags |
| `genre` | `string` | Filter by genre name, comma-separated (e.g., `"Electronic,Ambient"`) |
| `mood` | `string` | Filter by mood tag, comma-separated (e.g., `"Happy,Energetic"`) |
| `include-premium` | `boolean` | Include premium content (default: `false`) |
| `time_range` | `string` | Filter by creation date: `"7d"`, `"30d"`, or `"90d"` |
| `order_by` | `string` | Sort order: `"relevance"`, `"popularity"`, `"-popularity"`, `"created_at"`, `"-created_at"`, `"title"`, `"-title"`, `"seconds"`, `"-seconds"`, `"bpm"`, `"-bpm"`. Defaults to `"relevance"` when `q` is provided, `"-popularity"` otherwise |
| `limit` | `integer` | Results per page: 1-1000 (default: `10`) |
| `offset` | `integer` | Pagination offset (default: `0`) |
### Use cases
* Build a music browser or audio picker into your app or CMS
* Search music by genre and mood for video or podcast background music
* Programmatically download royalty-free music during content production pipelines
* Create curated playlists filtered by popularity, tempo, or release date
### FAQ
#### Is there a rate limit?
Yes. See [Rate limits](/ratelimits).
#### What license applies to the music?
Refer to the [License agreement](https://www.magnific.com/legal/terms-of-use#api-services).
#### What audio format is the music available in?
Music is delivered as audio files via CDN-hosted download URLs.
#### Can I filter for only free music?
Yes. Set `include-premium` to `false` (the default) to return only free music.
# Search and filter music
Source: https://docs.magnific.com/api-reference/music/search-music
get /v1/music
Search the Magnific Music catalog. Filter by genre, mood, artist, premium status, and creation date range. Returns paginated results sorted by popularity by default.
Use the Magnific Music API to search and filter music by genre, mood, artist, and more. See the [Music API overview](/api-reference/music/overview) for authentication and usage guidance.
# Get loras
Source: https://docs.magnific.com/api-reference/mystic/get-loras
get /v1/ai/loras
# Mystic - List tasks
Source: https://docs.magnific.com/api-reference/mystic/get-mystic
get /v1/ai/mystic
Get the status of all Mystic tasks
# Mystic - Get task status
Source: https://docs.magnific.com/api-reference/mystic/get-mystic-task
get /v1/ai/mystic/{task-id}
Get the status of the Mystic task
# Magnific Mystic API
Source: https://docs.magnific.com/api-reference/mystic/mystic
Photorealistic AI image generator with LoRA styles and characters. Generate production-ready 1K, 2K, and 4K images for marketing, e-commerce, and creative projects.
Generate photorealistic images in 1K/2K/4K with LoRA styles and characters.
Mystic AI image generation is a cutting-edge tool that produces stunningly realistic, high-resolution images. With options for 1K, 2K and 4K resolution, Mystic delivers sharp, detailed visuals that rival professional photography. From intricate facial features to complex textures, every element is rendered with exceptional clarity and precision.
### Stunning 1K, 2K and 4K quality
Enjoy razor-sharp 1K, 2K and 4K resolution with Magnific Mystic. Generate high-definition images with zero effort—no extra steps or upscaling needed. Just describe your vision, and Mystic will create beautifully detailed visuals ready for any project, from web design to large-format printing.
### Effortless creation
Transform your text descriptions into impressive, realistic results with custom parameters. Whether you need faces, hands, or text, everything is pixel-perfect and photo-realistic. Our state-of-the-art AI technology ensures that every generated image meets professional standards without requiring additional editing.
### Versatile applications
Perfect for a wide range of uses, including:
* Marketing materials that demand visual impact
* E-commerce product showcases with lifelike detail
* High-quality illustrations for publications
* Concept art for film and game development
* And much more!
With Mystic AI, you're equipped to create visuals that captivate and convince, all at the click of a button.
Generate an image using Mystic
Get the status of a Mystic image generation task
Get a list of all Mystic image generation tasks, including their statuses and details.
Returns a curated list of available LoRAs (Low-Rank Adaptation) for Mystic image generation.
### Image Reference Best Practices
When using `structure_reference` or `style_reference` images, how you send them matters:
| Action | Quality Impact |
| ------------------------------------------ | -------------------------- |
| Send URL of original image | ✅ Maximum quality |
| Send base64 of original file read directly | ✅ Maximum quality |
| Use `canvas.toDataURL('image/jpeg')` | ❌ \~8% quality loss |
| Use `canvas.toDataURL('image/jpeg', 0.8)` | ❌ \~20% quality loss |
| Resize image before sending | ❌ Significant quality loss |
| Convert PNG → JPEG before sending | ❌ Quality loss |
**Recommended:** Send reference images via URL whenever possible. Higher quality reference images produce better style and structure transfers.
### Frequently Asked Questions
Magnific Mystic generates images in three resolution tiers: 1K (1024px), 2K (2048px), and 4K (4096px). Higher resolutions deliver more detail and are ideal for print or large-format displays.
LoRAs (Low-Rank Adaptations) are style and character presets that customize Mystic's output. Use the GET /v1/ai/loras endpoint to retrieve available LoRAs, then include the LoRA ID in your generation request to apply specific styles or characters.
Generation time depends on resolution: 1K images typically complete in 10-20 seconds, 2K in 20-40 seconds, and 4K in 40-90 seconds. Use webhooks for efficient notification of task completion.
Mystic outputs high-quality PNG images. The generated image is delivered via a URL that remains accessible for download after task completion.
Rate limits vary by subscription tier. See [Rate Limits](/ratelimits) for current limits.
See the [Pricing page](/pricing) for current rates and subscription options.
# LoRAs training for custom characters
Source: https://docs.magnific.com/api-reference/mystic/post-loras-characters
post /v1/ai/loras/characters
Create you own custom character using LoRAs training
For now you can check the status of the training calling `v1/ai/loras`. We are working on it
# Mystic LoRA Styles - Train custom style
Source: https://docs.magnific.com/api-reference/mystic/post-loras-styles
post /v1/ai/loras/styles
Create you own custom style using LoRAs training
For now you can check the status of the training calling `v1/ai/loras`. We are working on it
# Mystic - Create image from text
Source: https://docs.magnific.com/api-reference/mystic/post-mystic
post /v1/ai/mystic
Convert descriptive text input into images using AI. This endpoint accepts a variety of parameters to customize the generated images.
## Important
Mystic image generation mode is Magnific's exclusive advanced AI workflow for ultra-realistic, high-resolution images.
Make sure you get your webhook set up on every request in order to retrieve your generations.
# Happy Horse 1.1 - Create video from reference images
Source: https://docs.magnific.com/api-reference/reference-to-video/happy-horse-1-1/generate
post /v1/ai/reference-to-video/happy-horse-1-1
Generate a high-quality AI video guided by 1 to 9 reference images that define characters, objects or scenes using Happy Horse 1.1, Alibaba's reference-to-video model.
**How to use references:**
- Provide 1 to 9 reference images via `image_urls`
- Reference each image in the prompt by its 1-based positional index (`character1`, `character2`, ...)
- The order of `image_urls` matches the character index in the prompt
**Key features:**
- 720P and 1080P resolution support
- 9 aspect ratio options
- Duration range: 3-15 seconds
- Optional bottom-right "Happy Horse" watermark
- Prompt up to 5000 characters
`image_urls` is an array of **objects**, each with a `url` field — not an array of plain strings. Passing strings returns `400 Bad Request`.
**Example request body**
```json theme={null}
{
"prompt": "character1 and character2 walk together through a sunlit forest path",
"image_urls": [
{ "url": "https://example.com/character1.jpg" },
{ "url": "https://example.com/character2.jpg" }
],
"aspect_ratio": "16:9",
"resolution": "1080P",
"duration": 5
}
```
The array position sets the character index used in the prompt: the 1st item is `character1`, the 2nd is `character2`, and so on up to `character9`.
# Happy Horse 1.1 R2V - List tasks
Source: https://docs.magnific.com/api-reference/reference-to-video/happy-horse-1-1/happy-horse-1-1-r2v-tasks
get /v1/ai/reference-to-video/happy-horse-1-1
Retrieve the list of all Happy Horse 1.1 reference-to-video tasks for the authenticated user.
# Happy Horse 1.1 Reference To Video API
Source: https://docs.magnific.com/api-reference/reference-to-video/happy-horse-1-1/overview
Generate AI videos from up to 9 reference images with Happy Horse 1.1. Reference characters as character1..character9 in the prompt. 720P/1080P, 9 aspect ratios.
Happy Horse 1.1 Reference-to-Video generates videos from up to 9 reference images, preserving character identity across scenes. Reference each image in the prompt with `character1`..`character9` tokens.
Happy Horse 1.1 Reference-to-Video is an AI video generation API that creates MP4 videos guided by 1 to 9 reference images defining characters, objects, or scenes. Built by Alibaba ATH (Taotian Innovation Unit, led by Zhang Di), the model maintains visual identity across the generated video. You reference each image in the prompt by its 1-based positional index (`character1`, `character2`, ..., up to `character9`). Output is available at 720P (1280x720) or 1080P (1920x1080) with durations from 3 to 15 seconds.
### Key capabilities
* **State-of-the-art quality**: Latest iteration of the Alibaba ATH Happy Horse video family
* **Up to 9 reference images**: Rich multi-character scenes from a single request
* **Indexed prompt references**: Use `character1`..`character9` tokens in the prompt to place each reference
* **9 aspect ratios**: `16:9`, `9:16`, `1:1`, `4:3`, `3:4`, `21:9`, `9:21`, `5:4`, `4:5`
* **Resolution options**: 720P (1280x720) and 1080P (1920x1080) output
* **Flexible durations**: 3 to 15 seconds of video output (default 5 seconds)
* **Optional watermark**: Bottom-right "Happy Horse" text watermark, off by default
* **Long prompts**: Up to 5000 characters describing scene, motion, and character interactions
* **Async processing**: Webhook notifications or polling for task completion
### How character references work
1. Provide 1 to 9 character images in the `image_urls` array (JPEG/JPG/PNG/WEBP, shortest side 400 px+ recommended, max 10 MB each)
2. The 1st item in the array is `character1`, the 2nd is `character2`, ..., up to `character9`
3. In the `prompt`, reference characters by these tokens to place them in the scene
4. Combine multiple references for multi-character scenes (e.g. "character1 and character2 share a meal")
**Example prompt:**
> "character1 and character2 walk together through a sunlit forest path, golden hour lighting"
### Use cases
* **Multi-character narratives**: Create scenes with up to 9 distinct characters interacting
* **Branded content**: Maintain consistent mascot, spokesperson, or brand identity across video campaigns
* **Episodic content**: Reuse the same characters across multiple videos for series or storytelling
* **Game cinematics**: Generate cutscenes featuring specific character designs
* **Marketing campaigns**: Place product imagery (`character1` = product) into varied scene contexts
* **Storyboarding**: Pre-visualize scenes with reference characters before live production
### API operations
Generate videos by submitting reference images and a prompt to the API. The service returns a task ID for async polling or webhook notification.
Create a new reference-to-video generation task
List all Happy Horse 1.1 R2V tasks with status
Get task status and results by ID