Back to Blog
Tutorial

Facebook Page Analytics Without Admin Access: Track Any Competitor

April 21, 2026
7 min read
S
By SociaVault Team
FacebookAnalyticsCompetitor AnalysisSocial Media DataAPI

Facebook Page Analytics Without Admin Access: Track Any Competitor

Facebook's native analytics only work for pages you manage. You can see your own Page Insights, but you can't see a competitor's follower growth, engagement rates, or posting frequency. That's a massive blind spot.

With SociaVault's API, you can pull public data from any Facebook page — no admin access required. Here's how to analyze competitors, track page performance, and benchmark your own results.

Get Any Facebook Page's Profile

Pull comprehensive page data including followers, likes, and basic info:

const API_KEY = process.env.SOCIAVAULT_API_KEY;
const BASE = 'https://api.sociavault.com/v1/scrape';
const headers = { 'X-API-Key': API_KEY };

async function getFacebookPage(handle) {
  const res = await fetch(
    `${BASE}/facebook/profile?handle=${encodeURIComponent(handle)}`,
    { headers }
  );
  const data = (await res.json()).data;

  if (!data) {
    console.log(`Page not found: ${handle}`);
    return null;
  }

  console.log(`\nFacebook Page: ${data.name || handle}`);
  console.log(`  Followers: ${(data.followers || data.follower_count || 0).toLocaleString()}`);
  console.log(`  Likes: ${(data.likes || data.like_count || 0).toLocaleString()}`);
  console.log(`  Category: ${data.category || 'N/A'}`);
  console.log(`  Website: ${data.website || 'N/A'}`);
  console.log(`  Description: ${(data.about || data.description || '').substring(0, 200)}`);

  return data;
}

getFacebookPage('cocacola');

Python version:

import os
import requests

API_KEY = os.environ["SOCIAVAULT_API_KEY"]
BASE = "https://api.sociavault.com/v1/scrape"
HEADERS = {"X-API-Key": API_KEY}

def get_facebook_page(handle):
    r = requests.get(f"{BASE}/facebook/profile", headers=HEADERS, params={"handle": handle})
    data = r.json().get("data", {})

    if not data:
        print(f"Page not found: {handle}")
        return None

    followers = data.get("followers") or data.get("follower_count", 0)
    likes = data.get("likes") or data.get("like_count", 0)

    print(f"\nFacebook Page: {data.get('name', handle)}")
    print(f"  Followers: {followers:,}")
    print(f"  Likes: {likes:,}")
    print(f"  Category: {data.get('category', 'N/A')}")

    return data

get_facebook_page("cocacola")

Analyze Page Posts

Pull recent posts and analyze engagement patterns:

async function analyzePagePosts(handle) {
  const res = await fetch(
    `${BASE}/facebook/profile/posts?handle=${encodeURIComponent(handle)}`,
    { headers }
  );
  const posts = (await res.json()).data || [];

  if (posts.length === 0) {
    console.log('No posts found');
    return;
  }

  // Calculate engagement metrics
  const metrics = posts.map(post => {
    const reactions = post.reactions || post.reaction_count || post.likes || 0;
    const comments = post.comments || post.comment_count || 0;
    const shares = post.shares || post.share_count || 0;
    const totalEng = reactions + comments + shares;

    return {
      text: (post.text || post.message || '').substring(0, 100),
      reactions,
      comments,
      shares,
      totalEng,
      type: post.type || post.media_type || 'unknown'
    };
  });

  // Sort by engagement
  metrics.sort((a, b) => b.totalEng - a.totalEng);

  // Summary stats
  const avgEng = metrics.reduce((s, m) => s + m.totalEng, 0) / metrics.length;
  const avgReactions = metrics.reduce((s, m) => s + m.reactions, 0) / metrics.length;
  const avgComments = metrics.reduce((s, m) => s + m.comments, 0) / metrics.length;
  const avgShares = metrics.reduce((s, m) => s + m.shares, 0) / metrics.length;

  console.log(`\nPost Analysis: ${handle}`);
  console.log(`  Posts analyzed: ${metrics.length}`);
  console.log(`  Avg reactions: ${Math.round(avgReactions).toLocaleString()}`);
  console.log(`  Avg comments: ${Math.round(avgComments).toLocaleString()}`);
  console.log(`  Avg shares: ${Math.round(avgShares).toLocaleString()}`);
  console.log(`  Avg total engagement: ${Math.round(avgEng).toLocaleString()}`);

  console.log(`\n  Top 3 Posts:`);
  metrics.slice(0, 3).forEach((m, i) => {
    console.log(`  ${i + 1}. "${m.text}..." — ${m.totalEng.toLocaleString()} engagement`);
  });

  return { handle, postCount: metrics.length, avgEng: Math.round(avgEng), posts: metrics };
}

analyzePagePosts('nike');

Compare Competitor Pages

Run a side-by-side comparison of multiple Facebook pages:

async function comparePages(handles) {
  const results = [];

  for (const handle of handles) {
    // Get profile
    const profileRes = await fetch(
      `${BASE}/facebook/profile?handle=${encodeURIComponent(handle)}`,
      { headers }
    );
    const profile = (await profileRes.json()).data;

    // Get posts
    const postsRes = await fetch(
      `${BASE}/facebook/profile/posts?handle=${encodeURIComponent(handle)}`,
      { headers }
    );
    const posts = (await postsRes.json()).data || [];

    const followers = profile?.followers || profile?.follower_count || 0;
    const totalEng = posts.reduce((sum, p) => {
      return sum + (p.reactions || p.reaction_count || p.likes || 0) 
                  + (p.comments || p.comment_count || 0) 
                  + (p.shares || p.share_count || 0);
    }, 0);
    const avgEng = posts.length > 0 ? Math.round(totalEng / posts.length) : 0;

    results.push({
      handle,
      name: profile?.name || handle,
      followers,
      likes: profile?.likes || profile?.like_count || 0,
      recentPosts: posts.length,
      avgEngagement: avgEng,
      engRate: followers > 0 ? ((avgEng / followers) * 100).toFixed(3) : '0'
    });

    await new Promise(r => setTimeout(r, 1500));
  }

  results.sort((a, b) => b.followers - a.followers);

  console.log('\nFacebook Page Comparison:');
  console.table(results.map(r => ({
    Page: r.name,
    Followers: r.followers.toLocaleString(),
    Likes: r.likes.toLocaleString(),
    'Avg Eng': r.avgEngagement.toLocaleString(),
    'ER %': r.engRate
  })));

  return results;
}

