ForHosting KIT · Home, food & hobbies

Witcher monster slayer

A griffin with 320 health against a silver sword dealing 45 per hit needs eight strikes, and 40 points of the last one are wasted: know the count before you take the contract. Free in your browser.

Free
Runs in your browser
No sign-up
Your data stays on your device

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Worked example

If you enter

Damage: 50
Health: 200

You get

Hits: 4
Leftover damage: 0
Total damage: 200
Last hit damage: 50

A Witcher who knows how many sword hits a beast can still take plans the fight instead of hoping the last Quen charge holds. The Witcher monster slayer calculator takes two positive numbers — attack damage per connecting hit, and the monster's remaining health pool — and returns the hits needed to reduce that pool to zero together with leftover damage on the killing blow. Leftover damage is overkill: the unused portion of the last strike after the monster's health is gone.

How hits and leftover damage are computed

The Witcher monster slayer answers a combat-arithmetic question every monster hunter eventually writes on a scrap of paper: given a constant damage value per connecting sword hit, how many hits does it take to empty a monster's health pool, and how much of the last swing is wasted as overkill. The closed-form identity is hits equals the ceiling of health divided by damage, and leftover damage equals hits times damage minus health.

Leftover damage is therefore the unused portion of the killing blow; it is zero when health is an exact multiple of damage, and strictly less than one full hit otherwise. A griffin with 320 health facing a silver sword that deals 45 per hit needs eight strikes: seven hits remove 315, the eighth needs only five more, and leftover damage is forty.

The same identity is what a tabletop referee uses when a player asks whether the next greatsword swing will drop a troll, and what a video-game designer uses when checking that a boss cannot be one-shot by a stacked mutagen build. Because ceiling division is deterministic, two clients that send the same pair of positive numbers always receive the same hits and leftover damage.

The calculator does not model signs, potions, critical hits, resistances, or dodge windows; it answers the raw pool-versus-strike question that those systems sit on top of, so a planner can compose those modifiers first and then ask how many remaining hits still stand between Geralt and a trophy.

What you can do with it

Bestiary fight planning

Paste silver-sword damage and a published monster health pool to see hits to kill and leftover overkill before you take the contract.

Combat-log and speedrun checks

Verify that a recorded sequence of connecting hits should have dropped the beast given the damage on the blade at that moment.

FAQ

How does the Witcher monster slayer count hits?

Send positive numbers damage (per connecting hit) and health (monster pool). Hits equal ceil(health / damage).

What is leftover damage on the killing blow?

Leftover damage is overkill: hits times damage minus health. It is zero when the pool is an exact multiple of damage, and always strictly less than one full hit otherwise.

Why must damage and health be positive?

Zero or negative damage cannot empty a pool, and a non-positive health pool is not a fight.

Does this look up The Witcher 3 bestiary by monster name?

No. You supply the remaining health and the damage you actually deal after oils, signs, and resistances. Creature names stay in your own table.

Does the calculator account for critical hits or potions?

No. It assumes the same damage on every connecting hit and ignores signs, potions, critical hits, resistances and dodges. Apply those modifiers to your damage figure first, then enter the result to see the hits still needed.

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

POSThttps://api.kit.forhosting.com/game/witcher-monster-slayer

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/game/witcher-monster-slayer \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"damage":50,"health":200}'

const res = await fetch("https://api.kit.forhosting.com/game/witcher-monster-slayer", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "damage": 50,
    "health": 200
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/game/witcher-monster-slayer",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "damage": 50,
    "health": 200
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/game/witcher-monster-slayer", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"damage":50,"health":200}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"damage":50,"health":200}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/game/witcher-monster-slayer", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "damage": 50,
  "health": 200
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "game.witcher_monster_slayer",
  "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_value 1000000000000000

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

When damage or health is not strictly positive the task fails with invalid_input rather than inventing a kill.

Input contract, response shape, and error behaviour

Values above one quadrillion are rejected so a hit count cannot leave the safe-integer range. Example: damage fifty and health two hundred yields four hits and leftover damage zero, because four times fifty is exactly two hundred. Damage forty-five and health three hundred twenty yields eight hits, leftover damage forty, last-hit damage five, and total damage three hundred sixty. POST a JSON body with two required finite numbers: damage, the Witcher's attack per connecting hit, and health, the monster's remaining pool. Each field may arrive as a JSON number or as a numeric string; aliases such as attack, dmg, sword_damage, hp, health_pool, and monster_hp are accepted and mapped onto the canonical names. Missing fields, empty strings, non-finite values, zeros, and negatives fail with invalid_input naming the field — those failures are not billed. On success the body echoes damage and health, returns hits as a positive integer, leftover_damage as the overkill on the killing blow, total_damage as hits times damage, last_hit_damage as the portion of the last strike that actually emptied the pool, a formula string restating the ceiling identity, and a one-line message suitable for a combat log. Pair the response with your own bestiary table if you need creature names; this endpoint solves the arithmetic only and does not look up a griffin, leshen, or noonwraith by title.

Where a Witcher monster slayer earns its keep

Bestiary authors and wiki maintainers use a Witcher monster slayer so readers can paste a silver-sword damage figure next to a published health pool and see the hit count without doing ceiling division by hand. Tabletop groups playing a Witcher-inspired system use the same contract when a player asks how many rounds a fiend can survive at the party's current damage line. Failed validation does not consume balance. Modders balancing New Game Plus or custom contracts need a deterministic oracle that rejects a zero-damage sword instead of silently reporting infinity, and that reports leftover overkill so a one-shot build is visible in the leftover_damage field rather than hidden in a boolean. Speedrunners and combat-log parsers check whether a recorded sequence of connecting hits should have dropped a boss given the damage on the steel or silver blade at that moment; calling a tiny parse API avoids pulling a full combat simulator for a two-number question. Keep requests small, pin hits and leftover_damage in tests, and you get reproducible slay counts for wiki widgets, mod pipelines, and edge workers without standing up a combat engine of your own.

Integration use cases

Mod and difficulty balance

Check that a mutagen stack cannot one-shot a boss: leftover_damage near a full hit means the last swing wasted almost everything.

Technical questions

What does the Witcher monster slayer calculator cost?

The browser tool is free. API requests use prepaid balance at $0.002 per successful call; invalid input is not billed.

Read the full KIT documentation →

Run — free