Engagement rate calculator
Enter the interactions you counted and the follower total, and 450 interactions on 10,000 followers give an engagement rate of 4.5%. Zero followers returns an error instead of a fake number, and viral posts can pass 100%. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Interactions
- 450
- Followers
- 10,000
- Engagement rate
- 4.5
Social media performance is rarely about raw likes. A post that collected four hundred interactions on an account of ten thousand followers is a very different story from the same four hundred interactions on a million-person audience. Engagement rate by followers is the ratio that makes those two stories comparable: total interactions divided by follower count, multiplied by one hundred, reported as a percent. Use it to score a campaign, compare accounts of different sizes, or gate a report that should never invent a rate when nobody is following yet.
What engagement rate by followers actually measures
The follower-based engagement rate is the workhorse metric of social reporting: how many interactions did this audience produce relative to how large the audience is. Agencies, in-house social teams, and creators use it because raw interaction counts lie at scale. Ten thousand likes looks impressive until you notice the account has twelve million followers; two hundred comments looks modest until you notice the account has eight hundred people.
Dividing total interactions by follower count, then multiplying by one hundred, turns both of those observations into a percent that can be compared across accounts, posts, and time windows of similar length. Interactions here are the sum you already collected for the window you care about — likes, comments, shares, saves, replies, reactions, or whatever the export labels as engagements. This calculator does not fetch posts and does not guess which events count; it computes the ratio from the two numbers you pass.
That split of responsibility is deliberate. Analytics exports disagree about whether a save is an interaction, whether a story reply counts, and whether impressions should replace followers in the denominator. Those product decisions belong in your pipeline.
Inputs, formula, rounding, and the zero-follower error
Negative interactions are rejected because a count of events cannot go below zero in this model. Followers must be greater than zero: engagement rate is undefined when follower count is zero, and the task fails instead of returning Infinity, NaN, or a silent zero. That failure is not billed.
Zero interactions with a positive follower count is valid and yields engagement rate 0, which is the honest reading of a silent post. Example: 450 interactions and 10,000 followers produce 4.5. Rates above 100 percent are allowed; a viral post can collect more interactions than the account has followers when non-followers still like, comment, or share.
Where a deterministic engagement rate calculator earns its keep
Weekly reporting packs need the same formula every Monday, not a spreadsheet cell that someone edited last quarter and forgot. Client dashboards that mix Instagram, TikTok, LinkedIn, and a newsletter should still speak one language for follower-based engagement even when each network counts events differently upstream. Content calendars and A/B tests need a number you can sort, average, and alert on without opening the native analytics UI.
Failed validation does not consume balance. Keep the two inputs in the same window — do not divide last week's comments by this morning's follower count — and you get a reproducible percent for homework, LMS plugins, agency retainers, and edge workers without standing up a social graph crawler of your own. If you need reach-based or impression-based engagement, compute that ratio in a different step with a different denominator; this landing is for the follower-count form that people actually search for as an engagement rate calculator.
What you can do with it
Agency weekly social reports
Turn each account's exported likes, comments, and shares plus its follower count into a comparable engagement rate percent for the Monday pack.
Creator and brand A/B tests
Score two captions or two posting times on the same audience by holding follower count fixed and comparing interaction totals as a rate.
FAQ
What happens if follower count is zero?
Engagement rate is undefined when follower count is zero, so the calculator does not return Infinity, NaN, or a fake zero percent, and the failure is not billed.
What counts as an interaction?
Whatever you already summed for the window: likes, comments, shares, saves, replies, reactions, or an export column named engagements. This calculator does not fetch posts or choose events for you.
Can engagement rate be higher than 100 percent?
Yes. Follower-based rate can exceed 100 percent when people who do not follow the account still interact, or when one follower interacts many times. The formula does not cap the result.
How do I calculate engagement rate by followers?
Divide the total interactions in your period by the follower count and multiply by 100. For example, 450 interactions on an account with 10,000 followers give 450 divided by 10,000, times 100, which is an engagement rate of 4.5%.
Why compare engagement rate instead of total likes?
Because raw counts mislead at scale. Ten thousand likes look impressive until you see twelve million followers behind them. Dividing by the audience turns accounts of very different sizes, and posts from different weeks, into one comparable percentage.
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
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/seo/engagement-rate \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"interactions":450,"followers":10000}'const res = await fetch("https://api.kit.forhosting.com/seo/engagement-rate", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"interactions": 450,
"followers": 10000
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/seo/engagement-rate",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"interactions": 450,
"followers": 10000
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/seo/engagement-rate", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"interactions":450,"followers":10000}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"interactions":450,"followers":10000}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/seo/engagement-rate", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"interactions": 450,
"followers": 10000
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "seo.engagement_rate",
"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
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
max_abs_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
What engagement rate by followers actually measures
What belongs here is a deterministic implementation of engagement_rate = (interactions / followers) × 100, with a hard error when followers is zero so dashboards never render Infinity or a fabricated zero percent.
Inputs, formula, rounding, and the zero-follower error
POST a JSON body with two required finite numbers: interactions, the non-negative total of engagements in the window, and followers, the strictly positive audience size used as the denominator. Each field may arrive as a JSON number or as a numeric string; aliases total_interactions, engagement, and engagements are accepted for the numerator, and follower_count, audience, and fans for the denominator. Missing fields, empty strings, NaN, Infinity, and non-numeric text fail with invalid_input naming the field. On success the body echoes the two inputs, the engagement_rate as a percentage rounded to ten decimal places for stable goldens across runtimes, and a formula string restating engagement_rate = (interactions / followers) * 100. Pair the response with your own benchmarks if you need a traffic-light label; this endpoint returns the percent only.
Integration use cases
Dashboards that must not divide by zero
Gate a new or deleted account with zero followers as invalid_input instead of rendering Infinity in a chart or inventing a zero rate.
Technical questions
How is engagement rate calculated from interactions and followers?
engagement_rate = (interactions / followers) × 100. Send a non-negative interaction total and a follower count greater than zero; the API returns the percentage.
What does the engagement rate calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.