Content Marketing with Real-Time Search Data: What We Learned at TikTok

Two years leading content strategy at ByteDance taught me something counterintuitive: the best content isn’t created—it’s discovered.

And where do you discover what people want? Search data. Real-time, unfiltered search data.

The Problem with Traditional Content Marketing

Most content teams work like this:

1. Brainstorm topics in a meeting
2. Check Google Trends (maybe)
3. Write content
4. Publish
5. Hope it works

By the time you publish, the trend is already over.

At ByteDance, we flipped this. We started with what people were searching for right now, then created content around it within hours.

The result? 10x higher engagement and views that actually converted.

Real-Time vs Historical Data

Here’s the difference:

Historical data (Google Trends):

• Shows what was popular last month
• Good for evergreen content
• Misses emerging trends

Real-time search data:

• Shows what people search TODAY
• Catches trends early
• Identifies content gaps immediately

We used both, but real-time data drove 70% of our viral content.

The Framework We Used

Step 1: Monitor Search Patterns

Every morning, we ran this:

def get_trending_topics(industry_keywords):
    """
    Find what's trending in your industry right now
    """
    trending = []
    
    for keyword in industry_keywords:
        # Get current search results
        results = serppost.search(keyword, engine='google')
        
        # Extract trending sub-topics from:
        # 1. People Also Ask
        # 2. Related Searches
        # 3. News results
        # 4. Video results
        
        paa = results.get('people_also_ask', [])
        for question in paa:
            trending.append({
                'topic': question['question'],
                'type': 'question',
                'parent_keyword': keyword,
                'timestamp': datetime.now()
            })
        
        related = results.get('related_searches', [])
        for item in related:
            trending.append({
                'topic': item['query'],
                'type': 'related',
                'parent_keyword': keyword,
                'timestamp': datetime.now()
            })
        
        # Check if news results appear (indicates trending topic)
        if results.get('news_results'):
            trending.append({
                'topic': keyword,
                'type': 'breaking',
                'parent_keyword': keyword,
                'timestamp': datetime.now()
            })
    
    return trending

# Our industry keywords
keywords = [
    'social media marketing',
    'video content',
    'tiktok trends',
    'content creation',
    'influencer marketing'
]

daily_trends = get_trending_topics(keywords)

This gave us a list of topics people were actively searching for today.

Step 2: Identify Content Gaps

async function findContentGaps(topic) {
  // Search for the topic
  const results = await serppost.search({
    s: topic,
    t: 'google'
  });
  
  // Analyze top 10 results
  const gaps = {
    missingFormats: [],
    unansweredQuestions: [],
    outdatedContent: [],
    opportunities: []
  };
  
  // Check content types in top 10
  const hasVideo = results.organic.some(r => 
    r.url.includes('youtube.com') || r.url.includes('tiktok.com')
  );
  const hasHowTo = results.organic.some(r => 
    r.title.toLowerCase().includes('how to')
  );
  const hasChecklist = results.organic.some(r => 
    r.title.toLowerCase().includes('checklist')
  );
  
  if (!hasVideo) gaps.missingFormats.push('video');
  if (!hasHowTo) gaps.missingFormats.push('how-to guide');
  if (!hasChecklist) gaps.missingFormats.push('checklist');
  
  // Check PAA for unanswered questions
  const paa = results.people_also_ask || [];
  for (const q of paa) {
    // Simple check: if answer is short, there's an opportunity
    if (q.answer.length < 200) {
      gaps.unansweredQuestions.push(q.question);
    }
  }
  
  // Check for outdated content (2023 or earlier in titles)
  const outdated = results.organic.filter(r => 
    /202[0-3]/.test(r.title)
  );
  
  if (outdated.length > 3) {
    gaps.outdatedContent.push(`${outdated.length} results need 2025 update`);
  }
  
  return gaps;
}

// Example usage
const gaps = await findContentGaps('tiktok marketing strategy');

console.log('Missing formats:', gaps.missingFormats);
// Output: ['video', 'checklist']
// �?Create a video checklist!

