ForHosting KIT · Home, food & hobbies

Golf course handicap calculator

A 12.4 index on tees with slope 130, course rating 72.1 and par 72 gives a course handicap of 14 strokes: enter your index and the scorecard figures to know your strokes before you tee off. 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

Handicap index: 12.4
Slope rating: 130
Course rating: 72.1
Par: 72

You get

Rating minus par: 0.1
Course handicap raw: 14.3654867257
Course handicap: 14

A Handicap Index alone does not tell you how many strokes you get on a particular set of tees. Course difficulty is published as a Slope Rating (relative hardness for bogey golfers) and a Course Rating (expected score for a scratch golfer), and those numbers interact with the course par. This golf course handicap calculator applies the World Handicap System formula: Course Handicap equals Handicap Index times Slope over 113, plus Course Rating minus Par, then rounds half away from zero to a whole number of strokes. Enter your index, the slope and course rating on the scorecard for the tees you will play, and the par for that layout.

What Course Handicap means and why slope and rating matter

Under the World Handicap System, your Handicap Index is a portable measure of potential ability computed from recent score differentials. It is not yet the number of strokes you receive on tomorrow’s card. Each set of tees has a Slope Rating, typically between about fifty-five and one hundred fifty-five, where one hundred thirteen is the standard baseline.

Multiplying the index by Slope divided by one hundred thirteen scales the portable index to the relative difficulty of those tees for a bogey golfer. Separately, Course Rating is the expected score for a scratch golfer from those tees; when Course Rating differs from the stated par, rating minus par shifts the stroke allotment so that a harder-than-par rating awards extra strokes and an easier-than-par rating awards fewer. The sum of the scaled index term and the rating-relative-to-par term is the raw Course Handicap.

Official practice rounds that value half away from zero to the nearest whole number so competitions can post integer stroke holes. This capability implements exactly that chain: scale by slope, add rating minus par, round half away from zero. It does not compute Playing Handicap (which applies a competition allowance percentage after Course Handicap), does not update your Handicap Index from a new round, and does not fetch live scorecard data from a governing body.

You supply the four published numbers; it returns the course stroke figure for those tees.

Where working out your course handicap helps

Club competitions and member-guest events need a deterministic conversion from each player’s Handicap Index to strokes for the tees in use before pairings close. Golf media and SEO landings that rank for golf course handicap calculator benefit from a live free browser path that matches the paid automation path on the same pure module, so readers who later automate bulk conversions see identical numbers.

League administrators can batch convert a roster when the club changes tees or publishes a new slope and course rating without opening a spreadsheet for each player. Failed validation does not consume balance.

What you can do with it

Club day and member-guest stroke allotment

Convert each entrant’s Handicap Index to Course Handicap for the published tees before the first tee time using slope, course rating, and par from the scorecard.

Scoring apps and on-course kiosks

Call the same formula from mobile and web so players see integer course strokes that match the club’s WHS posting policy.

League roster bulk conversion

When tees or ratings change, recompute Course Handicap for an entire roster from stored indexes and the new slope and rating without hand spreadsheets.

FAQ

What formula does the golf course handicap calculator use?

Course Handicap = Handicap Index × (Slope Rating / 113) + (Course Rating − Par), then rounded half away from zero to the nearest whole number. This matches the standard WHS course-handicap conversion for the tees played.

What is the difference between Course Handicap and Playing Handicap?

Course Handicap is the full stroke allotment for the tees after slope and rating-to-par. Playing Handicap multiplies Course Handicap by a competition allowance percentage (for example 95% or 85%). This capability returns Course Handicap only.

How do I enter a plus Handicap Index?

The formula still applies; strong players may receive a negative course handicap after rounding.

What is my course handicap with a 12.4 index on a slope 130 course?

14 strokes, if the course rating is 72.1 and par is 72. The index is scaled by 130 over 113, the 0.1 difference between rating and par is added, and the result is rounded to a whole stroke.

Why is the slope divided by 113?

Because 113 is the standard difficulty baseline. Slope ratings run from 55 to 155, so tees rated above 113 give you more strokes than your index and easier tees give you fewer.

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/hobby/sport-golf-course-handicap

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/hobby/sport-golf-course-handicap \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"handicap_index":12.4,"slope_rating":130,"course_rating":72.1,"par":72}'

const res = await fetch("https://api.kit.forhosting.com/hobby/sport-golf-course-handicap", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "handicap_index": 12.4,
    "slope_rating": 130,
    "course_rating": 72.1,
    "par": 72
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/hobby/sport-golf-course-handicap",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "handicap_index": 12.4,
    "slope_rating": 130,
    "course_rating": 72.1,
    "par": 72
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/hobby/sport-golf-course-handicap", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"handicap_index":12.4,"slope_rating":130,"course_rating":72.1,"par":72}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"handicap_index":12.4,"slope_rating":130,"course_rating":72.1,"par":72}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/hobby/sport-golf-course-handicap", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "handicap_index": 12.4,
  "slope_rating": 130,
  "course_rating": 72.1,
  "par": 72
}

Example response

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

Input contract, response fields, and validation rules

Example: index twelve point four, slope one hundred thirty, course rating seventy-two point one, par seventy-two yields raw course handicap about fourteen point three six and rounded course handicap fourteen, because twelve point four times one hundred thirty over one hundred thirteen is about fourteen point two six, plus zero point one for rating minus par. POST a JSON body with four required finite numbers: handicap_index (your WHS Handicap Index, allowed from negative ten for strong plus handicaps through fifty-four), slope_rating (fifty-five through one hundred fifty-five inclusive), course_rating (fifty through ninety, covering nine- and eighteen-hole ratings), and par (twenty-seven through ninety so nine-hole layouts are accepted). Each field may arrive as a JSON number or a numeric string; aliases such as hi, slope, cr, and course_par are accepted. Missing fields, empty strings, non-finite values, and numbers outside the published ranges fail with invalid_input naming the field, and those failures are not billed. On success the body echoes the four inputs, rating_minus_par (course_rating minus par), course_handicap_raw (the unrounded floating result of the formula), course_handicap (the integer strokes after half-away-from-zero rounding), and a short formula string for display. Use course_handicap when posting integer strokes to a card; keep course_handicap_raw if you need to audit rounding in a league spreadsheet.

Where a course handicap API earns its keep

Scoring apps and on-course kiosks can call this endpoint with the four scorecard fields instead of reimplementing slope scaling and rating-to-par adjustment in every client language. Pin the rounded course_handicap and the raw value in tests so a future change to rounding policy is caught immediately, and you get reproducible stroke allotments for tournaments, apps, and edge workers without standing up a full handicap network integration.

Technical questions

What ranges are accepted for slope, rating, and par?

slope_rating must be 55–155, course_rating 50–90, and par 27–90. handicap_index must be between −10 and 54. Values outside those ranges fail with invalid_input and are not billed.

What does the course handicap 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