# Social Media Intelligence > Social media monitoring, narrative tracking, and open-source intelligence for journalists. Use when tracking viral content spread, analyzing coordinated campaigns, monitoring breaking news on social platforms, investigating accounts for authenticity, or detecting misinformation patterns. Essential for reporters covering online narratives and digital investigations. - **Type:** Skill - **Install:** `agentstack add skill-jamditis-claude-skills-journalism-social-media-intelligence` - **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior - **Seller:** [jamditis](https://agentstack.voostack.com/s/jamditis) - **Installs:** 0 - **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills) - **Latest version:** 0.1.0 - **License:** MIT - **Upstream author:** [jamditis](https://github.com/jamditis) - **Source:** https://github.com/jamditis/claude-skills-journalism/tree/master/journalism-core/skills/social-media-intelligence - **Website:** https://skills.amditis.tech/ ## Install ```sh agentstack add skill-jamditis-claude-skills-journalism-social-media-intelligence ``` Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent. ## About # Social media intelligence Systematic approaches for monitoring, analyzing, and investigating social media for journalism. ## When to activate - Tracking how a story spreads across platforms - Investigating potential coordinated inauthentic behavior - Monitoring breaking news across social platforms - Analyzing account networks and relationships - Detecting bot activity or manipulation campaigns - Building evidence trails for digital investigations - Archiving social content before deletion ## Real-time monitoring ### Multi-platform tracker ```python from dataclasses import dataclass, field from datetime import datetime from typing import List, Optional, Dict from enum import Enum import hashlib class Platform(Enum): TWITTER = "twitter" # X since 2023; "twitter" retained for legacy data FACEBOOK = "facebook" INSTAGRAM = "instagram" TIKTOK = "tiktok" YOUTUBE = "youtube" REDDIT = "reddit" THREADS = "threads" BLUESKY = "bluesky" MASTODON = "mastodon" TELEGRAM = "telegram" @dataclass class SocialPost: platform: Platform post_id: str author: str content: str timestamp: datetime url: str engagement: Dict[str, int] = field(default_factory=dict) media_urls: List[str] = field(default_factory=list) archived_urls: List[str] = field(default_factory=list) content_hash: str = "" def __post_init__(self): # Hash content for duplicate detection self.content_hash = hashlib.md5( f"{self.platform.value}:{self.content}".encode() ).hexdigest() @dataclass class MonitoringQuery: keywords: List[str] platforms: List[Platform] accounts: List[str] = field(default_factory=list) hashtags: List[str] = field(default_factory=list) exclude_terms: List[str] = field(default_factory=list) start_date: Optional[datetime] = None def to_search_string(self, platform: Platform) -> str: """Generate platform-specific search query.""" parts = [] # Keywords if self.keywords: parts.append(' OR '.join(f'"{k}"' for k in self.keywords)) # Hashtags if self.hashtags: parts.append(' OR '.join(f'#{h}' for h in self.hashtags)) # Exclusions if self.exclude_terms: parts.append(' '.join(f'-{t}' for t in self.exclude_terms)) return ' '.join(parts) ``` ### Breaking news monitor ```python from collections import defaultdict from datetime import datetime, timedelta class BreakingNewsDetector: """Detect sudden spikes in keyword mentions.""" def __init__(self, baseline_window_hours: int = 24): self.baseline_window = timedelta(hours=baseline_window_hours) self.mention_history = defaultdict(list) def add_mention(self, keyword: str, timestamp: datetime): """Record a mention of a keyword.""" self.mention_history[keyword].append(timestamp) # Prune old data cutoff = datetime.now() - self.baseline_window * 2 self.mention_history[keyword] = [ t for t in self.mention_history[keyword] if t > cutoff ] def is_spiking(self, keyword: str, threshold_multiplier: float = 3.0) -> bool: """Check if keyword is spiking above baseline.""" now = datetime.now() recent = sum(1 for t in self.mention_history[keyword] if t > now - timedelta(hours=1)) baseline_hourly = len([ t for t in self.mention_history[keyword] if t > now - self.baseline_window ]) / self.baseline_window.total_seconds() * 3600 if baseline_hourly == 0: return recent > 10 # Arbitrary threshold for new topics return recent > baseline_hourly * threshold_multiplier def get_trending(self, top_n: int = 10) -> List[tuple]: """Get keywords sorted by spike intensity.""" spikes = [] for keyword in self.mention_history: if self.is_spiking(keyword): recent = sum(1 for t in self.mention_history[keyword] if t > datetime.now() - timedelta(hours=1)) spikes.append((keyword, recent)) return sorted(spikes, key=lambda x: x[1], reverse=True)[:top_n] ``` ## Account analysis ### Authenticity indicators ```python from dataclasses import dataclass from datetime import datetime from typing import List, Optional @dataclass class AccountAnalysis: username: str platform: Platform created_date: Optional[datetime] = None follower_count: int = 0 following_count: int = 0 post_count: int = 0 # Authenticity signals profile_photo_is_stock: Optional[bool] = None bio_contains_keywords: List[str] = field(default_factory=list) posts_primarily_reshares: Optional[bool] = None posting_pattern_irregular: Optional[bool] = None engagement_ratio_suspicious: Optional[bool] = None def calculate_red_flags(self) -> dict: """Score account authenticity.""" flags = {} # Account age if self.created_date: age_days = (datetime.now() - self.created_date).days if age_days 0: ratio = self.follower_count / self.following_count if ratio 0: age_days = max(1, (datetime.now() - self.created_date).days) posts_per_day = self.post_count / age_days if posts_per_day > 50: flags['excessive_posting'] = f"{posts_per_day:.0f} posts/day" # Stock photo check if self.profile_photo_is_stock: flags['stock_profile_photo'] = "Profile appears to be stock image" return flags def authenticity_score(self) -> int: """0-100 score, higher = more likely authentic.""" score = 100 flags = self.calculate_red_flags() penalty_per_flag = 20 score -= len(flags) * penalty_per_flag return max(0, score) ``` ### Network mapping ```python from collections import defaultdict from typing import Set, Dict class AccountNetwork: """Map relationships between accounts.""" def __init__(self): self.interactions = defaultdict(lambda: defaultdict(int)) self.accounts = {} def add_interaction(self, from_account: str, to_account: str, interaction_type: str = "mention"): """Record an interaction between accounts.""" self.interactions[from_account][to_account] += 1 def find_clusters(self, min_interactions: int = 3) -> List[Set[str]]: """Find groups of accounts that frequently interact.""" # Build adjacency with minimum threshold adjacency = defaultdict(set) for from_acc, targets in self.interactions.items(): for to_acc, count in targets.items(): if count >= min_interactions: adjacency[from_acc].add(to_acc) adjacency[to_acc].add(from_acc) # Find connected components visited = set() clusters = [] for account in adjacency: if account in visited: continue cluster = set() stack = [account] while stack: current = stack.pop() if current in visited: continue visited.add(current) cluster.add(current) stack.extend(adjacency[current] - visited) if len(cluster) > 1: clusters.append(cluster) return sorted(clusters, key=len, reverse=True) def coordination_score(self, accounts: Set[str]) -> float: """Score how coordinated a group of accounts appears.""" if len(accounts) 0: actual_connections += 1 return actual_connections / total_possible if total_possible > 0 else 0 ``` ## Narrative tracking ### Claim propagation tracker ```python from dataclasses import dataclass, field from datetime import datetime from typing import List, Dict, Optional @dataclass class Claim: text: str first_seen: datetime first_seen_url: str variations: List[str] = field(default_factory=list) appearances: List[Dict] = field(default_factory=list) def add_appearance(self, url: str, platform: Platform, timestamp: datetime, author: str): """Track where this claim has appeared.""" self.appearances.append({ 'url': url, 'platform': platform.value, 'timestamp': timestamp, 'author': author }) def spread_timeline(self) -> List[Dict]: """Get chronological spread of the claim.""" return sorted(self.appearances, key=lambda x: x['timestamp']) def platforms_reached(self) -> Dict[str, int]: """Count appearances by platform.""" counts = defaultdict(int) for app in self.appearances: counts[app['platform']] += 1 return dict(counts) def velocity(self, window_hours: int = 24) -> float: """Calculate spread rate in appearances per hour.""" if not self.appearances: return 0.0 recent = [ a for a in self.appearances if a['timestamp'] > datetime.now() - timedelta(hours=window_hours) ] return len(recent) / window_hours ``` ### Hashtag analysis ```python from collections import Counter from datetime import datetime, timedelta class HashtagAnalyzer: """Analyze hashtag usage patterns.""" def __init__(self): self.hashtag_posts = defaultdict(list) def add_post(self, hashtags: List[str], post: SocialPost): """Record a post's hashtags.""" for tag in hashtags: self.hashtag_posts[tag.lower()].append(post) def co_occurrence(self, hashtag: str, top_n: int = 10) -> List[tuple]: """Find hashtags that commonly appear with this one.""" co_tags = Counter() for post in self.hashtag_posts.get(hashtag.lower(), []): # Extract hashtags from post content tags = [ word.lower() for word in post.content.split() if word.startswith('#') ] for tag in tags: if tag != f'#{hashtag.lower()}': co_tags[tag] += 1 return co_tags.most_common(top_n) def posting_pattern(self, hashtag: str) -> Dict: """Analyze when posts with this hashtag appear.""" posts = self.hashtag_posts.get(hashtag.lower(), []) hour_counts = Counter(p.timestamp.hour for p in posts) day_counts = Counter(p.timestamp.strftime('%A') for p in posts) return { 'by_hour': dict(hour_counts), 'by_day': dict(day_counts), 'total_posts': len(posts), 'unique_authors': len(set(p.author for p in posts)) } ``` ## Evidence preservation ### Archive before it disappears For full archiving workflows (rate limits, batch jobs, recovery from broken archive UIs), see the **web-archiving** skill. ```python import re import requests from datetime import datetime from typing import Optional from urllib.parse import quote, urljoin class SocialArchiver: """Archive social content before deletion.""" def __init__(self): self.archived = {} def archive_to_wayback(self, url: str) -> Optional[str]: """Submit URL to Internet Archive. Anonymous saves are rate-limited at roughly 15/minute and silently drop some paywalled or heavily JS-rendered pages. For high-volume archiving, register an Internet Archive S3 key and add an Authorization header. """ try: save_url = f"https://web.archive.org/save/{quote(url, safe='')}" response = requests.get(save_url, timeout=30) if response.status_code == 200: archived_url = response.url self.archived[url] = { 'wayback': archived_url, 'archived_at': datetime.now().isoformat(), } return archived_url except Exception as e: print(f"Wayback archive failed: {e}") return None def archive_to_archive_today(self, url: str) -> Optional[str]: """Submit URL to archive.today. Operational notes (2026): the FBI subpoenaed archive.today's registrar in October 2025 to identify the operator; Wikipedia voted in February 2026 to stop accepting it as a citation source after the site shipped DDoS-attack code in January 2026. The service is still useful for capturing content the Wayback Machine can't render, but treat it as secondary to the Internet Archive and document any reliance on it. It also rate-limits aggressively and serves CAPTCHAs to scrapers. """ try: response = requests.post( 'https://archive.today/submit/', data={'url': url, 'anyway': '1'}, timeout=60, allow_redirects=False, headers={'User-Agent': 'Mozilla/5.0 (verification archive bot)'}, ) # archive.today returns the snapshot URL in one of two shapes: # - 30x with Location: https://archive.today/ # - 200 with Refresh: 0;url=https://archive.today/ # Following redirects silently can land on /wip/ pages or hide the # canonical snapshot URL, so handle both headers explicitly. if response.status_code in (301, 302, 303, 307, 308): location = response.headers.get('Location') if location: # Location MAY be relative per RFC 7231; resolve against request URL. return urljoin(response.url, location) if response.status_code == 200: refresh = response.headers.get('Refresh', '') # Refresh keyword is case-insensitive per HTML spec; values may # contain ;-separated params. Match the url= directive itself. m = re.search(r'\burl\s*=\s*(.+)', refresh, re.IGNORECASE) if m: target = m.group(1).strip().strip('\'"') return urljoin(response.url, target) except Exception as e: print(f"archive.today failed: {e}") return None def full_archive(self, url: str) -> dict: """Archive to multiple services for redundancy.""" results = { 'original_url': url, 'archived_at': datetime.now().isoformat(), 'archives': {}, } wayback = self.archive_to_wayback(url) if wayback: results['archives']['wayback'] = wayback archive_today = self.archive_to_archive_today(url) if archive_today: results['archives']['archive_today'] = archive_today return results ``` ## Coordination detection ### Behavioral signals checklist ```markdown ## Coordinated inauthentic behavior indicators ### Timing patterns - [ ] Multiple accounts posting same content within minutes - [ ] Synchronized posting times across accounts - [ ] Burst activity followed by dormancy - [ ] Posts appear faster than human typing speed ### Content patterns - [ ] Identical or near-identical text across accounts - [ ] Same images/media shared by multiple accounts - [ ] Identical typos or formatting errors - [ ] Copy-paste artifacts visible ### Account patterns - [ ] Accounts created around same time - [ ] Similar naming conventions (name + numbers) - [ ] Generic or stock profile photos - [ ] Minimal personal content, mostly shares - [ ] Follow the same accounts - [ ] Engage with each other disproportionately ### Network patterns - [ ] Form dense clusters in network analysis - [ ] Amplify same external sources - [ ] Target same accounts or hashtags - [ ] Cross-pl … ## Source & license This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code. - **Author:** [jamditis](https://github.com/jamditis) - **Source:** [jamditis/claude-skills-journalism](https://github.com/jamditis/claude-skills-journalism) - **License:** MIT - **Homepage:** https://skills.amditis.tech/ Install and usage instructions live in the source repository linked above. ## Pricing - **Free** — Free ## Security capabilities Automated source analysis of v0.1.0 — what this tool can access: - **Network access:** yes - **Filesystem access:** no - **Shell / process execution:** no - **Environment & secrets:** no - **Dynamic code execution:** no *"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.* ## Versions - **0.1.0** — security scan: passed — Imported from the upstream source. ## Links - Listing page: https://agentstack.voostack.com/l/skill-jamditis-claude-skills-journalism-social-media-intelligence - Seller: https://agentstack.voostack.com/s/jamditis - Browse the marketplace: https://agentstack.voostack.com/browse --- Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.