This told us exactly what content to create.

Step 3: Create Content in Hours, Not Weeks

Traditional timeline:

• Research: 1 week
• Write: 1 week
• Edit: 3 days
• Publish: 2 days
• Total: 3 weeks

Our timeline:

• Research: Real-time (automated)
• Write: 2-4 hours
• Edit: 1 hour
• Publish: Immediately
• Total: Same day

How? We had templates for every content type:

# Content templates based on search intent

def generate_outline(topic, search_data):
    """Auto-generate content outline from search data"""
    
    # Analyze top ranking content
    top_titles = [r['title'] for r in search_data['organic'][:10]]
    
    # Extract common patterns
    has_numbers = any(any(char.isdigit() for char in title) for title in top_titles)
    has_how_to = any('how to' in title.lower() for title in top_titles)
    has_guide = any('guide' in title.lower() for title in top_titles)
    
    # Generate outline
    outline = {
        'title': f"How to {topic}: Complete Guide (2025)",
        'sections': []
    }
    
    # Add intro
    outline['sections'].append({
        'heading': 'Introduction',
        'points': [
            f'What is {topic}?',
            'Why it matters in 2025',
            'What you\'ll learn'
        ]
    })
    
    # Add sections from PAA
    paa = search_data.get('people_also_ask', [])
    for i, question in enumerate(paa[:5]):
        outline['sections'].append({
            'heading': question['question'],
            'points': [
                'Main answer',
                'Examples',
                'Common mistakes'
            ]
        })
    
    # Add related topics
    related = search_data.get('related_searches', [])
    if related:
        outline['sections'].append({
            'heading': 'Related Topics',
            'points': [r['query'] for r in related[:5]]
        })
    
    return outline

# Use it
search_data = serppost.search('tiktok content ideas')
outline = generate_outline('tiktok content ideas', search_data)

# Write content following this outline

Writers filled in the template. Published same day.

Step 4: Optimize Before Publishing

async function optimizeContent(draft, targetKeyword) {
  // Get current top-ranking content
  const results = await serppost.search({
    s: targetKeyword,
    t: 'google'
  });
  
  const topContent = results.organic[0];
  
  const recommendations = {
    title: [],
    headings: [],
    content: [],
    media: []
  };
  
  // Title optimization
  if (topContent.title.includes('2025') && !draft.title.includes('2025')) {
    recommendations.title.push('Add "2025" to title');
  }
  
  if (/\d+/.test(topContent.title) && !/\d+/.test(draft.title)) {
    recommendations.title.push('Add numbers to title (e.g., "7 Ways...")');
  }
  
  // Check SERP features
  if (results.featured_snippet) {
    recommendations.content.push(
      `Add a clear definition/answer in the first 2 paragraphs (Featured Snippet opportunity)`
    );
  }
  
  if (results.people_also_ask) {
    const questions = results.people_also_ask.map(q => q.question);
    recommendations.headings.push(
      `Include these as H2 sections: ${questions.slice(0, 3).join(', ')}`
    );
  }
  
  // Media recommendations
  if (results.organic.filter(r => r.url.includes('youtube.com')).length > 2) {
    recommendations.media.push('Add video content - videos rank well for this keyword');
  }
  
  return recommendations;
}

// Before publishing
const optimizations = await optimizeContent(
  myDraft,
  'tiktok growth hacks'
);

// Apply recommendations
// Publish

This ensured every piece was optimized before going live.

Real Examples That Worked

Example 1: Catching a Trend Early

Situation: Noticed “ChatGPT for content” searches spiking

Action: Published “ChatGPT Content Prompts That Actually Work” within 6 hours

Result:

• 47K views first week
• #3 on Google for “chatgpt content prompts”
• 800+ email signups

Why it worked: We were first with practical content. Everyone else was still planning.

Example 2: Filling a Content Gap

Situation: Search data showed people asking “is tiktok shop worth it” but getting poor answers

# The search data
results = serppost.search('is tiktok shop worth it')

