Resolution scale calculator
Multiply a frame by any factor and get its new size: 1920 by 1080 at a scale of 2 becomes 3840 by 2160, the 4K UHD frame, with even dimensions ready for encoders. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Width
- 1,920
- Height
- 1,080
- Scale
- 2
- Original width
- 1,920
- Original height
- 1,080
- New width
- 3,840
- New height
- 2,160
Scaling a video resolution is the arithmetic step that comes before you pick an encoder preset or a social canvas: you know the original pixel width and height, you know a scale factor such as 2 for a 4K upsample or 0.5 for a half-size proxy, and you need the new integer width and height those numbers imply. This resolution scale calculator multiplies both axes by the same positive factor so the aspect ratio is preserved, rounds each side to the nearest pixel, and also reports the nearest even dimensions that H.264 and H.265 encoders typically require.
How a scale factor turns one resolution into another
A video frame is a grid of integer pixels. Scaling that grid by a factor s means every stored sample maps to a new sample count of round(width × s) by round(height × s). When s is 2, 1920×1080 becomes 3840×2160, the 4K UHD raster people mean when they say double 1080p.
When s is 0.5, the same master becomes a 960×540 proxy that still has the same 16:9 picture. The scale is applied uniformly on both axes so the aspect ratio does not change; stretching width independently of height is a different job, a resize into a target box or a social crop, not a resolution scale. Because encoders cannot emit a fraction of a pixel, the product is rounded to the nearest integer on each side.
If the factor is not positive, there is no meaningful frame: a zero scale would collapse the picture to nothing, and a negative scale would invent a mirrored negative raster that no encoder accepts.
Input contract, rounding, and error behaviour
Digit strings that parse as finite numbers are allowed so a pasted probe value does not need a second conversion. Width and height may not exceed 65536 pixels; scale may not exceed 1000. After multiplying, each side is rounded with the usual half-up rule to an integer pixel count.
If that rounding would produce a side below one pixel, the task fails rather than returning a zero-width frame. If a rounded side would exceed 65536, the task also fails so a runaway scale cannot invent an 8K-times-ten raster. When the scaled size matches a well-known raster such as 1920×1080 or 3840×2160, a named label such as 1080p Full HD or 4K UHD is included; otherwise that field is omitted.
Example: width 1920, height 1080, scale 2 yields 3840×2160. Example: the same frame at scale 0.5 yields 960×540. A scale of 0 or −1 fails with a message that scale must be a positive number.
Failed validation is not billed.
What you can do with it
Half-size proxies from a 4K master
From 3840×2160 at scale 0.5, obtain 1920×1080 (and the matching even size) before you spin a proxy encode or an offline timeline.
Double 1080p to a 4K target size
From 1920×1080 at scale 2, confirm 3840×2160 4K UHD so an upscale preset is aimed at a real raster, not a guessed box.
FAQ
How do I scale a video resolution by a factor?
Send finite numbers width, height, and a positive scale.
What happens if the scale factor is zero or negative?
A scale factor must be a positive number greater than zero; a zero or negative factor is not a usable video resolution and is not billed.
Does this resize or re-encode a video file?
No. This calculator only returns the scaled pixel size. It does not open, transcode, or write a video. Use a dedicated video resize task when you need a new file.
Why does it also give even dimensions?
Many H.264 and H.265 encoders insist on an even width and height. Each rounded side is therefore also snapped to the nearest even number, never below two pixels, so you can copy a size the encoder will accept.
Why is a 2x scale four times heavier?
The pixel count grows with the square of the factor. Doubling each side of 1920 by 1080 takes the frame from 2,073,600 pixels to 8,294,400, which is why a 4K master weighs so much more than 1080p.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/video/resolution-scale \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"width":1920,"height":1080,"scale":2}'const res = await fetch("https://api.kit.forhosting.com/video/resolution-scale", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"width": 1920,
"height": 1080,
"scale": 2
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/video/resolution-scale",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"width": 1920,
"height": 1080,
"scale": 2
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/video/resolution-scale", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"width":1920,"height":1080,"scale":2}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"width":1920,"height":1080,"scale":2}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/video/resolution-scale", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"width": 1920,
"height": 1080,
"scale": 2
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "video.resolution_scale",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
max_width | 65536 |
max_height | 65536 |
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
A scale factor that is zero or negative is rejected with invalid_input rather than a nonsense empty frame.
How a scale factor turns one resolution into another
Many codecs also insist on even width and even height so 2×2 chroma blocks line up; this calculator therefore also reports even_width and even_height, snapping each rounded side to the nearest even number with a floor of two pixels. The original pixel count is width × height; the new pixel count is new_width × new_height, which grows with s squared, not with s — a 2× linear scale is four times the pixels, which is why a 4K mezzanine is so much heavier than 1080p even though each side only doubled. Those cases fail with invalid_input instead of a hollow 0×0 success payload.
Input contract, rounding, and error behaviour
POST a JSON body with three required finite numbers: width and height of the original frame in pixels, and scale, the positive factor to apply. Aliases width_px and w are accepted for width; height_px and h for height; scale_factor, factor, and multiplier for scale. Each of width, height, and scale must be greater than zero and finite; missing fields, empty strings, NaN, Infinity, and non-numeric text fail with invalid_input naming the field. On success the JSON echoes original_width, original_height, and scale; reports new_width and new_height as the primary result; reports even_width and even_height for codec-friendly even dimensions; reports original_label and new_label as width×height strings; reports original_pixels, new_pixels, and megapixels of the scaled frame; reports aspect_ratio (width divided by height, twelve decimals) and scale_percent (scale times 100); and restates the formula. Pricing for a successful item is a flat $0.002.
Where a resolution-scale calculator earns its keep
Editors, transcode farms, and social-video tools all need the integer size of a scaled frame before they open an encoder. A producer who wants a half-resolution proxy from a 3840×2160 master should see 1920×1080, not a float pair that a later script truncates badly. Pipeline code that builds a scale filter still has to choose a target width times height; this calculator is the deterministic oracle for that pair, including the even snap that odd-sized screen recordings often need before H.264 will accept the frame. The capability does not open a video file, does not re-encode, and does not pick a codec — that work belongs to a media resize or convert task. It only answers the geometry question: given this width, this height, and this positive factor, what is the new resolution? A publisher checking whether a 1280×720 source scaled by 1.5 is already 1920×1080 Full HD can call this endpoint instead of doing mental arithmetic during a live session. API usage draws from prepaid KIT balance at the published $0.002 per successful request; invalid input is not charged. Keep requests small, pin new_width and new_height in tests, and you get a reproducible scaled resolution for presets, lesson keys, and edge workers without standing up a media framework of your own.
Integration use cases
Even dimensions for H.264 screen recordings
Scale an odd-sized capture and read even_width and even_height so the next encode does not fail on an odd luma size.
Technical questions
Are the new width and height whole pixels?
Yes. Each scaled side is rounded to the nearest integer. even_width and even_height further snap to the nearest even value (minimum 2) for typical H.264 and H.265 frames.
What does the resolution scale calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.