Tiktok Trend Radar

Automated TikTok & Instagram Trend Radar Skill

Overview

This skill builds a fully automated trend monitoring pipeline that: 1. Scrapes TikTok and Instagram in real-time using Apify 2. Sends trend data into Claude (via OpenClaw) for AI analysis 3. Automatically generates content ideas, video scripts, and hashtag explosion alerts 4. Produces ready-to-publish short videos via InVideo AI

The result: you know what's trending *before* everyone else — and you already have the content ready.

> 🔗 Apify: https://www.apify.com/?fpr=dx06p > 🔗 InVideo: https://invideo.sjv.io/TBB

What This Skill Does

Architecture Overview

┌─────────────────────────────────────────────────────────────┐
│                    TREND RADAR PIPELINE                     │
│                                                             │
│  ┌──────────┐    ┌──────────┐    ┌──────────────────────┐  │
│  │  Apify   │───▶│  Trend   │───▶│   Claude / OpenClaw  │  │
│  │ Scraper  │    │ Detector │    │   AI Analysis Engine │  │
│  │TikTok +  │    │(spike    │    │                      │  │
│  │Instagram │    │detection)│    │ • Content ideas      │  │
│  └──────────┘    └──────────┘    │ • Script generation  │  │
│                                  │ • Hashtag insights   │  │
│                                  └──────────┬───────────┘  │
│                                             │               │
│                         ┌───────────────────▼────────────┐ │
│                         │       InVideo AI               │ │
│                         │   Auto Video Production        │ │
│                         │   (script → MP4 in minutes)    │ │
│                         └───────────────────┬────────────┘ │
│                                             │               │
│                         ┌───────────────────▼────────────┐ │
│                         │         ALERTS & OUTPUT        │ │
│                         │  Slack / Email / Webhook / CMS │ │
│                         └────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘

Step 1 — Get Your API Keys

Apify

   export APIFY_TOKEN=apify_api_xxxxxxxxxxxxxxxx
   

InVideo

   export INVIDEO_API_KEY=iv_api_xxxxxxxxxxxxxxxx
   

OpenClaw / Claude API

   export CLAUDE_API_KEY=sk-ant-xxxxxxxxxxxxxxxx
   

Step 2 — Install Dependencies

npm install apify-client axios node-cron

Full Pipeline Implementation

Module 1 — Scrape TikTok & Instagram Trends

import ApifyClient from 'apify-client';
const apify = new ApifyClient({ token: process.env.APIFY_TOKEN });
// Define hashtags to monitor
const WATCHED_HASHTAGS = [
  "viral", "trending", "fyp", "lifehack",
  "productivity", "ai", "money", "fitness"
];
async function scrapeTikTokTrends() {
  const run = await apify.actor("apify/tiktok-hashtag-scraper").call({
    hashtags: WATCHED_HASHTAGS,
    resultsPerPage: 50,
    shouldDownloadVideos: false
  });
  const { items } = await run.dataset().getData();
  return items.map(item => ({
    platform: "tiktok",
    hashtag: item.hashtag,
    postCount: item.viewCount,
    likes: item.diggCount,
    shares: item.shareCount,
    comments: item.commentCount,
    description: item.text,
    author: item.authorMeta?.name,
    createdAt: item.createTime,
    url: item.webVideoUrl
  }));
}
async function scrapeInstagramTrends() {
  const run = await apify.actor("apify/instagram-hashtag-scraper").call({
    hashtags: WATCHED_HASHTAGS,
    resultsLimit: 50
  });
  const { items } = await run.dataset().getData();
  return items.map(item => ({
    platform: "instagram",
    hashtag: item.hashtags?.[0] || "unknown",
    likes: item.likesCount,
    comments: item.commentsCount,
    description: item.caption,
    author: item.ownerUsername,
    createdAt: item.timestamp,
    url: item.url
  }));
}
async function scrapeAllPlatforms() {
  const [tiktok, instagram] = await Promise.all([
    scrapeTikTokTrends(),
    scrapeInstagramTrends()
  ]);
  return [...tiktok, ...instagram];
}

Module 2 — Hashtag Explosion Detector

// In-memory baseline (use a database like Redis for production)
const baseline = {};
function detectExplosions(currentData) {
  const alerts = [];
  // Group by hashtag and calculate engagement scores
  const grouped = currentData.reduce((acc, post) => {
    if (!acc[post.hashtag]) acc[post.hashtag] = { posts: 0, totalLikes: 0, platforms: new Set() };
    acc[post.hashtag].posts++;
    acc[post.hashtag].totalLikes += post.likes || 0;
    acc[post.hashtag].platforms.add(post.platform);
    return acc;
  }, {});
  for (const [hashtag, stats] of Object.entries(grouped)) {
    const prev = baseline[hashtag] || { posts: 0, totalLikes: 0 };
    const growthRate = prev.posts > 0
      ? ((stats.posts - prev.posts) / prev.posts) * 100
      : 100;
    // Alert if posts grew more than 40% since last check
    if (growthRate > 40) {
      alerts.push({
        hashtag,
        growthRate: Math.round(growthRate),
        currentPosts: stats.posts,
        previousPosts: prev.posts,
        totalLikes: stats.totalLikes,
        platforms: [...stats.platforms],
        detectedAt: new Date().toISOString(),
        severity: growthRate > 100 ? "EXPLOSIVE" : "RISING"
      });
    }
    // Update baseline
    baseline[hashtag] = stats;
  }
  return alerts.sort((a, b) => b.growthRate - a.growthRate);
}

