ForHosting KIT · SEO

Keyword density

You can believe a page is about 'affordable ergonomic office chairs' and still be wrong, because what the text actually repeats, in what proportion, is a separate question from what you intended to write. The Keyword Density API counts single terms and multi-word phrases across a page's body content and returns their frequency, so you see what the copy statistically emphasizes rather than what you assume it does. It's a diagnostic step, not a rewrite tool.

● StableFree · in your browser

Run — free How it works & API

Use it from WebAPIEmailApp soonTelegram soon

Intent versus what the text actually says

Writers routinely aim for a target phrase and end up burying it under synonyms, related terms, and filler that dilute the very emphasis they were going for, or they overcorrect and repeat the phrase so often it reads as stuffed even though it never felt that way while drafting. Neither problem is visible from re-reading your own copy, because you already know what you meant to emphasize; a frequency count doesn't carry that bias.

What the endpoint measures

POST /seo/keyword-density pulls the visible body text of a URL, strips boilerplate like navigation and footer content where identifiable, and tallies single-word and multi-word phrase frequency as both a raw count and a percentage of total words. You get a ranked list of the terms and phrases that appear most, which surfaces both your intended focus keyword, confirming it's actually present at a reasonable rate, and any unintended repetition you didn't notice while writing.

A number with a complicated past

Keyword density as a metric had real weight decades ago, when search algorithms leaned more heavily on raw term frequency to judge relevance, and it produced a wave of pages written to hit an arbitrary percentage rather than to read well. Search ranking has moved well past treating density as a target to hit, but the underlying measurement never stopped being useful as a mirror: it tells you what a page emphasizes in practice, which is a different and still valuable question from whether that percentage itself affects rankings.

Reading the output correctly

There's no universal 'correct' percentage to aim for, and treating this data as a threshold to hit reintroduces the exact stuffing problem the metric used to cause; it's most useful as a sanity check against unnatural repetition and as confirmation that your actual topic and your intended topic match. Pair it with a heading structure or full audit check for a complete on-page picture rather than relying on density alone.

Fitting it into an editorial process

The call is asynchronous: submit a URL to POST /seo/keyword-density, get a task_id back immediately, and receive the frequency breakdown by signed webhook or a 24-hour signed link, which makes it easy to run automatically on every draft before publish. No page content is retained past the retention window, and nothing analyzed is used to train anything.

What you can do with it

Confirming a target phrase is actually present

Check a freshly written article to verify the intended focus phrase actually appears at a reasonable, natural rate rather than assuming it does.

Catching unintentional keyword stuffing

Run the check on older pages written before your current editorial standards to find repetition that reads as spammy in hindsight.

Comparing a page against its own topic drift

Use the frequency breakdown to spot when a page meant to focus on one product ended up statistically dominated by a competing or unrelated term.

Screening translated or localized content

Verify that a translated page still emphasizes the equivalent target phrase and didn't lose that focus in the translation process.

FAQ

What exactly does keyword density measure?

How often a specific term or phrase appears in a page's body text, shown as both a raw count and a percentage of total words, based on the page's visible content.

Is there an ideal keyword density percentage?

No single correct number exists; the metric is most useful for spotting unnatural repetition or confirming a topic matches intent, not as a target percentage to hit.

Does keyword density still affect rankings directly?

It's not treated as a direct ranking lever the way it was decades ago, but the underlying measurement still shows you what a page emphasizes in practice, which remains useful diagnostically.

Is there a free tier to try it?

The tool above runs free in your browser. The API is paid — each call draws from your prepaid ForHosting KIT balance: top up from $10.00 (it never expires), pay each request's published price, and a call with no balance returns HTTP 402. No subscription, no tokens, and a failed task is never charged.

How do I get the results back?

POST /seo/keyword-density returns a task_id immediately, and the frequency breakdown arrives via signed webhook or a signed link valid for 24 hours.

Does it check multi-word phrases or only single words?

Both — it tallies single-term frequency alongside multi-word phrase frequency, since most real target keywords are phrases rather than isolated words.

How much does it cost per page?

It's a flat $0.002 per request, making it cheap enough to run on every draft before it publishes.

What happens if the page fails to load?

The task retries automatically up to three times before returning a clear error, and a failed task is never charged.

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/seo/keyword-density

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, and soon from our app, email and Telegram.

Call it from your stack

curl -X POST https://api.kit.forhosting.com/seo/keyword-density \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d &#39;{"url":"https://ejemplo.com"}'

const res = await fetch("https://api.kit.forhosting.com/seo/keyword-density", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "url": "https://ejemplo.com"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/seo/keyword-density",
    headers={"Authorization": f"Bearer {os.environ[&#39;KIT_KEY']}"},
    json={
    "url": "https://ejemplo.com"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/seo/keyword-density", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => &#39;{"url":"https://ejemplo.com"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"url":"https://ejemplo.com"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/seo/keyword-density", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "url": "https://ejemplo.com"
}

Example response

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

Read the full KIT documentation →

Run — free