कैसे n8n और Scrapeless के साथ एक बुद्धिमान B2B लीड जनरेशन वर्कफ़्लो बनाएं

"सॉफ़्टवेयर कंपनियाँ" "Enterprise Clients" कर्मचारियों:50-200
"मार्केटिंग एजेंसियाँ" "B2B सेवाएँ" "डिजिटल ट्रांसफॉर्मेशन"
"SaaS स्टार्टअप्स" "सीरीज ए" "वेंचर बैक्ड"
"निर्माण कंपनियाँ" "डिजिटल समाधान" ISO

[
  {
    "markdown": "# कंपनी का होमपेज\n\nहमारी कंपनी में आपका स्वागत है...",
    "metadata": {
      "title": "कंपनी का नाम - होमपेज",
      "description": "कंपनी का विवरण",
      "sourceURL": "https://company.com"
    }
  }
]

console.log("=== स्क्रैपलेस क्रॉलर डेटा PROSESSING ===");

try {
  // डेटा एक श्रृंखला के रूप में आता है
  const crawlerDataArray = $json;
  
  console.log("डेटा प्रकार:", typeof crawlerDataArray);
  console.log("क्या श्रृंखला है:", Array.isArray(crawlerDataArray));
  console.log("श्रृंखला की लंबाई:", crawlerDataArray?.length || 0);
  
  // जाँचना कि क्या श्रृंखला खाली है
  if (!Array.isArray(crawlerDataArray) || crawlerDataArray.length === 0) {
    console.log("❌ खाली या अम valide क्रॉलर डेटा");
    return {
      url: "अनजान",
      company_name: "कोई डेटा नहीं",
      content: "",
      error: "खाली क्रॉलर प्रतिक्रिया",
      processing_failed: true,
      skip_reason: "क्रॉलर से डेटा नहीं लौटा"
    };
  }
  
  // श्रृंखला से पहला तत्व लेना
  const crawlerResponse = crawlerDataArray[0];
  
  // मार्कडाउन सामग्री निकालना
  const markdownContent = crawlerResponse?.markdown || "";
  
  // मेटाडेटा निकालना (यदि उपलब्ध हो)
  const metadata = crawlerResponse?.metadata || {};
  
  // मूल जानकारी
  const sourceURL = metadata.sourceURL || metadata.url || extractURLFromContent(markdownContent);
  const companyName = metadata.title || metadata.ogTitle || extractCompanyFromContent(markdownContent);
  const description = metadata.description || metadata.ogDescription || "";
  
  console.log(`प्रसंस्करण: ${companyName}`);
  console.log(`यूआरएल: ${sourceURL}`);
  console.log(`सामग्री की लंबाई: ${markdownContent.length} अक्षर`);
  
  // सामग्री गुणवत्ता सत्यापन

if (!markdownContent || markdownContent.length < 100) {
    return {
      url: sourceURL,
      company_name: companyName,
      content: "",
      error: "क्रॉलर से सामग्री अपर्याप्त है",
      processing_failed: true,
      raw_content_length: markdownContent.length,
      skip_reason: "सामग्री बहुत छोटी या खाली"
    };
  }
  
  // मार्कडाउन सामग्री को साफ़ करना और संरचना देना
  let cleanedContent = cleanMarkdownContent(markdownContent);
  
  // संपर्क जानकारी निकालना
  const contactInfo = extractContactInformation(cleanedContent);
  
  // महत्वपूर्ण व्यावसायिक अनुभागों को निकालना
  const businessSections = extractBusinessSections(cleanedContent);
  
  // क्लॉड एआई के लिए सामग्री बनाना
  const contentForAI = buildContentForAI({
    companyName,
    sourceURL,
    description,
    businessSections,
    contactInfo,
    cleanedContent
  });
  
  // सामग्री गुणवत्ता मेट्रिक्स
  const contentQuality = assessContentQuality(cleanedContent, contactInfo);
  
  const result = {
    url: sourceURL,
    company_name: companyName,
    content: contentForAI,
    raw_content_length: markdownContent.length,
    processed_content_length: contentForAI.length,
    extracted_emails: contactInfo.emails,
    extracted_phones: contactInfo.phones,
    content_quality: contentQuality,
    metadata_info: {
      has_title: !!metadata.title,
      has_description: !!metadata.description,
      site_name: metadata.ogSiteName || "",
      page_title: metadata.title || ""
    },
    processing_timestamp: new Date().toISOString(),
    processing_status: "सफलता"
  };
  
  console.log(`✅ सफलतापूर्वक संसाधित किया गया ${companyName}`);
  return result;
  
} catch (error) {
  console.error("❌ क्रॉलर डेटा संसाधित करते समय त्रुटि:", error);
  return {
    url: "अज्ञात",
    company_name: "प्रसंस्करण त्रुटि",
    content: "",
    error: error.message,
    processing_failed: true,
    processing_timestamp: new Date().toISOString()
  };
}

