ForHosting KIT · Home, food & hobbies

Dark chocolate ganache ratio calculator

200 g of dark chocolate needs 200 g of cream, for 400 g of ganache: the classic dark recipe uses equal weights. Enter the chocolate weight in grams, ounces or kilograms and get the cream and the total in the same unit. 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

Chocolate weight: 200 g

You get

Cream weight: 200 g
Total weight: 400
Ratio: 1
Ratio label: 1:1 cream:chocolate

Pastry cooks and home bakers reach for dark chocolate ganache when they need a glossy glaze, a truffle center, or a pipeable filling with deep cocoa flavor. The classic dark formula pairs equal parts chocolate and cream by weight, so once you know how much chocolate you have, the cream amount is not a guess — it is the same number. Mental arithmetic still fails under rush: someone weighs two hundred grams of couverture, pours cream by eye, and ends up with a split or overly soft emulsion. This dark chocolate ganache ratio calculator takes one positive chocolate weight and returns the matching cream weight at a fixed one-to-one ratio, plus the combined total. Units stay yours — grams, ounces, or kilograms — the tool multiplies the number only.

Why dark ganache uses a one-to-one cream-to-chocolate ratio

Ganache is an emulsion of chocolate and cream. Dark chocolate has less cocoa butter and milk solids than milk or white chocolate, so the classic pastry ratio for a firm yet scoopable dark ganache is one part cream to one part chocolate by mass. That means if you have three hundred grams of dark chocolate, you heat three hundred grams of cream, pour it over the chopped chocolate, rest briefly, then stir or blend until smooth.

The ratio is a mass ratio, not a volume ratio: a cup of cream does not weigh the same as a cup of chopped chocolate, so kitchen scales matter. This calculator encodes only that fixed one-to-one rule. It does not adjust for cacao percentage, butter additions, glucose, or flavor extracts.

It does not convert cups to grams. You choose the unit, pass the chocolate weight as a finite positive number, and receive cream equal to chocolate and total equal to twice the chocolate. Zero is rejected because you cannot make ganache from no chocolate; negative weights are rejected because mass cannot be negative.

Non-numeric strings, empty fields, Infinity, and NaN also fail so clients can surface a clear field error. Optional unit is echoed in the message for readability only. Searchers looking for a dark chocolate ganache ratio calculator usually want this exact confirm: cream equals chocolate for dark style, not a multi-mode ratio picker for milk or white.

When a fixed one-to-one ratio helps

Inventory tools that scale truffle production walk each chocolate lot, call the dark ratio once, and print cream purchase orders that match the classic one-to-one rule. Culinary schools use deterministic goldens in LMS auto-graders so students learn that dark ganache cream equals chocolate by weight, not a vague splash from the pan. Failed validation is free.

When you need milk chocolate two-to-one cream ratios or white chocolate three-to-one, use a dedicated style calculator; this page owns the dark chocolate one-to-one search intent.

What you can do with it

Truffle and glaze batch planning

From a known dark chocolate weight, get matching cream for truffle centers or cake glazes without mental math errors.

Production cream purchase orders

Scale cream buys for dark ganache lines from chocolate inventory lots using a fixed 1:1 mass ratio in scripts.

FAQ

What happens if the chocolate weight is zero or negative?

Non-positive chocolate weights cannot make ganache and are not billed.

Is the ratio by weight or by volume?

By mass (weight). Use the same unit for chocolate and cream. The tool does not convert cups to grams.

Does this work for milk or white chocolate ganache?

No. This calculator is fixed at the classic dark 1:1 cream-to-chocolate ratio. Milk and white styles typically use more cream and need a different tool.

Does the cacao percentage change the amount of cream?

No. The calculator applies only the fixed one-to-one rule for dark ganache. It does not adjust for cacao percentage, added butter, glucose or flavor extracts, so tweak the recipe yourself if your chocolate needs it.

Can I weigh in ounces or kilograms?

Yes. The unit is yours: the calculator multiplies the number only, so ounces in give ounces out. It does not convert cups to grams, so weigh the chocolate on a scale first.

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/cook/ganache-dark-ratio

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/cook/ganache-dark-ratio \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"chocolate_weight":200}'

const res = await fetch("https://api.kit.forhosting.com/cook/ganache-dark-ratio", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "chocolate_weight": 200
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/cook/ganache-dark-ratio",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "chocolate_weight": 200
},
)
task_id = res.json()["task_id"]

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

body := bytes.NewBufferString(`{"chocolate_weight":200}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/cook/ganache-dark-ratio", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "chocolate_weight": 200
}

Example response

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

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

Zero and negative weights fail with invalid_input and are not billed.

Input contract, response fields, and error behaviour

Magnitudes above one trillion are rejected to keep the analytic path safe. POST a JSON body with one required field: chocolate_weight, a finite positive number for the dark chocolate mass in your chosen unit. Aliases chocolate, weight, grams, mass, amount, and choc are accepted so forms and scripts can reuse familiar keys. Optional unit (aliases u, measure) is a short string such as g or oz stored for display. On success the body includes chocolate_weight and cream_weight (rounded), total_weight as their sum, ratio always one, ratio_label one-to-one cream to chocolate, ganache_style dark, unit as provided or null, formula cream_weight equals chocolate_weight times one, and a human-readable message. Example: chocolate_weight two hundred with unit g returns cream_weight two hundred, total_weight four hundred, and a message that states two hundred g dark chocolate needs two hundred g cream. If chocolate_weight is missing, not finite, zero, or negative, the task fails with invalid_input naming the problem and does not consume balance. Pair this endpoint with a cups-to-grams converter when your recipe still lists volumes; this calculator only applies the dark ganache mass ratio to a weight you already trust.

Where a fixed dark-ganache ratio API earns its keep

Cloud functions that rebuild family recipe cards from JSON need a tiny, network-free primitive that never drifts between preview and production. Keep requests small, pin cream_weight and total_weight in tests, and you get reproducible dark ganache cream amounts for widgets, edge workers, and kitchen tablets without a full multi-style ganache designer.

Integration use cases

Recipe apps and pastry widgets

Embed a free dark ganache ratio tool that matches API goldens so readers and kitchen tablets show the same cream figure.

Technical questions

How do I calculate cream for dark chocolate ganache?

Send a finite positive chocolate_weight (aliases chocolate, weight, grams, mass, amount). The API returns cream_weight = chocolate_weight × 1 and total_weight = chocolate + cream at the classic dark 1:1 ratio.

What does the dark chocolate ganache ratio calculator cost?

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

Read the full KIT documentation →

Run — free