Video watermark position calculator
Place a 240 by 120 logo in the bottom-right corner of a 1920 by 1080 frame with a 32-pixel margin and get its top-left point, x 1648 and y 928, checked to fit fully inside the frame. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Runs in your browser. Free, unlimited — your data never leaves this page.
The video watermark position calculator returns the top-left pixel coordinates needed to place a logo, bug, or branding image in a chosen corner of a video frame. Enter the video dimensions, watermark dimensions, corner, and uniform margin, and the result provides deterministic x and y values ready for a rendering or encoding workflow. It also validates that the watermark fits completely inside the frame, preventing placements that would crop or hide part of the image.
Understanding the coordinate result
Video compositing systems usually locate an overlay by the position of its top-left pixel. This calculator follows that convention: x is the horizontal distance from the frame's left edge, and y is the vertical distance from its top edge. For a top-left placement, both coordinates equal the requested margin.
A top-right placement keeps y at the margin while calculating x from the video width minus the watermark width and margin. Bottom placements use the same idea vertically, subtracting the watermark height and margin from the video height. This makes the result straightforward to transfer into a video filter, canvas renderer, motion graphics template, or server-side encoding pipeline.
All values are integer pixels, so the response avoids fractional positions and implicit rounding. The position field is repeated in the response alongside the effective margin, making logs and job records easier to interpret without reconstructing the original request. The calculator performs geometry only; it does not inspect pixel content, account for transparent padding inside the watermark file, or alter either source asset.
Choosing dimensions and a safe margin
Use the actual encoded frame dimensions rather than a player's displayed size. A 1920 by 1080 source shown in a smaller browser element still has a 1920 by 1080 coordinate system unless your rendering stage explicitly resizes it first. Watermark dimensions should likewise describe the image size at the moment it is overlaid.
If your pipeline scales a logo before compositing, supply the scaled width and height, not the original file's dimensions. The margin is a uniform inset applied horizontally and vertically from the chosen corner. A margin of zero aligns the watermark's outer rectangle directly with both frame edges; a positive margin moves it inward.
Transparent pixels still belong to the watermark rectangle, so crop unnecessary transparent borders beforehand if the visible mark appears farther from the edge than the returned coordinates suggest.
Applying coordinates in production workflows
The returned x and y coordinates can be inserted into an overlay stage after any resize or orientation normalization has completed. Ordering is important: if a pipeline calculates coordinates for a landscape frame and then rotates or crops the video, the selected visual corner may change or the watermark may move off-screen. Calculate placement against the final frame geometry, or recalculate whenever a transform changes width or height.
For batches, keep the desired corner and margin as policy inputs while supplying each asset's actual frame and watermark dimensions. The deterministic response then gives every job a placement that follows the same edge-spacing rule across landscape, square, vertical, and custom formats. This capability does not account for title-safe areas, device notches, subtitles, lower thirds, or important subjects; choose a larger margin or a different corner when editorial constraints require additional clearance.
It also does not create an expression in any specific encoder syntax, which keeps the coordinates portable across tools.
What you can do with it
Build an encoding command
Calculate portable x and y values before inserting a logo overlay into a transcoding or rendering job.
Standardize branded exports
Apply the same corner and edge margin policy across landscape, square, and vertical video variants.
Validate automated layouts
Reject oversized watermarks or impossible margins before an expensive media-processing stage begins.
FAQ
What do x and y represent?
They are the pixel coordinates of the watermark rectangle's top-left corner, measured from the video frame's top-left corner.
How is the margin applied?
The same non-negative pixel margin is applied inward from the horizontal and vertical edges of the selected corner.
Can the watermark touch the edge?
Yes. Set margin to zero to align its rectangular boundary with the two edges of the selected corner.
Does this resize or add the watermark to my video?
No. It only calculates placement coordinates; it does not upload, decode, resize, render, or modify media.
What if the watermark is bigger than the video?
The placement is refused when the logo is wider or taller than the frame, or when the margin would push part of it outside. That check matters most for narrow vertical videos and unusually large logos.
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/watermark-position \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"video_width":1920,"video_height":1080,"watermark_width":240,"watermark_height":120,"position":"bottom_right"}'const res = await fetch("https://api.kit.forhosting.com/video/watermark-position", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"video_width": 1920,
"video_height": 1080,
"watermark_width": 240,
"watermark_height": 120,
"position": "bottom_right"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/video/watermark-position",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"video_width": 1920,
"video_height": 1080,
"watermark_width": 240,
"watermark_height": 120,
"position": "bottom_right"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/video/watermark-position", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"video_width":1920,"video_height":1080,"watermark_width":240,"watermark_height":120,"position":"bottom_right"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"video_width":1920,"video_height":1080,"watermark_width":240,"watermark_height":120,"position":"bottom_right"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/video/watermark-position", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"video_width": 1920,
"video_height": 1080,
"watermark_width": 240,
"watermark_height": 120,
"position": "bottom_right"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "video.watermark_position",
"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
Choosing dimensions and a safe margin
The request is rejected when either watermark dimension exceeds the matching frame dimension. It is also rejected when the chosen margin cannot leave the entire watermark inside the frame. That validation matters for narrow portrait videos, unusually large logos, and automated workflows receiving mixed aspect ratios.
Applying coordinates in production workflows
Each API calculation costs $0.002, while the browser implementation can perform the same pure arithmetic locally for interactive planning and quick checks.
Technical questions
What happens if the watermark is larger than the video?
The request returns an invalid input error because the watermark cannot fit completely inside the frame.
What does an API request cost?
Each API request costs $0.002. The same deterministic calculation can also run in the browser.