comparePages(['cocacola', 'pepsi', 'drpepper', 'redbull']);

Content Type Performance Analysis

Understand which types of posts perform best for a page:

async function analyzeContentTypes(handle) {
  const postsRes = await fetch(
    `${BASE}/facebook/profile/posts?handle=${encodeURIComponent(handle)}`,
    { headers }
  );
  const posts = (await postsRes.json()).data || [];

  const types = {};

  for (const post of posts) {
    const type = post.type || post.media_type || 'text';
    if (!types[type]) {
      types[type] = { count: 0, totalEng: 0 };
    }
    types[type].count++;
    types[type].totalEng += (post.reactions || post.reaction_count || post.likes || 0)
                           + (post.comments || post.comment_count || 0)
                           + (post.shares || post.share_count || 0);
  }

  console.log(`\nContent Type Performance: ${handle}`);
  console.log('─'.repeat(50));

  for (const [type, data] of Object.entries(types)) {
    const avg = Math.round(data.totalEng / data.count);
    console.log(`  ${type.padEnd(15)} ${data.count} posts — avg eng: ${avg.toLocaleString()}`);
  }
}

analyzeContentTypes('nike');

Facebook Content Performance Benchmarks

Content TypeAverage ERNotes
Video (native)0.15-0.30%Best performing format on Facebook
Live Video0.20-0.50%Highest reach per follower
Image0.10-0.20%Bread and butter content
Link0.05-0.10%Lowest engagement (links reduce reach)
Text only0.08-0.15%Works for engagement bait
Reels0.15-0.35%Growing reach, Meta pushing these

Facebook Group Intelligence

You can also monitor public Facebook Groups related to your industry:

async function analyzeGroup(groupUrl) {
  const res = await fetch(
    `${BASE}/facebook/group?url=${encodeURIComponent(groupUrl)}`,
    { headers }
  );
  const data = (await res.json()).data;

  if (!data) {
    console.log('Group not found');
    return null;
  }

  console.log(`\nGroup: ${data.name || 'Unknown'}`);
  console.log(`  Members: ${(data.members || data.member_count || 0).toLocaleString()}`);
  console.log(`  Privacy: ${data.privacy || 'N/A'}`);
  console.log(`  Description: ${(data.description || '').substring(0, 200)}`);

  return data;
}

Tracking Page Growth Over Time

Facebook doesn't provide historical data, but you can build your own by snapshotting daily:

import os
import json
import requests
from datetime import date

API_KEY = os.environ["SOCIAVAULT_API_KEY"]
BASE = "https://api.sociavault.com/v1/scrape"
HEADERS = {"X-API-Key": API_KEY}

def snapshot_pages(handles, filename="fb-snapshots.json"):
    """Take daily snapshots of Facebook page metrics"""
    
    # Load existing snapshots
    try:
        with open(filename) as f:
            snapshots = json.load(f)
    except (FileNotFoundError, json.JSONDecodeError):
        snapshots = []

    today = str(date.today())
    daily = {"date": today, "pages": {}}

    for handle in handles:
        r = requests.get(f"{BASE}/facebook/profile", headers=HEADERS, params={"handle": handle})
        data = r.json().get("data", {})
        
        daily["pages"][handle] = {
            "followers": data.get("followers") or data.get("follower_count", 0),
            "likes": data.get("likes") or data.get("like_count", 0),
        }

        import time
        time.sleep(1)

    snapshots.append(daily)

    with open(filename, "w") as f:
        json.dump(snapshots, f, indent=2)

    print(f"Snapshot saved for {today}: {len(daily['pages'])} pages")

    # Show growth if we have previous data
    if len(snapshots) >= 2:
        prev = snapshots[-2]
        print(f"\nGrowth since {prev['date']}:")
        for handle in handles:
            curr = daily["pages"].get(handle, {}).get("followers", 0)
            old = prev["pages"].get(handle, {}).get("followers", 0)
            if old > 0:
                change = curr - old
                pct = (change / old * 100)
                print(f"  {handle}: {change:+,} ({pct:+.2f}%)")

# Run daily via cron
snapshot_pages(["cocacola", "pepsi", "nike", "adidas"])

Facebook Analytics vs. Native Insights

FeatureNative Facebook InsightsSociaVault API
Your own page✅ Full access✅
Competitor pages❌ No access✅ Public data
Post-level stats✅ Detailed✅ Reactions, comments, shares
Historical data✅ Up to 2 yearsBuild your own with snapshots
API accessMeta Business Suite API (complex)Simple REST API
CostFree (for your page)1 credit per request
Demographics✅ For your page❌

The key value: competitor data. Facebook gives you zero visibility into competitor performance through native tools.

Get Started

Sign up free — start tracking any Facebook page's performance today.

Found this helpful?

Share it with others who might benefit

Share on X

Ready to Try SociaVault?

Start extracting social media data with our powerful API. No credit card required.

Get Started FreeView Documentation