iApp Image Upscaler
iApp Image Upscaler enlarges an image 2x or 4x and reconstructs the detail that a plain resize cannot: edges stay crisp, textures such as hair, fabric, foliage and lettering are rebuilt instead of blurred, and JPEG artefacts in the source are cleaned up on the way. It is built for e-commerce product photos, print material prepared from web-sized originals, old or low-resolution photographs, thumbnails that must be shown large, and illustrations. A 1024 x 1024 photo becomes 4096 x 4096 in 1.0 second on the production service; the output is limited to 16.8 megapixels (4096 x 4096), which covers A3 print at 300 dpi.
Live Demo
Upload a JPEG, PNG or WebP (up to 10 MB), or pick one of the small example images, choose 2x or 4x and press Upscale. The result appears in a before-and-after view: drag the handle to compare.
Request as cURL
curl -X POST 'https://api.iapp.co.th/v3/store/image-generation/image-upscaler/upscale' \ -H 'apikey: YOUR_API_KEY' \ -F 'file=@photo.jpg' \ -F 'scale=4' -F 'model=photo' -F 'output_format=png'
Examples
Each pair below is a 300 x 300 crop from a 256-pixel source enlarged 4x to 1024 pixels. Left: plain bicubic resize. Right: iApp Image Upscaler, photo model (illustration model for the last pair). Source images are from the iApp Image Generation gallery; outputs are unretouched.
Quick Start
You need an API key from the iApp AI Portal. Send the image as a multipart form with the apikey header:
curl -X POST https://api.iapp.co.th/v3/store/image-generation/image-upscaler/upscale \
-H "apikey: YOUR_API_KEY" \
-F "file=@product.jpg" \
-F "scale=4" \
-F "output_format=png"
{
"status": "success",
"model": "photo",
"scale": 4,
"input": { "width": 800, "height": 800 },
"width": 3200,
"height": 3200,
"mime_type": "image/png",
"bytes": 9871234,
"image_base64": "iVBORw0KGgoAAAANSUhEUgAADIAAAAyACAIAAAB...",
"time": { "model": 0.61, "total": 1.42 },
"iapp": { "images": 1, "version": "1.0.0-20260907" }
}
Add -F "response=image" to receive the image bytes directly instead of JSON. Code examples for Python and JavaScript are in the Technical Reference.
Endpoints and Pricing
| Endpoint | Description | Price |
|---|---|---|
POST /v3/store/image-generation/image-upscaler/upscale | Enlarge one image 2x or 4x | 1 IC per image |
GET /v3/store/image-generation/image-upscaler/models | List the available models and limits | Free |
One image costs 1 IC whatever its size or scale, as long as the output stays within 16.8 megapixels (4096 x 4096). Only successful responses are charged; rejected or failed requests are free.
Performance
Measured on the production GPU on 7 September 2026, one request at a time, photo model, median of 5 runs. Model time is the enlargement itself; encoding is the time to produce the returned file and depends on the format you ask for.
| Input | Scale | Output | Model time | PNG encode | JPEG encode |
|---|---|---|---|---|---|
| 512 x 512 | 4x | 2048 x 2048 | 0.23 s | 0.34 s | 0.05 s |
| 1024 x 1024 | 4x | 4096 x 4096 | 0.98 s | 1.37 s | 0.18 s |
| 1920 x 1080 | 2x | 3840 x 2160 | 0.41 s | 0.61 s | 0.08 s |
| 2048 x 2048 | 2x | 4096 x 4096 | 0.78 s | 1.27 s | 0.18 s |
| Metric | Value |
|---|---|
| Illustration model, 1024 x 1024 to 4096 x 4096 | 0.32 s |
| Fast model, 1024 x 1024 to 4096 x 4096 | 0.06 s |
| Serving capacity | about 1,500 images per hour at the largest output as PNG, about 3,000 per hour as JPEG, on one GPU; requests beyond that wait in a first-come queue |
| Input | JPEG, PNG or WebP, up to 10 MB and 16.8 megapixels; transparency is preserved |
| Output | PNG (default), JPEG or WebP, up to 16.8 megapixels (4096 x 4096): at 4x the input may be up to 1024 x 1024, at 2x up to 2048 x 2048 |
| Rate limits (per API key) | 5 per second, 60 per minute, 1,200 per hour |
A 4096 x 4096 PNG of a photograph is typically 10 to 20 MB; the same image as JPEG at the default quality of 92 is 1 to 3 MB. Ask for output_format=jpeg or webp when file size or transfer time matters more than lossless output.
Output Quality
The upscaler is a learned model that reconstructs plausible detail. It is measured against plain bicubic resizing on the 29 images of the iApp Image Generation gallery (900 x 540), each reduced 4x with a Lanczos filter and enlarged back to the original size (7 September 2026, photo model):
| Metric (versus the original) | Bicubic resize | iApp Image Upscaler |
|---|---|---|
| LPIPS perceptual distance, lower is better | 0.284 | 0.159 |
| Images where the upscaler is closer to the original (LPIPS) | 29 of 29 | |
| PSNR, higher is better | 27.2 dB | 25.7 dB |
The two rows point in opposite directions on purpose. LPIPS measures how close the result looks to the original to a human observer; PSNR rewards the safe, blurred average that a resize produces. Reconstructing texture always costs a little PSNR; judge the service by the examples above and by your own images in the demo.
Two limits apply:
- Fine detail that is not present in the source is invented, not recovered: a face or a line of small text at 40 pixels will come out sharp but not necessarily identical to the real person or the real text. Do not use the output as evidence of what a low-resolution source showed.
- Heavily compressed or blurred sources are cleaned up, but motion blur and out-of-focus areas stay soft.
Data Security and Compliance
- The service is GDPR and PDPA compliant.
- Images are processed in memory and returned in the response; nothing is written to disk and nothing is retained after the response is sent.
- The model runs on iApp-operated GPU infrastructure in Thailand; no image is sent to a third-party provider.
Technical Reference
Request
POST /v3/store/image-generation/image-upscaler/upscale accepts multipart/form-data with the apikey header.
| Field | Type | Required | Description |
|---|---|---|---|
file | file | Yes, or image_base64 | The image: JPEG, PNG or WebP, up to 10 MB and 16.8 megapixels. EXIF orientation is applied; transparency is preserved. |
image_base64 | string | No | Alternative to file: the image as base64 (a data: URL prefix is accepted). |
scale | integer | No | 4 (default) or 2. |
model | string | No | photo (default) for photographs and general images, anime for illustrations, anime and flat artwork, fast for a lighter model when throughput matters more than detail. |
output_format | string | No | png (default, lossless), jpeg or webp. |
quality | integer | No | 1 to 100 for jpeg and webp, default 92. |
response | string | No | json (default) returns the JSON below with the image as base64; image returns the image bytes with the matching Content-Type. |
Every successful response carries the headers iapp-input-images: 1 and x-iapp-output-size (for example 4096x4096).
Response
{
"status": "success",
"model": "photo",
"scale": 4,
"input": { "width": 1024, "height": 1024 },
"width": 4096,
"height": 4096,
"mime_type": "image/png",
"bytes": 16523871,
"image_base64": "...",
"time": { "model": 0.98, "total": 2.41 },
"iapp": { "images": 1, "version": "1.0.0-20260907" }
}
time.model is the enlargement; time.total includes decoding the upload and encoding the result.
Errors
| HTTP status | error_code | Meaning |
|---|---|---|
| 400 | invalid_image | The file is not a readable JPEG, PNG or WebP |
| 400 | input_too_large | The input exceeds 16.8 megapixels |
| 400 | output_too_large | Input x scale would exceed 16.8 megapixels; the message states the largest input for that scale. Use scale=2 or a smaller image |
| 400 | invalid_scale, invalid_model, invalid_output_format | A field has a value outside the table above |
| 401 | Missing or invalid apikey | |
| 402 | Insufficient credits | |
| 413 | file_too_large | The upload exceeds 10 MB |
| 429 | Rate limit exceeded for this API key | |
| 503 | starting | The service is starting; retry after 30 seconds |
Errors are not charged.
Code Examples
- cURL
- Python
- JavaScript
# JSON response, image saved from the base64 field
curl -X POST https://api.iapp.co.th/v3/store/image-generation/image-upscaler/upscale \
-H "apikey: YOUR_API_KEY" \
-F "file=@photo.jpg" -F "scale=4" -F "output_format=png" \
| python3 -c "import sys, json, base64; r = json.load(sys.stdin); open('photo-4x.png', 'wb').write(base64.b64decode(r['image_base64'])); print(r['width'], r['height'], r['time'])"
# or the image bytes directly
curl -X POST https://api.iapp.co.th/v3/store/image-generation/image-upscaler/upscale \
-H "apikey: YOUR_API_KEY" \
-F "file=@photo.jpg" -F "scale=2" -F "output_format=jpeg" -F "response=image" \
-o photo-2x.jpg
import base64
import requests
url = "https://api.iapp.co.th/v3/store/image-generation/image-upscaler/upscale"
with open("photo.jpg", "rb") as f:
response = requests.post(
url,
headers={"apikey": "YOUR_API_KEY"},
files={"file": ("photo.jpg", f, "image/jpeg")},
data={"scale": 4, "model": "photo", "output_format": "png"},
timeout=120,
)
response.raise_for_status()
result = response.json()
with open("photo-4x.png", "wb") as out:
out.write(base64.b64decode(result["image_base64"]))
print(result["width"], result["height"], result["time"])
// Browser: fileInput is an <input type="file">
const form = new FormData();
form.append("file", fileInput.files[0]);
form.append("scale", "4");
form.append("output_format", "webp");
const response = await fetch("https://api.iapp.co.th/v3/store/image-generation/image-upscaler/upscale", {
method: "POST",
headers: { "apikey": "YOUR_API_KEY" },
body: form,
});
const result = await response.json();
const img = document.createElement("img");
img.src = `data:${result.mime_type};base64,${result.image_base64}`;
document.body.appendChild(img);
Changelog
| Version | Date | Change |
|---|---|---|
| v1.0.0-20260907 | 7 Sep 2026 | First release: 2x and 4x enlargement with photo, illustration and fast models; PNG, JPEG and WebP output; transparency preserved; output up to 16.8 megapixels. 1 IC per image. |