गूगल ट्रेंड्स स्वचालित रिपोर्टिंग प्रणाली (पाइपड्रीम + स्क्रैपलेस + डिस्कॉर्ड)

import { axios } from "@pipedream/platform"

export default defineComponent({
  async run({ steps, $ }) {
    const keywords = ["AI", "Machine Learning", "Data Science"];
    const allResults = {};
    
    for (const keyword of keywords) {
      console.log(`Processing keyword: ${keyword}`);
      
      const payload = {
        actor: "scraper.google.trends",
        input: {
          q: keyword,
          date: "today 1-m",
          data_type: "interest_over_time",
          hl: "en",
          tz: "420",
          geo: "",
          cat: "",
          property: "",
        },
        proxy: {
          country: "",
        }
      };

      try {
        const response = await axios($, {
          method: 'POST',
          url: 'https://api.scrapeless.com/api/v1/scraper/request',
          headers: {
            'Content-Type': 'application/json',
            'x-api-token': 'Scrapeless API KEY'
          },
          data: payload
        });
        
        console.log(`Response for ${keyword}:`, response);
        
        if (response.job_id) {
          console.log(`Job created for ${keyword}, ID: ${response.job_id}`);
          
          let attempts = 0;
          const maxAttempts = 12;
          let jobResult = null;
          
          while (attempts < maxAttempts) {
            await new Promise(resolve => setTimeout(resolve, 10000));
            attempts++;
            
            try {
              const resultResponse = await axios($, {
                method: 'GET',
                url: `https://api.scrapeless.com/api/v1/scraper/result/${response.job_id}`,
                headers: {
                  'x-api-token': 'Scrapeless API KEY'
                }
              });
              
              console.log(`Attempt ${attempts} for ${keyword}:`, resultResponse);
              
              if (resultResponse.status === 'completed') {
                jobResult = resultResponse.result;
```hi
console.log(`कार्य ${keyword} के लिए पूरा हुआ:`, jobResult);
                break;
              } else if (resultResponse.status === 'failed') {
                console.error(`कार्य ${keyword} के लिए विफल:`, resultResponse);
                break;
              } else {
                console.log(`कार्य अभी भी चल रहा है ${keyword} के लिए, स्थिति: ${resultResponse.status}`);
              }
            } catch (error) {
              console.error(`कार्य स्थिति की जांच करते समय त्रुटि ${keyword} के लिए:`, error);
            }
          }
          
          if (jobResult) {
            allResults[keyword] = jobResult;
          } else {
            allResults[keyword] = { 
              error: `कार्य टाइमआउट या ${attempts} प्रयासों के बाद विफल`,
              job_id: response.job_id 
            };
          }
          
        } else {
          allResults[keyword] = response;
        }
        
      } catch (error) {
        console.error(`त्रुटि ${keyword} के लिए:`, error);
        allResults[keyword] = { 
          error: `अनुरोध विफल: ${error.message}` 
        };
      }
    }
    
    console.log("अंतिम परिणाम:", JSON.stringify(allResults, null, 2));
    return allResults;
  },
})

export default defineComponent({
  async run({ steps, $ }) {
    const httpData = steps.http.$return_value;
    
    console.log("प्राप्त HTTP डेटा:", JSON.stringify(httpData, null, 2));
    
    const processedData = {};
    const timestamp = new Date().toISOString();
    
    for (const [keyword, data] of Object.entries(httpData)) {
      console.log(`प्रसंस्करण ${keyword}:`, data);
      
      let timelineData = null;
      let isPartial = false;
      
      if (data?.interest_over_time?.timeline_data) {
        timelineData = data.interest_over_time.timeline_data;
        isPartial = data.interest_over_time.isPartial || false;
      } else if (data?.timeline_data) {
        timelineData = data.timeline_data;
      } else if (data?.interest_over_time && Array.isArray(data.interest_over_time)) {
        timelineData = data.interest_over_time;
      }
      
      if (timelineData && Array.isArray(timelineData) && timelineData.length > 0) {
        console.log(`पाया गया ${timelineData.length} डेटा बिंदुओं के लिए ${keyword}`);
        
        const values = timelineData.map(item => {
          const value = item.value || item.interest || item.score || item.y || 0;
          return parseInt(value) || 0;
        });
        
        const validValues = values.filter(v => v >= 0);
        
        if (validValues.length > 0) {
          const average = Math.round(validValues.reduce((sum, val) => sum + val, 0) / validValues.length);
          const trend = validValues.length >= 2 ? validValues[validValues.length - 1] - validValues[0] : 0;
          const max = Math.max(...validValues);
          const min = Math.min(...validValues);
          
          const recentValues = validValues.slice(-7);
          const earlyValues = validValues.slice(0, 7);
          const recentAvg = recentValues.length > 0 ? recentValues.reduce((a, b) => a + b, 0) / recentValues.length : 0;
          const earlyAvg = earlyValues.length > 0 ? earlyValues.reduce((a, b) => a + b, 0) / earlyValues.length : 0;
          const weeklyTrend = Math.round(recentAvg - earlyAvg);
          
          processedData[keyword] = {
            keyword,
            average,
            trend,
            weeklyTrend,
            values: validValues,
            max,
            min,
            dataPoints: validValues.length,
            isPartial,
            timestamps: timelineData.map(item => item.time || item.date || item.timestamp),
            lastValue: validValues[validValues.length - 1],
            firstValue: validValues[0],
            volatility: Math.round(Math.sqrt(validValues.map(x => Math.pow(x - average, 2)).reduce((a, b) => a + b, 0) / validValues.length)),
            status: 'success'
          };
        } else {
          processedData[keyword] = {
            keyword,
            average: 0,
            trend: 0,
            weeklyTrend: 0,
            values: [],
            max: 0,
            min: 0,
            dataPoints: 0,
            isPartial: false,
            error: "टाइमलाइन डेटा में कोई मान्य मूल्य नहीं मिला",
            status: 'error',
            rawTimelineLength: timelineData.length
          };
        }
      } else {
        processedData[keyword] = {

सारांश = {
  समयचिह्न,
  कुलकुंजीशब्द: ऑब्जेक्ट.कुंजियाँ(processedData).लंबाई,
  सफल कुंजीशब्द: ऑब्जेक्ट.मान(processedData).फिल्टर(d => d.स्थिति === 'सफलता').लंबाई,
  अवधि: "आज 1-म",
  डेटा: processedData
};

लॉग("आखिरी संसाधित डेटा:", JSON.स्ट्रिंगिफाई(saransh, शून्य, 2));
लौटाएँ सारांश;

---

यह Scrapeless द्वारा लौटाए गए डेटा के आधार पर निम्नलिखित मेट्रिक्स की गणना करेगा:

* **औसत मूल्य**
* **साप्ताहिक प्रवृत्ति परिवर्तन** (पिछले 7 दिन बनाम पिछले 7 दिन)
* **अधिकतम / न्यूनतम मान**
* **अस्थिरता**

**नोट:**

* प्रत्येक कुंजीशब्द एक विस्तृत विश्लेषण वस्तु उत्पन्न करेगा, जिससे दृश्यता और आगे की सूचनाओं के लिए इसे आसान बनाया जा सकेगा।

### चरण 4 - discord_notify (डिस्कॉर्ड में विश्लेषण रिपोर्ट भेजें)

![चरण 4 - discord_notify (डिस्कॉर्ड में विश्लेषण रिपोर्ट भेजें)](https://assets.scrapeless.com/prod/posts/build-google-trends-monitor-with-pipedream/f18726b4fe24fa4e2815d32624288b79.png)

1. अंतिम Node.js चरण जोड़ें, निम्नलिखित कोड उदाहरण है

डिस्कॉर्डवेबहुकयूआरएल = "https://discord.com/api/webhooks/1380448411299614821/MXzmQ14TOPK912lWhle_7qna2VQJBjWrdCkmHjdEloHKhYXw0fpBrp-0FS4MDpDB8tGh";

लॉग("डिस्कॉर्ड के लिए डेटा संसाधित किया जा रहा है:", JSON.स्ट्रिंगिफाई(processedData, शून्य, 2));

वर्तमान दिनांक = नई तिथि().toLocaleString('hi-IN');

कुंजीशब्द = ऑब्जेक्ट.मान(processedData.data);
सफल = कुंजीशब्द.फिल्टर(k => k.स्थिति === 'सफलता');

let सबसे अच्छा प्रदर्शन करने वाला = शून्य;
let सबसे खराब प्रदर्शन करने वाला = शून्य;
let सबसे मजबूत प्रवृत्ति = शून्य;

अगर (सफल.लंबाई > 0) {
  सबसे अच्छा प्रदर्शन करने वाला = सफल.कम करें((अधिकतम, वर्तमान) => वर्तमान.औसत > अधिकतम.औसत ? वर्तमान : अधिकतम);
  सबसे खराब प्रदर्शन करने वाला = सफल.कम करें((न्यूनतम, वर्तमान) => वर्तमान.औसत < न्यूनतम.औसत ? वर्तमान : न्यूनतम);
  सबसे मजबूत प्रवृत्ति = सफल.कम करें((अधिकतम, वर्तमान) => Math.abs(वर्तमान.साप्ताहिकप्रवृत्ति) > Math.abs(अधिकतम.साप्ताहिकप्रवृत्ति) ? वर्तमान : अधिकतम);
}

डिस्कॉर्ड संदेश = {
  सामग्री: `📊 **गूगल ट्रेंड्स रिपोर्ट** - ${वर्तमान दिनांक}`,
  एम्बेड: [
    {
      शीर्षक: "🔍 प्रवृत्तियों का विश्लेषण",
      रंग: 3447003,
      समयचिह्न: नई तिथि().toISOString(),
      फ़ील्ड: [
        {
          नाम: "📈 सारांश",
          मान: `**अवधि:** पिछले महीने\n**विश्लेषण किए गए कुंजीशब्द:** ${processedData.totalKeywords}\n**सफलता:** ${processedData.successfulKeywords}/${processedData.totalKeywords}`,
          इनलाइन: झूठा
        }
      ]
    }
  ]
};

अगर (सफल.लंबाई > 0) {
  कुंजीशब्द विवरण = सफल.मानचित्र डेटा => {
    प्रवृत्ति चिह्न = डेटा.साप्ताहिकप्रवृत्ति > 5 ? '🚀' : 
                     डेटा.साप्ताहिकप्रवृत्ति > 0 ? '📈' : 
                     डेटा.साप्ताहिकप्रवृत्ति < -5 ? '📉' : 
                     डेटा.साप्ताहिकप्रवृत्ति < 0 ? '⬇️' : '➡️';
    
    प्रदर्शन चिह्न = डेटा.औसत > 70 ? '🔥' : 
                           डेटा.औसत > 40 ? '✅' : 
                           डेटा.औसत > 20 ? '🟡' : '🔴';
    
    लौटें {
      नाम: `${प्रदर्शन चिह्न} ${डेटा.कुंजीशब्द}`,
      मान: `**स्कोर:** ${डेटा.औसत}/100\n**प्रवृत्ति:** ${प्रवृत्ति चिह्न} ${डेटा.साप्ताहिकप्रवृत्ति > 0 ? '+' : ''}${डेटा.साप्ताहिकप्रवृत्ति}\n**श्रेणी:** ${डेटा.न्यूनतम}-${डेटा.अधिकतम}`,
      इनलाइन: सही
    };
  });
  
  डिस्कॉर्ड संदेश.एम्बेड[0].फ़ील्ड.push(...कुंजीशब्द विवरण);
}

अगर (सबसे अच्छा प्रदर्शन करने वाला && सफल.लंबाई > 1) {
  डिस्कॉर्ड संदेश.एम्बेड.push({
    शीर्षक: "🏆 मुख्य विशेषताएँ",
    रंग: 15844367,
    फ़ील्ड: [
      {
        नाम: "🥇 शीर्ष प्रदर्शन करने वाला",
        मान: `**${सबसे अच्छा प्रदर्शन करने वाला.कुंजीशब्द}** (${सबसे अच्छा प्रदर्शन करने वाला.औसत}/100)`,
        इनलाइन: सही
      },
      {
        नाम: "📊 न्यूनतम स्कोर",
        मान: `**${सबसे खराब प्रदर्शन करने वाला.कुंजीशब्द}** (${सबसे खराब प्रदर्शन करने वाला.औसत}/100)`,
        इनलाइन: सही
      },
      {
        नाम: "⚡ सबसे मजबूत प्रवृत्ति",
        मान: `**${सबसे मजबूत प्रवृत्ति.कुंजीशब्द}** (${सबसे मजबूत प्रवृत्ति.साप्ताहिकप्रवृत्ति > 0 ? '+' : ''}${सबसे मजबूत प्रवृत्ति.साप्ताहिकप्रवृत्ति})`,
        इनलाइन: सही
      }
    ]
  });
}

विफल = कुंजीशब्द.फिल्टर(k => k.स्थिति === 'त्रुटि');
अगर (विफल.लंबाई > 0) {
  डिस्कॉर्ड संदेश.एम्बेड.push({
    शीर्षक: "❌ त्रुटियाँ",
    रंग: 15158332,
    फ़ील्ड: विफल.मानचित्र डेटा => ({
      नाम: डेटा.कुंजीशब्द,
      मान: डेटा.त्रुटि || "अज्ञात त्रुटि",
      इनलाइन: सही
    }))
  });

console.log("Discord संदेश भेजने के लिए:", JSON.stringify(discordMessage, null, 2));

try {
  const response = await axios($, {
    method: 'POST',
    url: discordWebhookUrl,
    headers: {
      'Content-Type': 'application/json'
    },
    data: discordMessage
  });

  console.log("Discord webhook प्रतिक्रिया:", response);

  return {
    webhook_sent: true,
    platform: "discord",
    message_sent: true,
    keywords_analyzed: processedData.totalKeywords,
    successful_keywords: processedData.successfulKeywords,
    timestamp: currentDate,
    discord_response: response
  };

} catch (error) {
  console.error("Discord webhook त्रुटि:", error);

  const simpleMessage = {
    content: `📊 **Google Trends रिपोर्ट - ${currentDate}**\n\n` +
            `📈 **परिणाम (${processedData.successfulKeywords}/${processedData.totalKeywords}):**\n` +
            successful.map(data => 
              `• **${data.keyword}**: ${data.average}/100 (${data.weeklyTrend > 0 ? '+' : ''}${data.weeklyTrend})`
            ).join('\n') +
            (failed.length > 0 ? `\n\n❌ **त्रुटियाँ:** ${failed.map(d => d.keyword).join(', ')}` : '')
  };

  try {
    const fallbackResponse = await axios($, {
      method: 'POST',
      url: discordWebhookUrl,
      headers: {
        'Content-Type': 'application/json'
      },
      data: simpleMessage
    });

    return {
      webhook_sent: true,
      platform: "discord",
      message_sent: true,
      fallback_used: true,
      discord_response: fallbackResponse
    };

  } catch (fallbackError) {
    console.error("Discord fallback त्रुटि:", fallbackError);

    return {
      webhook_sent: false,
      platform: "discord",
      error: error.message,
      fallback_error: fallbackError.message,
      data_summary: {
        keywords: processedData.totalKeywords,
        successful: processedData.successfulKeywords,
        best_performer: bestPerformer?.keyword,
        best_score: bestPerformer?.average
      }
    };
  }
}
},
})

2. अपने डिस्कॉर्ड वेबहुक यूआरएल को अपने स्वयं के वेबहुक पते से बदलें
3. अपने कार्यप्रवाह को चलाने और वास्तविक समय की जानकारी प्राप्त करने के लिए डिप्लॉय पर क्लिक करें।

### चरण 5 - वास्तविक समय की Google Trends जानकारी प्राप्त करें

आप सीधे Discord में कीवर्ड को चेक करने के लिए डेटा प्राप्त कर सकते हैं:

![चरण 5 - वास्तविक समय की Google Trends जानकारी प्राप्त करें](https://assets.scrapeless.com/prod/posts/build-google-trends-monitor-with-pipedream/7169818a2a9ab050b812d04b40d5c480.png)

**नीचे पूर्ण लिंक डायग्राम है:**

![नीचे पूर्ण लिंक डायग्राम है](https://assets.scrapeless.com/prod/posts/build-google-trends-monitor-with-pipedream/f75d04384f0a80200a0509310fd14680.png)

> **✅ अभी लाइव: Scrapeless आधिकारिक एकीकरण Pipedream पर**
>
> Scrapeless अब Pipedream के एकीकरण हब पर आधिकारिक तौर पर उपलब्ध है! केवल कुछ क्लिक के साथ, आप अपने Pipedream कार्यप्रवाहों से सीधे हमारी शक्तिशाली Google Trends API को कॉल कर सकते हैं—कोई सेटअप, कोई सर्वर की आवश्यकता नहीं।
>
> चाहे आप वास्तविक समय के डैशबोर्ड बना रहे हों, विपणन खुफिया को स्वचालित कर रहे हों, या कस्टम विश्लेषण को शक्ति प्रदान कर रहे हों, यह एकीकरण आपको उत्पादन-ग्रेड ट्रेंड मॉनिटरिंग के लिए सबसे तेज़ मार्ग प्रदान करता है।
>
> 👉 तुरंत निर्माण शुरू करें: **pipedream.com/apps/scrapeless**
       
Drag, drop, और आज ही अपने अगले ट्रेंड-संचालित कार्यप्रवाह को डिप्लॉय करें।

डेवलपर्स, विश्लेषकों और विकास टीमों के लिए बिल्कुल सही जिन्हें तेजी से कार्रवाई करने योग्य जानकारी की आवश्यकता होती है।

## सारांश
Pipedream, Scrapeless API और Discord के शक्तिशाली संयोजन के माध्यम से, हमने एक Google Trends रिपोर्टिंग प्रणाली बनाई जो मैन्युअल हस्तक्षेप की आवश्यकता नहीं होती और इसे स्वचालित रूप से दैनिक रूप से निष्पादित किया जाता है। यह न केवल काम की दक्षता को बहुत बढ़ाता है, बल्कि विपणन निर्णयों को अधिक डेटा-संचालित भी बनाता है।

यदि आपको भी समान डेटा स्वचालन विश्लेषण प्रणाली बनाने की आवश्यकता है, तो आप इस तकनीकी संयोजन को आजमाने के लिए बेझिझक प्रयास कर सकते हैं!

---
Scrapeless सभी लागू कानूनों और विनियमों के साथ पूर्ण अनुपालन में कार्य करता है, केवल सार्वजनिक रूप से उपलब्ध डेटा तक पहुँचता है जो प्लेटफ़ॉर्म सेवा की शर्तों के अनुसार है। यह समाधान वैध व्यापार खुफिया और अनुसंधान उद्देश्यों के लिए डिज़ाइन किया गया है।