Magnific AI Upscaler Guide: Creative vs Precision, sliders, and API

A 900px draft that needs to be a crisp 1920px cover is the usual trigger for reaching for Magnific. The tool is an AI upscaler with two distinct modes: one that invents plausible detail, and one that scales faithfully without touching content. Confusing the two is how a byline photo gets an extra tooth or a screenshot’s command line turns into soup.

Creative vs. Precision: pick the mode first

Magnific’s own docs split the upscaler into two engines with opposite philosophies, and that split matters more than any single slider. Creative mode reimagines textures and adds detail that may never have existed in the source — results that go beyond interpolation. Precision mode enhances resolution and sharpness without creative interpretation. Creative caps at 4x scale / 4096px; Precision goes to 16x / 16384px.

Decide before you touch a slider:

• Product shot, portrait, screenshot, or anything with text, a logo, or a known face that must stay exact → Precision.
• Low-res AI art, an illustration, or a shot where invented texture is a win → Creative.

In Spaces (Magnific’s node-based builder), add an Image Upscaler node, connect an image, and pick the mode. The card then shows the scale (2x, 4x, 8x, or 16x depending on mode) and, for Creative only, an optional prompt describing the image.

The Creative-mode controls

• Models: Magnific (richer detail, larger output), Classic (faster, preset-driven), or Automatic.
• Engines: Illusio (illustrations, cartoon art, artistic flair), Sharpy (sharp edges, maximum clarity), Sparkle (photographs, natural enhancement), Automatic (analyzes the image and picks for you).
• Presets: Subtle (minimal change, stays close to source), Vivid (balanced improvement), Wild (reconstructs missing detail, adds interpretation), Custom (manual sliders).
• Sliders, -10 to +10: Creativity — negative is conservative, positive is imaginative. Resemblance — negative gives the model freedom, positive keeps it faithful. HDR — higher values give a more dramatic tonal range. Fractality — density of fractal-like detail added per area.
• Optimized For: a 13-category picker — Standard Ultra, Portrait Soft, Portrait Hard, Landscape, Photography, Sci-Fi, 3D Renders, Video Games, Films, Illustrations, Art, Horror, Anime — that steers the enhancement toward what the image contains.
• Prompt: a short, factual description of the content. A quick pass through the ChatGPT prompting cheat sheet helps here — describe what’s literally in the frame, not a style brief.

The Precision-mode controls

Precision trades all of the above for three numeric sliders, 0–100: Sharpness (edge enhancement), Grain (raise to add film grain, lower to reduce it), Ultra Detail (fine-detail level). It also offers four models — Ultra Sublime (product/archival fidelity), Ultra Photo (portraits, skin), Ultra Denoiser (noisy or low-light sources), Ultra (general purpose, fastest) — and three presets: Balanced, Portraits, Grainy Analog. There is no prompt field, because the mode’s entire point is not reinterpreting content.

A repeatable workflow for covers, thumbnails, and product shots

1. Decide the mode first, using the rule above. A cover generated by an image model at 1K usually has no real text yet, so Creative is fine. A thumbnail that already has a face and headline baked in should go through Precision, or get its text added after a Creative pass.
2. Source the highest resolution you reasonably can. Upscaling recovers sharpness and adds plausible detail; it does not recover information that was never captured.
3. Start on a preset, not raw sliders. Subtle for anything with a recognizable subject, Wild only for pure texture or art. Move to Custom once you know which direction to push.
4. For faces, logos, or any subject that must stay exact: negative Creativity, positive Resemblance, modest HDR and Fractality. The docs describe these as the exact opposite ends of the same tradeoff, so pushing both toward “faithful” is a deliberate, documented choice, not a guess.
5. Add text, captions, and watermarks last, in your design tool, after the upscale. Baked-in type gets treated as raw pixels by the Creative engine, same as everything else.
6. Check faces and any readable text at 100% zoom before shipping. A thumbnail-sized preview hides exactly the artifacts that matter at full size.

For a video series, this slots in right after you’ve exported a frame from an avatar clip built with the workflow in the HeyGen avatar video guide — the frame is just another source image for an upscale pass before it ships to a video platform.

When not to use Magnific

Skip the upscaler, or at least skip Creative mode, for:

• Text-heavy screenshots. Terminal output, code, and UI chrome have exact characters an AI model has no reason to preserve precisely; even Precision can soften thin monospace strokes at high scale.
• Diagrams and charts. Lines, labels, and arrows are information, not texture. A model built to add plausible detail can turn an arrow into something that looks fine and is wrong.
• Anything a reader needs to trust pixel-for-pixel, like a dashboard screenshot used as evidence. Don’t run proof through a generative pass.

If a pipeline needs to pick a mode per image automatically, that’s one if statement — does this image contain real text or a known face, yes or no — the kind of small decision logic covered conceptually in what is agentic AI.

