Video resolution scale calculator
Pick a delivery label and see the exact frame size: 1920 by 1080 converted to 720p becomes 1280 by 720, a factor of 0.666667, with a clear warning whenever the plan enlarges the source. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Source width
- 1,920
- Source height
- 1,080
- Target label
- 720p
- Target height
- 720
- Scale factor
- 0.666667
- Scaled width
- 1,280
- Scaled height
- 720
This video resolution scale calculator turns a source width and height plus a familiar delivery label into an exact, reusable resize plan. Choose 480p, 720p, 1080p, or 4K to receive the target height, uniform scale factor, proportional output width, and a clear indication of whether the operation enlarges the source. It performs arithmetic only: no video is uploaded, decoded, changed, or stored. The result is useful for planning encoding settings, validating export presets, and keeping automated media pipelines consistent before expensive transcoding begins.
How target labels become scale factors
Resolution labels describe the progressive frame height used for delivery. This calculator maps 480p to 480 pixels, 720p to 720 pixels, 1080p to 1080 pixels, and 4K to 2160 pixels. It then divides that target height by the source height.
A 1080-pixel-high source converted to 720p therefore has a scale factor of 0.666667, while a 720-pixel-high source planned for 1080p has a factor of 1.5. A factor below one means reduction, one means no size change, and a factor above one means enlargement. The calculation uses only supplied dimensions and the fixed label table, so identical inputs always produce identical results.
Preserving the source aspect ratio
The selected label fixes the output height, not an arbitrary rectangular canvas. The same scale is applied to the source width, which preserves the source video's shape. For a standard 1920 by 1080 frame, choosing 720p yields 1280 by 720.
For a 640 by 480 archival clip, choosing 720p yields 960 by 720 rather than stretching it to 1280 by 720. That distinction matters because a resolution label and an aspect ratio answer different questions: the label describes vertical detail, while the source dimensions determine frame shape. Some encoders require even dimensions or dimensions divisible by a codec-specific block size; this calculator does not silently adjust for those constraints because doing so would change the mathematical scale.
Treat its dimensions as the proportional plan, then apply any encoder-specific padding or cropping rule explicitly. This keeps the result understandable and prevents an unnoticed aspect-ratio change.
What you can do with it
Plan an encoding ladder
Calculate consistent proportional dimensions for several delivery tiers before configuring a transcoder or packaging workflow.
Preserve non-widescreen footage
Convert archival, vertical, or custom-aspect footage to a target height while retaining its original frame shape.
FAQ
Which target labels are supported?
The accepted labels are exactly 480p, 720p, 1080p, and 4K.
Does the calculator stretch video to 16:9?
No. It applies one uniform scale to both source dimensions, preserving the original aspect ratio.
Does this capability resize the video file?
No. It only returns a deterministic resize calculation. It does not upload, decode, encode, or store media.
How do I convert 1920x1080 to 720p?
Choose 720p and enter 1920 by 1080: the result is 1280 by 720, with a scale factor of 0.666667. The target height is divided by the source height, and the same factor is applied to the width.
Why does a 640x480 clip become 960x720 at 720p?
The label fixes only the height. The width is scaled by the same factor, so the original 4:3 shape stays intact instead of being stretched to 1280 by 720.
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-convert \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"source_width":1920,"source_height":1080,"target_label":"720p"}'const res = await fetch("https://api.kit.forhosting.com/video/resolution-convert", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"source_width": 1920,
"source_height": 1080,
"target_label": "720p"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/video/resolution-convert",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"source_width": 1920,
"source_height": 1080,
"target_label": "720p"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/video/resolution-convert", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"source_width":1920,"source_height":1080,"target_label":"720p"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"source_width":1920,"source_height":1080,"target_label":"720p"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/video/resolution-convert", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"source_width": 1920,
"source_height": 1080,
"target_label": "720p"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "video.resolution_convert",
"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_mb | 500 |
max_minutes | 60 |
max_megapixels | 3.9 |
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
How target labels become scale factors
The returned is_upscale flag makes that last condition explicit, avoiding slightly different comparisons in every caller.
Preserving the source aspect ratio
The scaled_width result is rounded to the nearest integer because video frame dimensions must ultimately be whole pixels.
Valid inputs and practical interpretation
Strict labels make integrations predictable and ensure that a typo never falls through to a misleading conversion. Upscaling increases frame dimensions but cannot recreate detail that the source never contained, so the flag is a planning signal rather than a quality promise. Use it to choose a different master, warn an editor, select an enhancement workflow, or prevent an automated job from spending encoding time on an enlargement that your delivery policy disallows. Provide source_width and source_height as positive integer pixel counts, each no larger than 1,000,000, and provide target_label using one of the four recognized spellings. Labels are intentionally exact and case-sensitive: 4K is valid, while 4k, UHD, 2160p, or an invented tier is rejected with an invalid_input error. The is_upscale value compares the target height with the source height. It is false when the heights match, even if the proportional width rounds by a pixel, and true only when the requested target has more vertical pixels. API use is charged at $0.002 per successful request.
Integration use cases
Detect accidental upscaling
Check is_upscale before submitting a job so low-resolution masters are not enlarged without an explicit quality decision.
Technical questions
How is the scale factor calculated?
The target height for the selected label is divided by source_height, and the reported factor is rounded to six decimal places.
When is is_upscale true?
It is true when the selected target height is greater than the source height. Equal or smaller target heights return false.