ForHosting KIT · Images

Favicon size generator

A favicon often appears to be one tiny image, but modern browsers, mobile home screens, and installed web apps expect several square assets.

● BetaFree · in your browser

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

This favicon size generator checks a source image’s width and height against the standard 16, 32, 48, 180, 192, and 512 pixel targets. It tells you which targets fit within the original pixels and which would require upscaling, helping you plan clean exports before opening an image editor or automating an asset pipeline.

Start with the actual source dimensions

Enter the source image width and height in pixels, using the dimensions of the file that will supply the favicon artwork. The calculator uses the smaller dimension as the limiting dimension because every target in the standard set is square. For example, a 600 by 200 image has plenty of horizontal pixels, but it can only produce square exports up to 200 by 200 without enlarging the original. The result includes the source dimensions, that limiting dimension, and one record for each standard target: 16, 32, 48, 180, 192, and 512 pixels. Each record repeats the target width and height and clearly states whether upscaling is required. Separate lists also collect the sizes that fit and those that need enlargement, making the response convenient for both people and build scripts. The tool does not inspect or crop image content. It answers the narrower planning question from dimensions alone, so you remain in control of padding, cropping, transparency, and artwork placement during export.

Understand fitting and upscaling

A target fits when both source dimensions are at least as large as the requested square size. A 192 by 300 source therefore fits 16, 32, 48, 180, and 192, while 512 is flagged as requiring upscaling. Equality counts as a fit: a 48 by 48 source can produce the 48 pixel target without enlargement. A flagged size is not automatically forbidden. It is a warning that the exporter must invent pixels, which may soften edges, blur fine lettering, or expose artifacts in artwork designed for a smaller canvas. Vector originals can usually be rendered directly at every target and do not have the same raster limitation, but once you provide raster dimensions this calculator evaluates them conservatively. Sources smaller than 16 pixels on either axis are rejected because they cannot supply even the smallest standard favicon target without enlargement. The calculation is deterministic and does not depend on file format, metadata, device pixel ratio, browser detection, or network services, so identical width and height values always return the same classification.

Use the result in an export workflow

Treat the output as an export checklist rather than as generated image files. Create the fitting sizes directly from the source, preserving transparency and using a high-quality downsampling filter. Review every upscaling size before deciding whether to enlarge the raster, redraw the artwork, or return to a vector master. The 16, 32, and 48 pixel variants cover familiar browser and desktop favicon contexts. The 180 pixel target is commonly used for an Apple touch icon, while 192 and 512 pixel assets are widely used in web app manifests and installed experiences. Exact packaging requirements still belong to the platform or manifest you are targeting, and this capability does not write HTML, a manifest, an ICO container, or PNG files. In automation, read fitting_sizes to select safe raster exports and upscaling_sizes to fail a quality check or trigger a larger-source request. The API costs $0.002 per request, and because the response has stable keys and ordered targets, it can be placed in a repeatable asset validation step without post-processing unpredictable output.

What you can do with it

Check a logo before favicon export

Confirm which standard square assets can be downsampled from the available raster logo and which need a larger master.

Validate a web app asset pipeline

Fail a build when required manifest icon sizes would depend on raster upscaling.

Plan a designer handoff

Give a designer an exact list of safe exports and larger targets that require new artwork.

FAQ

Which favicon sizes are checked?

The fixed standard set is 16, 32, 48, 180, 192, and 512 pixels, with square width and height for every target.

How is a size classified as fitting?

A target fits without upscaling when both the source width and source height are at least the target size.

What happens when the source is smaller than 16 by 16?

The request returns an invalid input error because the source cannot cover the smallest standard target.

Does this capability resize or crop my image?

No. It evaluates dimensions only and returns a planning set; it does not receive, decode, crop, or export image files.

Does a requires_upscaling flag mean I cannot use that size?

No. It means raster enlargement is necessary. You may still export it, but a larger or vector source usually produces sharper results.

What does the API request cost?

Each API request costs $0.002.

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

POSThttps://api.kit.forhosting.com/image/favicon-sizes

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/image/favicon-sizes \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"width":256,"height":256}'

const res = await fetch("https://api.kit.forhosting.com/image/favicon-sizes", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "width": 256,
    "height": 256
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/image/favicon-sizes",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "width": 256,
    "height": 256
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/image/favicon-sizes", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"width":256,"height":256}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"width":256,"height":256}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/image/favicon-sizes", 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": 256,
  "height": 256
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "image.favicon_sizes",
  "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

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

Limits

`max_mb`	15
`max_megapixels`	12

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.

Read the full KIT documentation →