Scripting it: the API and an open-source alternative

Both endpoints sit under api.magnific.com, authenticated with x-magnific-api-key:

curl -X POST "https://api.magnific.com/v1/ai/image-upscaler" \
  --header 'Content-Type: application/json' \
  --header 'x-magnific-api-key: <your-key>' \
  --data '{
    "image": "<base64-encoded-image>",
    "scale_factor": "4x",
    "optimized_for": "films_n_photography",
    "creativity": -3,
    "hdr": 2,
    "resemblance": 3,
    "fractality": 3,
    "engine": "magnific_sparkle"
  }'

That’s Creative, matching the slider names above plus scale_factor, optimized_for, and engine. The Precision endpoint, /v1/ai/image-upscaler-precision, is a separate call with sharpen, smart_grain, and ultra_detail (0–100, defaults 50 / 7 / 30) and a filter_nsfw boolean. Its documented response returns a task_id and a status (CREATED in the example) — it’s async, so poll with the task id or set webhook_url instead.

If you’d rather not depend on an external API, Real-ESRGAN is a verifiable open-source option. The maintained GitHub repo (xinntao/Real-ESRGAN) ships inference_realesrgan.py:

python inference_realesrgan.py -n RealESRGAN_x4plus -i input.jpg -o results --face_enhance

-n selects the model (RealESRGAN_x4plus is the general-purpose default), -o sets the output folder, --tile 400 chunks large images to avoid GPU out-of-memory errors, and --face_enhance runs GFPGAN on detected faces. A portable NCNN build (realesrgan-ncnn-vulkan) needs no CUDA or PyTorch install and takes the same -n/-s/-t flags from the command line — a practical path for a CI box with no Python environment. No cloud dependency, no per-image cost beyond your own compute, at the price of running inference yourself.

Pitfalls

• Batch-processing a product catalog through Creative “because it looked fine on one test image.” Creative’s value is reimagining detail; at scale that means a slightly different interpretation per photo, which reads as inconsistency across a catalog. Use Precision for anything that must look like the same product line.
• Cranking Fractality and HDR together on a face. Both add density and tonal punch; stacked on a portrait they produce the over-sharpened, slightly uncanny look people call “AI skin.”
• Treating the prompt field as optional. A one-line factual description measurably helps Creative’s engine selection — it’s a hint, not decoration.
• Forgetting Precision has no prompt field. If a pipeline always sends a prompt string, make sure it’s dropped, not silently ignored with an error, on Precision calls.
• Assuming the Precision response is synchronous. The documented shape is task_id + status; code that expects an image back in the same response will break the first time a job takes longer than usual.
• Upscaling a screenshot or diagram without deciding the mode first. This is the single most common way a sharp cover photo ships with a melted command prompt.

FAQ

What does the Magnific AI upscaler actually do to an image?

It does more than resize. In Creative mode it is powered by Magnific’s own model and can reimagine texture and add detail that was never in the source pixels. In Precision mode it is powered by Clarity and scales faithfully without reinterpreting the content, per Magnific’s own image-models documentation.

What is the difference between Magnific’s Creative and Precision upscaling modes?

Creative tops out at 4x (4096px), supports a text prompt, and uses AI engines named Illusio, Sharpy, and Sparkle to add generative detail. Precision tops out at 16x (16384px), has no prompt field, and uses four faithfulness-focused models (Ultra Sublime, Ultra Photo, Ultra Denoiser, Ultra). Pick Precision whenever you cannot afford invented detail.

Which Magnific settings keep faces and on-image text from warping?

In Creative mode, push Creativity toward negative, push Resemblance toward positive, and keep Fractality and HDR modest; the official docs state negative Creativity means conservative output and positive Resemblance means closer to the original. For anything with real words baked into the image, use Precision mode instead, since it does not reinterpret content.

Does Magnific have an API for upscaling images programmatically?

Yes. The Creative endpoint is a POST to https://api.magnific.com/v1/ai/image-upscaler with an x-magnific-api-key header and fields including image, scale_factor, creativity, hdr, resemblance, fractality, and engine. A separate Precision endpoint, /v1/ai/image-upscaler-precision, takes sharpen, smart_grain, ultra_detail, and filter_nsfw, and returns a task_id and status for async polling.

What is an open-source alternative to Magnific for scripted upscaling?

Real-ESRGAN (xinntao/Real-ESRGAN on GitHub) is a maintained, self-hosted option. The Python script inference_realesrgan.py takes -n for model name (RealESRGAN_x4plus is the general-purpose default), -s/–outscale for the target scale, –tile to avoid out-of-memory errors, and –face_enhance to run GFPGAN on faces. A portable NCNN build needs no CUDA or PyTorch install.