ForHosting KIT · Images

Blink-free photo calculator

The blink-free photo calculator estimates the minimum number of shots needed to make your chance of capturing at least one photo with open eyes exceed a chosen target.

● BetaFree · in your browser

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Enter the blink rate for a single shot and the confidence you want. The calculator applies a simple independent-photo probability model, returns a whole photo count, and makes the assumption behind the result visible. It is useful for portraits, group-photo planning, school photography, events, and any repeated shot where blinking can spoil an otherwise usable image.

Turn a blink rate into a practical shot count

A blink rate describes the probability that one attempted photo is spoiled by closed eyes. If that rate is 0.10, a single shot has a 90 percent chance of being blink-free under this model. Taking another independent photo gives you another opportunity. The calculator asks a practical question: how many opportunities are required before the probability of having at least one successful image strictly exceeds your target? Enter the blink rate as a decimal between zero and one, then enter a target probability below one. The answer is always a whole number because a photographer cannot take a fraction of a picture. A blink rate of zero returns one photo, since the first shot is already certain to be blink-free in the model. A blink rate of one is rejected because every shot would fail and no finite number could reach the target. Use a rate that represents the subject, group, timing, and shooting conditions you actually expect rather than an unrelated population average.

Understand the probability model

For one photo, the probability of failure is the blink rate. For two independent photos, both fail only when the first and second fail, so their combined failure probability is the blink rate squared. For any number n, the chance that every photo fails is the blink rate raised to n. Subtracting that value from one gives the probability that at least one photo is blink-free. The calculator finds the smallest integer n for which this success probability is greater than, not merely equal to, your target. Logarithms provide the initial count efficiently, and a numerical boundary check makes sure floating-point rounding does not violate that strict rule. Independence is the important assumption: each shutter release is treated as a fresh opportunity with the same blink rate. A rapid burst may contain correlated frames, while pauses, prompts, flash recycle times, or changing expressions can alter the true rate. Treat the result as a planning estimate, not a guarantee about a particular person or session.

Choose inputs and use the result responsibly

Start with a blink rate supported by your own observations when possible. For example, review a representative set of previous portraits and divide blink-spoiled frames by total frames. Then choose a target that matches the cost of missing the shot. A casual portrait may tolerate a lower target, while a ceremonial group photo that cannot be repeated may justify a higher one. Higher blink rates and targets closer to one both increase the required count, sometimes sharply. The returned number is the mathematical minimum for the stated assumptions, so real sessions may benefit from a modest operational margin for focus errors, motion, lighting, or expressions that this calculator does not model. For groups, do not automatically use one person's blink rate: the relevant failure rate is the chance that the complete photo is unusable because at least one required subject has closed eyes. Estimate that group-level rate first if all faces must be open. The page is convenient for individual checks, while API requests cost $0.002 when you incorporate the calculation into scheduling or capture software.

What you can do with it

Plan a portrait burst

Estimate a short burst length that clears the desired chance of obtaining at least one open-eye portrait.

Prepare for group photography

Use an estimated group-level failure rate to plan enough attempts for a class, team, or wedding party.

Set capture workflow defaults

Convert an observed blink failure rate into a repeatable minimum shot count in photography software.

FAQ

What formula does the calculator use?

For n independent photos it uses 1 - blink_rate^n as the probability that at least one photo is blink-free.

Why can I not enter a blink rate of 1?

A rate of 1 means every photo fails, so no finite photo count can exceed a positive success target.

Does the result guarantee an open-eye photo?

No. It is a probability estimate based on a constant blink rate and independent photos, not a guarantee for a session.

Can I use this for a group?

Yes, if blink_rate represents the probability that the whole group photo is spoiled by one or more closed-eye subjects.

How much does an API calculation cost?

Each API request costs $0.002. The calculation is deterministic and uses no external service.

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/blink-free-photos

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/blink-free-photos \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"blink_rate":0.1,"target_probability":0.99}'

const res = await fetch("https://api.kit.forhosting.com/image/blink-free-photos", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "blink_rate": 0.1,
    "target_probability": 0.99
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/image/blink-free-photos",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "blink_rate": 0.1,
    "target_probability": 0.99
},
)
task_id = res.json()["task_id"]

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

body := bytes.NewBufferString(`{"blink_rate":0.1,"target_probability":0.99}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/image/blink-free-photos", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "blink_rate": 0.1,
  "target_probability": 0.99
}

Example response

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