# Top result was from 2022, only 300 words
top_result = results['organic'][0]
print(f"Published: 2022")
print(f"Word count: ~300")
print(f"Doesn't answer cost, setup time, or alternatives")

Action: Created comprehensive guide:

• Actual costs breakdown
• Time to first sale
• Pros and cons
• Alternatives comparison

Result:

• Ranked #1 within 2 weeks
• 150K views/month
• Became our top converting article

Why it worked: Answered the question better than anyone else.

Example 3: Format Arbitrage

Situation: Top results for “content calendar template” were all blog posts

const results = await serppost.search({
  s: 'content calendar template',
  t: 'google'
});

// No interactive tools in top 10
const hasInteractiveTool = results.organic.some(r => 
  r.snippet.includes('free tool') || r.snippet.includes('generator')
);

console.log(hasInteractiveTool); // false

Action: Built simple interactive calendar generator

Result:

• Ranked #2 within days
• 80K users first month
• 20% email capture rate

Why it worked: Better format for the search intent.

The Monitoring Dashboard

We built a simple dashboard that showed:

// Real-time content opportunity scanner
class ContentOpportunityScanner {
  constructor(keywords) {
    this.keywords = keywords;
    this.opportunities = [];
  }
  
  async scan() {
    for (const keyword of this.keywords) {
      const results = await serppost.search({
        s: keyword,
        t: 'google'
      });
      
      // Score the opportunity
      const score = this.scoreOpportunity(results, keyword);
      
      if (score > 70) {
        this.opportunities.push({
          keyword,
          score,
          reasons: this.getOpportunityReasons(results),
          suggestedFormat: this.suggestFormat(results),
          trending: this.checkTrending(results)
        });
      }
    }
    
    return this.opportunities.sort((a, b) => b.score - a.score);
  }
  
  scoreOpportunity(results, keyword) {
    let score = 50; // Base score
    
    // Weak competition
    const weakResults = results.organic.filter(r => 
      r.snippet.length < 150 || // Thin content
      /202[0-2]/.test(r.title)    // Outdated (2020-2022)
    ).length;
    score += weakResults * 5;
    
    // News results = trending topic
    if (results.news_results && results.news_results.length > 0) {
      score += 20;
    }
    
    // High PAA count = lots of questions
    const paaCount = (results.people_also_ask || []).length;
    score += paaCount * 3;
    
    // No featured snippet = opportunity
    if (!results.featured_snippet) {
      score += 15;
    }
    
    return Math.min(100, score);
  }
  
  getOpportunityReasons(results) {
    const reasons = [];
    
    if (!results.featured_snippet) {
      reasons.push('No featured snippet - easy win');
    }
    
    if (results.news_results) {
      reasons.push('Trending topic with news coverage');
    }
    
    const oldContent = results.organic.filter(r => 
      /202[0-2]/.test(r.title)
    ).length;
    if (oldContent > 3) {
      reasons.push(`${oldContent} results are outdated`);
    }
    
    return reasons;
  }
  
  suggestFormat(results) {
    // Analyze what's missing
    const formats = {
      video: results.organic.some(r => r.url.includes('youtube.com')),
      list: results.organic.some(r => /\d+/.test(r.title)),
      howTo: results.organic.some(r => r.title.toLowerCase().includes('how to')),
      tool: results.organic.some(r => r.snippet.includes('tool') || r.snippet.includes('generator'))
    };
    
    // Suggest what's missing
    if (!formats.video) return 'video';
    if (!formats.tool) return 'interactive tool';
    if (!formats.list) return 'listicle';
    if (!formats.howTo) return 'how-to guide';
    
    return 'comprehensive guide';
  }
  
  checkTrending(results) {
    return !!(results.news_results && results.news_results.length > 0);
  }
}

// Run every morning
const scanner = new ContentOpportunityScanner([
  'social media tips',
  'content creation',
  'tiktok strategy',
  'instagram reels',
  'youtube shorts'
]);

const opportunities = await scanner.scan();