Module 3 — AI Analysis with Claude (OpenClaw)

import axios from 'axios';
async function analyzeWithClaude(trendData, explosionAlerts) {
  const prompt = 
You are a viral content strategist. Analyze these trending social media data and provide actionable output.
TRENDING DATA (last scrape)

${JSON.stringify(trendData.slice(0, 20), null, 2)}
EXPLOSION ALERTS
${JSON.stringify(explosionAlerts, null, 2)}
Respond ONLY in this exact JSON format, no preamble:
{
  "topTrends": [
    {
      "hashtag": "#example",
      "whyItsTrending": "brief explanation",
      "targetAudience": "who this appeals to",
      "contentAngle": "unique angle to take on this trend"
    }
  ],
  "contentIdeas": [
    {
      "title": "video title idea",
      "hashtag": "#hashtag",
      "hook": "first 3 seconds script",
      "format": "tutorial | reaction | storytime | list | pov",
      "estimatedViralPotential": "high | medium | low",
      "reasoning": "why this would perform well"
    }
  ],
  "urgentAlerts": [
    {
      "hashtag": "#hashtag",
      "message": "alert message",
      "recommendedAction": "what to do right now",
      "windowOfOpportunity": "estimated hours before trend peaks"
    }
  ],
  "bestTimeToPost": "recommendation based on trend timing"
}
;
  const response = await axios.post(
    'https://api.anthropic.com/v1/messages',
    {
      model: "claude-opus-4-5",
      max_tokens: 2000,
      messages: [{ role: "user", content: prompt }]
    },
    {
      headers: {
        'x-api-key': process.env.CLAUDE_API_KEY,
        'anthropic-version': '2023-06-01',
        'Content-Type': 'application/json'
      }
    }
  );
  const raw = response.data.content[0].text;
  const clean = raw.replace(/

Module 4 — Auto Script Generation

CONTENT IDEA: ${JSON.stringify(contentIdea)} TREND CONTEXT: ${trendContext}

Respond ONLY in this JSON format: { "title": "video title", "duration": "estimated seconds", "hook": "opening line — first 3 seconds", "fullScript": "complete word-for-word script", "captions": ["caption 1", "caption 2", "..."], "hashtags": ["#tag1", "#tag2", "#tag3"], "cta": "call to action at the end", "thumbnailIdea": "description of ideal thumbnail" }

Rules:

const raw = response.data.content[0].text; return JSON.parse(raw.replace(/`json|`/g, '').trim()); }

Module 5 — Auto Video Production with InVideo

// Poll until ready let exportUrl = null; while (!exportUrl) { await new Promise(r => setTimeout(r, 6000)); const status = await invideo.get(/videos/${videoId}/status); if (status.data.state === "completed") exportUrl = status.data.exportUrl; if (status.data.state === "failed") throw new Error("Video generation failed"); console.log( Video progress: ${status.data.progress}%); }

return { videoId, exportUrl, script }; }

Module 6 — Alerts & Notifications

Main Orchestrator — Full Pipeline

async function runTrendRadar() { console.log(\n🔍 Trend Radar scan started at ${new Date().toISOString()});

try { // 1 — Scrape all platforms console.log(" [1/5] Scraping TikTok & Instagram..."); const trendData = await scrapeAllPlatforms(); console.log( ✅ ${trendData.length} posts collected);

// 2 — Detect explosions console.log(" [2/5] Detecting explosions..."); const alerts = detectExplosions(trendData); console.log( ✅ ${alerts.length} alerts detected);

// 3 — AI analysis console.log(" [3/5] Analyzing with Claude..."); const analysis = await analyzeWithClaude(trendData, alerts); console.log( ✅ ${analysis.contentIdeas?.length} content ideas generated);

// 4 — Auto-generate scripts for top 2 ideas console.log(" [4/5] Generating video scripts..."); const topIdeas = analysis.contentIdeas?.slice(0, 2) || []; const scripts = await Promise.all( topIdeas.map(idea => generateVideoScript(idea, JSON.stringify(analysis.topTrends))) ); console.log( ✅ ${scripts.length} scripts written);

// 5 — Produce videos console.log(" [5/5] Producing videos with InVideo..."); const videos = await Promise.all(scripts.map(produceVideo)); console.log( ✅ ${videos.length} videos ready);

// 6 — Send alerts if (alerts.length > 0) { await sendAlert(alerts[0], analysis); console.log(" ✅ Alerts sent"); }

// Final report return { scannedAt: new Date().toISOString(), postsAnalyzed: trendData.length, explosionAlerts: alerts, contentIdeas: analysis.contentIdeas, videos: videos.map(v => ({ title: v.script.title, url: v.exportUrl })), bestTimeToPost: analysis.bestTimeToPost };

} catch (err) { console.error("Radar error:", err.message); throw err; } }

// Schedule: run every 4 hours automatically cron.schedule('0 */4 * * *', () => { runTrendRadar().then(report => { console.log("\n📊 RADAR REPORT:", JSON.stringify(report, null, 2)); }); });

// Also run immediately on startup runTrendRadar();

Environment Variables

Normalized Radar Report Schema

Requirements