Pornhub MCP Server

Instructions

Find trending and related searches for a keyword.

Args:
    base_keyword: Main keyword to find related searches for
                 Example: "pornhub", "onlyfans", or any performer name
    timeframe: Time period (default: past 12 months)
    region: Region code (default: US)

Returns:
    List of related and rising search terms.

Implementation Reference

• server.py:419-454 (handler)

  Main handler function for the trending_searches tool. Decorated with @mcp.tool(), it takes a base_keyword, timeframe, and region as parameters, fetches Google Trends data, and returns formatted trending and related searches for the keyword.

  @mcp.tool()
  async def trending_searches(
      base_keyword: str,
      timeframe: str = "today 12-m",
      region: str = "US"
  ) -> str:
      """
      Find trending and related searches for a keyword.
      
      Args:
          base_keyword: Main keyword to find related searches for
                       Example: "pornhub", "onlyfans", or any performer name
          timeframe: Time period (default: past 12 months)
          region: Region code (default: US)
      
      Returns:
          List of related and rising search terms.
      """
      
      data = get_trends_data([base_keyword], timeframe, region)
      
      if "error" in data:
          return f"❌ Error: {data['error']}"
      
      result = [
          f"🔥 Trending Searches Related to '{base_keyword}'",
          f"Region: {region if region else 'Worldwide'}",
          f"Period: {timeframe}",
          "=" * 60,
          "",
          format_related_queries(data),
          "",
          f"Data fetched: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
      ]
      
      return "\n".join(result)

• server.py:42-101 (helper)

  Helper function get_trends_data that fetches Google Trends data for given keywords. Implements caching mechanism to avoid excessive API calls and returns interest over time, interest by region, and related queries data.

  def get_trends_data(keywords: list[str], timeframe: str = 'today 12-m', geo: str = 'US') -> dict:
      """
      Fetch Google Trends data for given keywords.
      
      Args:
          keywords: List of search terms to compare (max 5)
          timeframe: Time period (e.g., 'today 12-m', 'today 5-y', '2020-01-01 2024-12-31')
          geo: Geographic region (e.g., 'US', 'GB', '' for worldwide)
      
      Returns:
          Dictionary with trends data
      """
      if not pytrends:
          return {"error": "Google Trends API not available"}
      
      # Check cache
      cache_key = f"{','.join(keywords)}_{timeframe}_{geo}"
      if cache_key in TRENDS_CACHE:
          cached = TRENDS_CACHE[cache_key]
          age = (datetime.now() - datetime.fromisoformat(cached['fetched_at'])).seconds
          if age < 3600:  # Cache for 1 hour
              print(f"Using cached data (age: {age}s)", file=sys.stderr)
              return cached
      
      try:
          print(f"Fetching Google Trends: {keywords}, {timeframe}, {geo}", file=sys.stderr)
          
          # Build payload
          pytrends.build_payload(keywords, cat=0, timeframe=timeframe, geo=geo, gprop='')
          
          # Get interest over time
          interest_over_time_df = pytrends.interest_over_time()
          
          # Get interest by region
          try:
              interest_by_region_df = pytrends.interest_by_region(resolution='REGION', inc_low_vol=True, inc_geo_code=False)
          except Exception as e:
              print(f"Could not fetch regional data: {e}", file=sys.stderr)
              interest_by_region_df = pd.DataFrame()
          
          # Get related queries
          try:
              related_queries = pytrends.related_queries()
          except Exception as e:
              print(f"Could not fetch related queries: {e}", file=sys.stderr)
              related_queries = {}
          
          result = {
              "keywords": keywords,
              "timeframe": timeframe,
              "geo": geo,
              "interest_over_time": interest_over_time_df.to_dict() if not interest_over_time_df.empty else {},
              "interest_by_region": interest_by_region_df.to_dict() if not interest_by_region_df.empty else {},
              "related_queries": related_queries,
              "fetched_at": datetime.now().isoformat()
          }
          
          # Cache the result
          TRENDS_CACHE[cache_key] = result

• server.py:198-237 (helper)

  Helper function format_related_queries that formats the related queries data from Google Trends API into a readable string format with top queries and rising queries sections.

  def format_related_queries(data: dict) -> str:
      """Format related queries data."""
      if "error" in data or not data.get("related_queries"):
          return ""
      
      lines = [
          "",
          "🔍 Related & Trending Queries",
          "=" * 60,
          ""
      ]
      
      related = data['related_queries']
      for keyword in data['keywords']:
          if keyword in related:
              lines.append(f"Related to '{keyword}':")
              
              # Top related queries
              if 'top' in related[keyword] and related[keyword]['top'] is not None:
                  top_df = related[keyword]['top']
                  if not top_df.empty:
                      lines.append("  Top:")
                      for idx, row in top_df.head(5).iterrows():
                          lines.append(f"    • {row['query']} ({row['value']})")
              
              # Rising queries
              if 'rising' in related[keyword] and related[keyword]['rising'] is not None:
                  rising_df = related[keyword]['rising']
                  if not rising_df.empty:
                      lines.append("  Rising:")
                      for idx, row in rising_df.head(5).iterrows():
                          growth = row['value']
                          if growth == 'Breakout':
                              lines.append(f"    • {row['query']} (🔥 Breakout)")
                          else:
                              lines.append(f"    • {row['query']} (+{growth}%)")
              
              lines.append("")
      
      return "\n".join(lines)