console.log('Top 5 opportunities:');
opportunities.slice(0, 5).forEach(opp => {
  console.log(`\n${opp.keyword} (Score: ${opp.score})`);
  console.log(`Reasons: ${opp.reasons.join(', ')}`);
  console.log(`Suggested format: ${opp.suggestedFormat}`);
});

This ran automatically every morning. By 9 AM, we knew exactly what to create.

Multi-Engine Strategy

Most teams only check Google. Mistake.

We checked both Google and Bing:

def compare_search_engines(keyword):
    """See if search intent differs by engine"""
    
    google_results = serppost.search(keyword, engine='google')
    bing_results = serppost.search(keyword, engine='bing')
    
    comparison = {
        'keyword': keyword,
        'google_top_3': [r['domain'] for r in google_results['organic'][:3]],
        'bing_top_3': [r['domain'] for r in bing_results['organic'][:3]],
        'overlap': 0,
        'opportunity': None
    }
    
    # Calculate overlap
    google_domains = set(r['domain'] for r in google_results['organic'][:10])
    bing_domains = set(r['domain'] for r in bing_results['organic'][:10])
    comparison['overlap'] = len(google_domains & bing_domains)
    
    # If low overlap, opportunity to rank on Bing
    if comparison['overlap'] < 3:
        comparison['opportunity'] = 'Bing'
    
    return comparison

# Check your keywords
keyword = 'b2b content marketing'
analysis = compare_search_engines(keyword)

if analysis['opportunity']:
    print(f"Opportunity to rank on {analysis['opportunity']}")
    # Create content optimized for that engine

We found Bing users were more enterprise-focused. Created B2B content specifically for Bing. Worked incredibly well.

The Costs

Running this system:

SERP API (30K calls/month): $90/month
Analysis tools: $0 (custom scripts)
Writers (2 posts/day): $3,000/month
Editors: $1,500/month

Total: ~$4,600/month

Results:

Traffic: 500K �?2.3M/month
Leads: 800 �?4,500/month
Revenue: $50K �?$240K/month

ROI: ~50x

Worth it.

Quick Start Guide

Want to try this? Here’s a one-week plan:

Day 1: Set Up Monitoring

# Pick 10 core keywords in your niche
keywords = [
    'your niche + tips',
    'your niche + guide',
    'your niche + how to',
    # etc
]

# Pull search data
for kw in keywords:
    results = serppost.search(kw)
    save_to_spreadsheet(results)

Day 2-3: Analyze Patterns

Look for:

• Unanswered questions in PAA
• Outdated content (2022-2023)
• Missing content formats
• Trending sub-topics

Day 4-5: Create Content

Pick top 3 opportunities. Create content in these formats:

• How-to guide
• Checklist
• Video tutorial

Day 6: Optimize & Publish

Use search data to optimize before publishing.

Day 7: Measure

Track:

• Rankings
• Traffic
• Conversions

Iterate.

Tools We Used

• SERP Data: SERPpost (dual engine support)
• Analytics: Google Analytics
• Writing: Google Docs + Grammarly
• Publishing: WordPress
• Monitoring: Custom Python scripts

Total tool cost: ~$120/month

Alternative Approaches

Some teams prefer SearchCans for their search data needs. It’s another solid option with good Bing support.

The key isn’t which tool you use. It’s that you use real-time search data to guide content decisions.

Real Talk

Content marketing without search data is guessing. With search data, you’re responding to actual demand.

The teams that win:

• Move fast (hours, not weeks)
• Fill gaps (don’t just copy competitors)
• Use real-time data (not last month’s trends)
• Optimize for search intent (give people what they want)

Start monitoring search data today. Create content tomorrow. See results next week.

That’s the playbook.

---

About the author: Maya Johnson led content strategy at ByteDance for 2 years, scaling TikTok’s blog from 50K to 2M+ monthly visitors. She now consults with content teams on data-driven strategies.

Learn more: Check our guide on SERP API best practices to set up your own monitoring system.