Likes per follower
A big account with few likes per post reaches a smaller share of its audience than its follower count suggests. The rate puts accounts of different sizes on the same scale.
Enter an Instagram username or profile URL to see its engagement rate from the likes on its recent posts, with average likes, average video views and the API calls that return the same data.
Up to 12 recent posts per calculation. Likes only; collaboration posts by other accounts are left out.
nasa or @nasa, or its address (instagram.com/nasa).The calculator reads the profile's 12 most recent posts and keeps the ones the profile published itself. It adds up their likes, divides by the number of posts to get the average likes per post, then divides that by the follower count and multiplies by 100.
Engagement rate = average likes per post ÷ followers × 100
A big account with few likes per post reaches a smaller share of its audience than its follower count suggests. The rate puts accounts of different sizes on the same scale.
Reels and videos also show how many times they were played. The calculator shows the average views per video next to the rate, so you can see how far the videos travel beyond the followers.
The calculator reads what a public profile shows anyone who opens it. A private account's posts aren't public, so it can't be calculated; email and phone are never shown.
Meta's Instagram Graph API returns likes, comments and reach for your own professional (business or creator) account, and Business Discovery returns basic numbers for other business accounts, once your app has passed App Review and you have a Facebook Page linked to the account. To check any public profile, including accounts that aren't business accounts, the SocialAPIs API returns the public numbers with one API key.
Every calculation is two calls to the SocialAPIs REST API: the profile for the follower count, then its recent posts for the likes and views. Use the same calls to compare many profiles, track engagement every week, or feed a dashboard, from any language or from n8n, Make and Zapier.
GET /instagram/profile/details then GET /instagram/profile/posts, both with username · 2 credits per calculation (1 per call) · your key goes in the x-api-token header, never in the URL.
# Step 1: the follower count
curl -G "https://api.socialapis.io/instagram/profile/details" \
--max-time 100 \
--fail-with-body \
-H "x-api-token: $SOCIALAPIS_API_KEY" \
--data-urlencode "username=nasa"
# Step 2: the recent posts (likes, video views)
curl -G "https://api.socialapis.io/instagram/profile/posts" \
--max-time 100 \
--fail-with-body \
-H "x-api-token: $SOCIALAPIS_API_KEY" \
--data-urlencode "username=nasa"import os
import requests
API = "https://api.socialapis.io"
HEADERS = {"x-api-token": os.environ["SOCIALAPIS_API_KEY"]}
USERNAME = "nasa"
# Step 1: the follower count
profile = requests.get(f"{API}/instagram/profile/details", params={"username": USERNAME}, headers=HEADERS, timeout=100)
profile.raise_for_status()
followers = profile.json()["data"]["followers_count"]
# Step 2: the recent posts (likes, video views)
posts = requests.get(f"{API}/instagram/profile/posts", params={"username": USERNAME}, headers=HEADERS, timeout=100)
posts.raise_for_status()
# Only the profile's own posts (collaboration posts by other accounts are left out),
# and only posts whose like count is shown.
own = [
p for p in posts.json()["data"]["posts"]
if (p.get("owner") or {}).get("username", "").lower() == USERNAME.lower()
and not p.get("like_and_view_counts_disabled")
and p.get("like_count") is not None
]
if own and followers:
avg_likes = sum(p["like_count"] for p in own) / len(own)
print(f"{len(own)} posts, {avg_likes:,.0f} likes on average")
print(f"Engagement rate (likes): {avg_likes / followers * 100:.2f}%")
// Node 18+, as an ES module (e.g. main.mjs)
async function get(url, params) {
const query = new URLSearchParams(params).toString();
const response = await fetch(query ? `${url}?${query}` : url, {
headers: { "x-api-token": process.env.SOCIALAPIS_API_KEY },
signal: AbortSignal.timeout(100000),
});
if (!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`);
return response.json();
}
// Step 1: the follower count
let data = await get("https://api.socialapis.io/instagram/profile/details", {
username: "nasa",
});
console.log(data);
// Step 2: the recent posts (likes, video views)
data = await get("https://api.socialapis.io/instagram/profile/posts", {
username: "nasa",
});
console.log(data);import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.Map;
import java.util.stream.Collectors;
public class Main {
private static final HttpClient CLIENT = HttpClient.newBuilder()
.connectTimeout(Duration.ofSeconds(10))
.build();
public static void main(String[] args) throws Exception {
// Step 1: the follower count
String body = get("https://api.socialapis.io/instagram/profile/details", Map.of(
"username", "nasa"));
System.out.println(body);
// Step 2: the recent posts (likes, video views)
body = get("https://api.socialapis.io/instagram/profile/posts", Map.of(
"username", "nasa"));
System.out.println(body);
}
static String get(String url, Map<String, String> params) throws Exception {
String query = params.entrySet().stream()
.map(e -> URLEncoder.encode(e.getKey(), StandardCharsets.UTF_8) + "="
+ URLEncoder.encode(e.getValue(), StandardCharsets.UTF_8))
.collect(Collectors.joining("&"));
HttpRequest request = HttpRequest.newBuilder(URI.create(query.isEmpty() ? url : url + "?" + query))
.header("x-api-token", System.getenv("SOCIALAPIS_API_KEY"))
.timeout(Duration.ofSeconds(100))
.GET()
.build();
HttpResponse<String> response = CLIENT.send(request, HttpResponse.BodyHandlers.ofString());
if (response.statusCode() / 100 != 2) {
throw new RuntimeException("HTTP " + response.statusCode() + ": " + response.body());
}
return response.body();
}
}package main
import (
"fmt"
"io"
"log"
"net/http"
"net/url"
"os"
"time"
)
func main() {
// Step 1: the follower count
body, err := get("https://api.socialapis.io/instagram/profile/details", url.Values{
"username": {"nasa"},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(string(body))
// Step 2: the recent posts (likes, video views)
body, err = get("https://api.socialapis.io/instagram/profile/posts", url.Values{
"username": {"nasa"},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(string(body))
}
func get(endpoint string, params url.Values) ([]byte, error) {
if len(params) > 0 {
endpoint += "?" + params.Encode()
}
req, err := http.NewRequest(http.MethodGet, endpoint, nil)
if err != nil {
return nil, err
}
req.Header.Set("x-api-token", os.Getenv("SOCIALAPIS_API_KEY"))
client := &http.Client{Timeout: 100 * time.Second}
resp, err := client.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
if err != nil {
return nil, err
}
if resp.StatusCode/100 != 2 {
return nil, fmt.Errorf("HTTP %d: %s", resp.StatusCode, body)
}
return body, nil
}Set SOCIALAPIS_API_KEY to your key first (export SOCIALAPIS_API_KEY=…). Step 1's data has followers_count; step 2's data.posts has the 12 most recent posts, each with like_count, video_view_count (videos) and owner.username. Calls that return data are charged, including empty results; errors (4xx/5xx) are not charged.
Enter the username (for example nasa) or the profile address (instagram.com/nasa) into the calculator above. It reads the profile's follower count and its 12 most recent posts, averages the likes on the posts the profile published itself, and divides that average by the follower count, times 100.
No. The rate counts likes only, because the recent posts list returns likes and video views but no comment count. Formulas that add comments to likes give a slightly higher number, so compare rates calculated the same way.
Collaboration posts appear on several profiles at once; the calculator keeps only the posts published by the profile you entered, so another account's audience doesn't change the result. Posts whose owner hid the like count are left out too. The result says how many posts were analysed.
No. A private account shows its follower count publicly but not its posts, so there is nothing to average. The calculator says the account is private and stops after the profile check. Email addresses and phone numbers are never shown for any account.
Without an account you get a few free calculations a day to try it. Signed in, each calculation is two API calls on your own account: 2 credits, with no daily limit beyond your plan. Calls that return data are charged, including empty results; errors (4xx/5xx) are not charged. The free plan includes 200 calls a month, no credit card; paid plans start at $4.99 a month.
Use the API: call GET /instagram/profile/details and GET /instagram/profile/posts with username for each profile, from a script, a spreadsheet or a no-code tool like n8n, Make or Zapier, and store the averages every week to chart them. The code below is the exact pair of calls this calculator makes.
The same API covers public Facebook Pages: followers, likes, posts and the ads a Page runs. There are free Facebook follower count and ad checker tools on this site. SocialAPIs covers Facebook and Instagram.
SocialAPIs (socialapis.io) is a public Facebook and Instagram data API. Free plan: 200 calls a month, no credit card. Paid plans from $4.99 a month. One x-api-token header.
Instagram follower count · Facebook follower count · Facebook ad checker