// ========== उपयोगिता फंक्शन ==========

function extractURLFromContent(content) {
  // मार्कडाउन सामग्री से URL निकालने की कोशिश करें
  const urlMatch = content.match(/https?:\/\/[^\s\)]+/);
  return urlMatch ? urlMatch[0] : "अज्ञात";
}

function extractCompanyFromContent(content) {
  // सामग्री से कंपनी का नाम निकालने की कोशिश करें
  const titleMatch = content.match(/^#\s+(.+)$/m);
  if (titleMatch) return titleMatch[1];
  
  // डोमेन निकालने के लिए ईमेल खोजें
  const emailMatch = content.match(/@([a-zA-Z0-9.-]+\.[a-zA-Z]{2,})/);
  if (emailMatch) {
    const domain = emailMatch[1].replace('www.', '');
    return domain.split('.')[0].charAt(0).toUpperCase() + domain.split('.')[0].slice(1);
  }
  
  return "अज्ञात कंपनी";
}

function cleanMarkdownContent(markdown) {
  return markdown
    // नेविगेशन तत्वों को हटाना
    .replace(/^\[Skip to content\].*$/gmi, '')
    .replace(/^\[.*\]\(#.*\)$/gmi, '')
    // मार्कडाउन लिंक को हटाना लेकिन पाठ बनाए रखना
    .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
    // छवियों और बेस64 को हटाना
    .replace(/!\[([^\]]*)\]\([^)]*\)/g, '')
    .replace(/<Base64-Image-Removed>/g, '')
    // कुकी/गोपनीयता उल्लेख हटाना
    .replace(/.*?(cookie|privacy policy|terms of service).*?\n/gi, '')
    // कई स्पेस को साफ़ करना
    .replace(/\s+/g, ' ')
    // कई खाली लाइनों को हटाना
    .replace(/\n\s*\n\s*\n/g, '\n\n')
    .trim();
}

function extractContactInformation(content) {
  // ईमेल के लिए रेगुलर एक्सप्रेशन
  const emailRegex = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g;
  
  // फोन के लिए रेगुलर एक्सप्रेशन (अंतर्राष्ट्रीय समर्थन के साथ)
  const phoneRegex = /(?:\+\d{1,3}\s?)?\d{3}\s?\d{3}\s?\d{3,4}|\(\d{3}\)\s?\d{3}-?\d{4}/g;
  
  const emails = [...new Set((content.match(emailRegex) || [])
    .filter(email => !email.includes('example.com'))
    .slice(0, 3))];
  
  const phones = [...new Set((content.match(phoneRegex) || [])
    .filter(phone => phone.replace(/\D/g, '').length >= 9)
    .slice(0, 2))];
  
  return { emails, phones };
}

function extractBusinessSections(content) {
  const sections = {};
  
  // महत्वपूर्ण अनुभागों की खोज
  const lines = content.split('\n');
  let currentSection = '';
  let currentContent = '';
  
  for (let i = 0; i < lines.length; i++) {
    const line = lines[i].trim();
    
    // शीर्षक पहचान
    if (line.startsWith('#')) {
      // पिछले अनुभाग को सहेजें
      if (currentSection && currentContent) {
        sections[currentSection] = currentContent.trim().substring(0, 500);
      }
      
      // नया अनुभाग
      const title = line.replace(/^#+\s*/, '').toLowerCase();
      if (title.includes('about') || title.includes('service') || 
          title.includes('contact') || title.includes('company')) {
        currentSection = title.includes('about') ? 'about' :
                        title.includes('service') ? 'services' :
                        title.includes('contact') ? 'contact' : 'company';
        currentContent = '';
      } else {
        currentSection = '';
      }
    } else if (currentSection && line) {
      currentContent += line + '\n';
    }

}

// अंतिम अनुभाग सहेजें
if (currentSection && currentContent) {
  sections[currentSection] = currentContent.trim().substring(0, 500);
}

return sections;
}

function buildContentForAI({ companyName, sourceURL, description, businessSections, contactInfo, cleanedContent }) {
  let aiContent = `कंपनी विश्लेषण अनुरोध\n\n`;
  aiContent += `कंपनी: ${companyName}\n`;
  aiContent += `वेब साइट: ${sourceURL}\n`;
  
  if (description) {
    aiContent += `विवरण: ${description}\n`;
  }
  
  aiContent += `\nसंपर्क जानकारी:\n`;
  if (contactInfo.emails.length > 0) {
    aiContent += `ईमेल: ${contactInfo.emails.join(', ')}\n`;
  }
  if (contactInfo.phones.length > 0) {
    aiContent += `फोन: ${contactInfo.phones.join(', ')}\n`;
  }
  
  aiContent += `\nव्यापार अनुभाग:\n`;
  for (const [section, content] of Object.entries(businessSections)) {
    if (content) {
      aiContent += `\n${section.toUpperCase()}:\n${content}\n`;
    }
  }
  
  // मुख्य सामग्री जोड़ें (सीमित)
  aiContent += `\nपूर्ण सामग्री पूर्वावलोकन:\n`;
  aiContent += cleanedContent.substring(0, 2000);
  
  // क्लॉड API के लिए अंतिम सीमा
  return aiContent.substring(0, 6000);
}

function assessContentQuality(content, contactInfo) {
  const wordCount = content.split(/\s+/).length;
  
  return {
    word_count: wordCount,
    has_contact_info: contactInfo.emails.length > 0 || contactInfo.phones.length > 0,
    has_about_section: /about|company|who we are/gi.test(content),
    has_services_section: /services|products|solutions/gi.test(content),
    has_team_section: /team|leadership|staff/gi.test(content),
    content_richness_score: Math.min(10, Math.floor(wordCount / 50)),
    email_count: contactInfo.emails.length,
    phone_count: contactInfo.phones.length,
    estimated_quality: wordCount > 200 && contactInfo.emails.length > 0 ? "उच्च" : 
                      wordCount > 100 ? "मध्यम" : "कम"
  };
}

{
  "url": "https://company.com",
  "company_name": "कंपनी का नाम",
  "content": "कंपनी विश्लेषण अनुरोध\n\nकंपनी: ...",
  "raw_content_length": 50000,
  "processed_content_length": 2500,
  "extracted_emails": ["contact@company.com"],
  "extracted_phones": ["+1-555-123-4567"],
  "content_quality": {
    "word_count": 5000,
    "has_contact_info": true,
    "estimated_quality": "उच्च",
    "content_richness_score": 10
  },
  "processing_status": "सफलता"
}

इस संसाधित कंपनी की वेबसाइट सामग्री का विश्लेषण करें और B2B लीड जानकारी को निकालें। केवल वैध JSON लौटाएं:
कंपनी URL: {{ $json.url }}
कंपनी का नाम: {{ $json.company_name }}
प्रसंस्कृत वेबसाइट सामग्री: {{ $json.content }}
सामग्री गुणवत्ता आकलन: {{ $json.content_quality }}
पूर्व-निकाली गई संपर्क जानकारी: 
ईमेल: {{ $json.extracted_emails }}
फोन: {{ $json.extracted_phones }}
मेटाडेटा जानकारी: {{ $json.metadata_info }}

प्रांप्ट संरचना फ़िल्टरिंग को अधिक विश्वसनीय बनाती है क्योंकि अब क्लॉड को लगातार, संरचित इनपुट प्राप्त होता है। इससे अगली चरण की आपकी कार्यप्रणाली में लीड स्कोर और बेहतर योग्यता निर्णयों में अधिक सटीकता आती है।

## चरण 7: क्लॉड एआई प्रतिक्रिया का पर्किंग
लीड्स को फ़िल्टर करने से पहले, हमें क्लॉड की JSON प्रतिक्रिया को सही ढंग से पर्क करना होगा जो मार्कडाउन स्वरूपण में लिपटा हो सकता है।

1. एआई एजेंट (क्लॉड) के बाद एक कोड नोड जोड़ें
2. क्लॉड की JSON प्रतिक्रिया को पर्क और साफ़ करने के लिए कॉन्फ़िगर करें


![क्लॉड प्रतिक्रिया पर्कन का कॉन्फ़़िगरेशन](https://assets.scrapeless.com/prod/posts/build-b2b-lead-generation-workflow-with-n8n/aae4593790f5f1c5d34d43ecaf354e85.png)

### 1. कोड नोड कॉन्फ़िगरेशन

Here’s the translated text in Hindi:

```javascript
console.log("संपर्क ईमेल:", leadData.contact_email);

// मान्यता और डेटा सफाई
const cleanedLead = {
    company_name: leadData.company_name || "अज्ञात",
    industry: leadData.industry || null,
    company_size: leadData.company_size || null,
    location: leadData.location || null,
    contact_email: leadData.contact_email || null,
    phone: leadData.phone || null,
    key_services: Array.isArray(leadData.key_services) ? leadData.key_services : [],
    target_market: leadData.target_market || null,
    technologies: Array.isArray(leadData.technologies) ? leadData.technologies : [],
    funding_stage: leadData.funding_stage || null,
    business_model: leadData.business_model || null,
    social_presence: leadData.social_presence || { linkedin: null, twitter: null },
    lead_score: typeof leadData.lead_score === 'number' ? leadData.lead_score : 0,
    qualification_reasons: Array.isArray(leadData.qualification_reasons) ? leadData.qualification_reasons : [],
    decision_makers: Array.isArray(leadData.decision_makers) ? leadData.decision_makers : [],
    next_actions: Array.isArray(leadData.next_actions) ? leadData.next_actions : [],
    content_insights: leadData.content_insights || {},

    // फ़िल्टर करने के लिए मेटा जानकारी
    is_qualified: leadData.lead_score >= 6 && leadData.contact_email !== null,
    has_contact_info: !!(leadData.contact_email || leadData.phone),
    processing_timestamp: new Date().toISOString(),
    claude_processing_status: "सफल"
};

console.log(✅ लीड प्रोसेस किया गया: ${cleanedLead.company_name} (स्कोर: ${cleanedLead.lead_score}, योग्य: ${cleanedLead.is_qualified}));

return cleanedLead;

} catch (error) {
console.error("❌ क्लॉड प्रतिक्रिया को पार्स करते समय त्रुटि:", error);
console.error("कच्चा आउटपुट:", $json.output);

// संरचित त्रुटि प्रतिक्रिया
return {
    company_name: "क्लॉड पार्सिंग त्रुटि",
    industry: null,
    company_size: null,
    location: null,
    contact_email: null,
    phone: null,
    key_services: [],
    target_market: null,
    technologies: [],
    funding_stage: null,
    business_model: null,
    social_presence: { linkedin: null, twitter: null },
    lead_score: 0,
    qualification_reasons: [क्लॉड पार्सिंग विफल: ${error.message}],
    decision_makers: [],
    next_actions: ["क्लॉड प्रतिक्रिया पार्सिंग ठीक करें", "JSON प्रारूप की जांच करें"],
    content_insights: {},
    is_qualified: false,
    has_contact_info: false,
    processing_timestamp: new Date().toISOString(),
    claude_processing_status: "विफल",
    parsing_error: error.message,
    raw_claude_output: $json.output || "कोई आउटपुट प्राप्त नहीं हुआ"
};
}

// क्यों क्लॉड प्रतिक्रिया पार्सिंग जोड़ें?
- मार्कडाउन हैंडलिंग: क्लॉड उत्तरों से JSON प्रारूप को हटाता है
- डेटा मान्यता: सुनिश्चित करता है कि सभी क्षेत्रों के पास उचित प्रकार और डिफ़ॉल्ट हैं
- त्रुटि वसूली: JSON पार्सिंग विफलताओं को व्यवस्थित रूप से संभालता है
- फ़िल्टरिंग तैयारी: आसान फ़िल्टरिंग के लिए अनुक्रमित क्षेत्रों को जोड़ता है
- डिबग समर्थन: समस्या निवारण के लिए व्यापक लॉगिंग

![क्लॉड पार्सिंग परिणाम](https://assets.scrapeless.com/prod/posts/build-b2b-lead-generation-workflow-with-n8n/95a71f3004d783ad6b7b825f48c382ed.png)


## चरण 8: लीड फ़िल्टरिंग और गुणवत्ता नियंत्रण
पार्स किए गए और मान्य डेटा का उपयोग करके योग्यता स्कोर और डेटा पूर्णता के आधार पर लीड को फ़िल्टर करें।

1. क्लॉड प्रतिक्रिया पार्सर के बाद एक IF नोड जोड़ें
2. सुधारित योग्यता मानदंड स्थापित करें

![लीड फ़िल्टरिंग कॉन्फ़िगरेशन](https://assets.scrapeless.com/prod/posts/build-b2b-lead-generation-workflow-with-n8n/ad0e0cc63715193510af41fc38841a52.png)


### 1. नया IF नोड कॉन्फ़िगरेशन

अब जब डेटा सही ढंग से पार्स किया गया है, तो IF नोड में इन शर्तों का उपयोग करें:

**1: कई शर्तें जोड़ें**

**शर्त 1:**
- फ़ील्ड: {{ $json.lead_score }}
- ऑपरेटर: के बराबर या अधिक
- मान: 6

**शर्त 2:**
- फ़ील्ड: {{ $json.claude_processing_status }}
- ऑपरेटर: के बराबर
- मान: सफल

विकल्प: आवश्यकतानुसार प्रकार रूपांतरित करें
- सही


![लीड फ़िल्टरिंग कॉन्फ़िगरेशन](https://assets.scrapeless.com/prod/posts/build-b2b-lead-generation-workflow-with-n8n/1942aa09d81e10b991722980288346f7.png)

### 2. फ़िल्टरिंग लाभ

- गुणवत्ता आश्वासन: केवल योग्य लीड संग्रहण के लिए आगे बढ़ते हैं
- लागत अनुकूलन: निम्न गुणवत्ता वाली लीड को संसाधित करने से रोकता है
- डेटा अखंडता: सुनिश्चित करता है कि पार्स किया गया डेटा संग्रहण से पहले मान्य है
- डिबग क्षमता: विफल पार्सिंग को पकड़ लिया गया है और लॉग किया गया है


## चरण 9: Google शीट्स में लीड संग्रहण
योग्य लीड को आसान पहुंच और प्रबंधन के लिए एक Google शीट्स डेटाबेस में संग्रहीत करें।

1. फ़िल्टर के बाद एक Google शीट्स नोड जोड़ें
2. नए लीड को जोड़ने के लिए कॉन्फ़िगर करें
हालांकि, आप चाहें तो डेटा को अपने अनुसार प्रबंधित कर सकते हैं।

![Google शीट्स कॉन्फ़िगरेशन](https://assets.scrapeless.com/prod/posts/build-b2b-lead-generation-workflow-with-n8n/8fb4f8fbfc0448e4b0577585cbfeec2a.png)

![Google शीट्स कॉन्फ़िगरेशन](https://assets.scrapeless.com/prod/posts/build-b2b-lead-generation-workflow-with-n8n/32739a965efc954f6bca1aca4e712676.png)

**Google शीट्स सेटअप:**

{
  "embeds": [
    {
      "title": "🎯 नया योग्य लीड मिला!",
      "description": "**{{ $json.company_name || 'अज्ञात कंपनी' }}** (स्कोर: {{ $json.lead_score || 0 }}/10)",
      "color": 3066993,
      "fields": [
        {
          "name": "उद्योग",
          "value": "{{ $json.industry || 'निर्दिष्ट नहीं' }}",
          "inline": true
        },
        {
          "name": "आकार",
          "value": "{{ $json.company_size || 'निर्दिष्ट नहीं' }}",
          "inline": true
        },
        {
          "name": "स्थान",
          "value": "{{ $json.location || 'निर्दिष्ट नहीं' }}",
          "inline": true
        },
        {
          "name": "संपर्क",
          "value": "{{ $json.contact_email || 'कोई ईमेल नहीं मिला' }}",
          "inline": false
        },
        {
          "name": "फोन",
          "value": "{{ $json.phone || 'कोई फोन नहीं मिला' }}",
          "inline": false
        },
        {
          "name": "सेवाएँ",
          "value": "{{ $json.key_services && $json.key_services.length > 0 ? $json.key_services.slice(0, 3).join(', ') : 'निर्दिष्ट नहीं' }}",
          "inline": false
        },
        {
          "name": "वेबसाइट",
          "value": "[वेबसाइट पर जाएँ]({{ $node['Code2'].json.url || '#' }})",
          "inline": false
        },
        {
          "name": "क्यों योग्य",
          "value": "{{ $json.qualification_reasons && $json.qualification_reasons.length > 0 ? $json.qualification_reasons.slice(0, 2).join(' • ') : 'मानक योग्यता मापदंड पूरे हुए' }}",
          "inline": false
        }
      ],
      "footer": {
        "text": "n8n लीड जनरेशन वर्कफ़्लो द्वारा उत्पन्न"
      },
      "timestamp": ""
    }
  ]
}

"SaaS कंपनियाँ" "B2B सॉफ्टवेयर" "Enterprise software"
"क्लाउड सॉफ्टवेयर" "API" "डेवलपर्स" "सदस्यता मॉडल"
"सॉफ्टवेयर को सेवा के रूप में" "प्लेटफ़ॉर्म" "इंटिग्रेशन"

"डिजिटल मार्केटिंग एजेंसी" "B2B मार्केटिंग" "Enterprise clients"
"मार्केटिंग स्वचालन" "डिमांड जनरेशन" "लीड जनरेशन"
"सामग्री मार्केटिंग एजेंसी" "विकास मार्केटिंग" "प्रदर्शन मार्केटिंग"

"ईकॉमर्स कंपनियाँ" "ऑनलाइन रिटेल" "D2C ब्रांड"
"Shopify स्टोर" "WooCommerce" "ईकॉमर्स प्लेटफॉर्म"
"ऑनलाइन मार्केटप्लेस" "डिजिटल वाणिज्य" "रिटेल तकनीक"