उत्पादएकीकरणसंसाधनदस्तावेजीकरणमूल्य निर्धारण
अभी शुरू करें

© 2026 CapSolver. All rights reserved.

हमसे संपर्क करें

Slack: lola@capsolver.com

उत्पाद

  • reCAPTCHA v2
  • reCAPTCHA v3
  • Cloudflare Turnstile
  • Cloudflare Challenge
  • AWS WAF
  • ब्राउज़र एक्सटेंशन
  • अधिक कैप्चा प्रकार

एकीकरण

  • Selenium
  • Playwright
  • Puppeteer
  • n8n
  • साझेदार
  • सभी एकीकरण देखें

संसाधन

  • रेफरल प्रोग्राम
  • दस्तावेजीकरण
  • API संदर्भ
  • ब्लॉग
  • FAQ
  • शब्दावली
  • स्थिति

कानूनी

  • सेवा की शर्तें
  • गोपनीयता नीति
  • धनवापसी नीति
  • मेरी व्यक्तिगत जानकारी न बेचें
ब्लॉग/n8n/CapSolver और n8n का उपयोग करके ImageToText समस्या को कैसे हल करें
Mar16, 2026

CapSolver और n8n का उपयोग करके ImageToText समस्या को कैसे हल करें

Rajinder Singh

Rajinder Singh

Deep Learning Researcher

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

क्या होगा यदि आप अपने n8n वर्कफ़्लो के अंदर इमेज कैप्चा को स्वचालित रूप से हल कर सकते हैं — चाहे आप एक पुन: प्रयोज्य सॉल्वर एपीआई बना रहे हों या एक फ़ॉर्म सबमिशन को स्वचालित कर रहे हों जिसमें कैप्चा इमेज को पढ़ने की आवश्यकता हो — यह सब एक भी मॉडल को प्रशिक्षित किए बिना?

इस गाइड में, आप सीखेंगे कि n8n (एक विज़ुअल वर्कफ़्लो ऑटोमेशन टूल) को CapSolver (एक AI-संचालित कैप्चा सॉल्विंग सेवा) के साथ कैसे संयोजित करें ताकि इमेज टू टेक्स्ट कैप्चा को मांग पर हल किया जा सके — या तो एक स्टैंडअलोन एपीआई एंडपॉइंट के रूप में या किसी भी ऑटोमेशन वर्कफ़्लो के अंदर एक कदम के रूप में।

आप क्या बनाएंगे:

सॉल्वर एपीआई — एक पुन: प्रयोज्य एंडपॉइंट जिसे आपके अन्य उपकरण कॉल कर सकते हैं:

  • एक इमेज टू टेक्स्ट सॉल्वर एपीआई जो एक base64 इमेज को स्वीकार करता है और मान्यता प्राप्त टेक्स्ट लौटाता है

प्रत्यक्ष-उपयोग वर्कफ़्लो — CapSolver एक बड़े ऑटोमेशन के अंदर एक कदम के रूप में एम्बेडेड है:

  • एक फ़ॉर्म ऑटोमेशन जो एक लक्ष्य साइट से एक कैप्चा इमेज प्राप्त करता है, इसे base64 में परिवर्तित करता है, इसे CapSolver के साथ हल करता है, और मान्यता प्राप्त टेक्स्ट के साथ फ़ॉर्म सबमिट करता है

इमेज टू टेक्स्ट (ImageToTextTask) क्या है?

इमेज टू टेक्स्ट CapSolver की OCR-आधारित पहचान सेवा है। आप एक कैप्चा की base64-एन्कोडेड इमेज भेजते हैं, और CapSolver तुरंत मान्यता प्राप्त टेक्स्ट — अक्षर, संख्या, या दोनों — लौटाता है।

यह reCAPTCHA या Turnstile जैसे अन्य CapSolver ऑपरेशनों से मौलिक रूप से अलग है:

विशेषता इमेज टू टेक्स्ट (पहचान) reCAPTCHA / Turnstile (टोकन)
संसाधन प्रकार पहचान टोकन
इनपुट Base64 इमेज वेबसाइट URL + साइट कुंजी
परिणाम मान्यता प्राप्त टेक्स्ट (तत्काल) टोकन (पोलिंग की आवश्यकता है)
प्रॉक्सी की आवश्यकता है नहीं कार्य प्रकार पर निर्भर करता है
उपयोग का मामला एक इमेज से विकृत टेक्स्ट पढ़ें एक सत्यापन टोकन उत्पन्न करें

मुख्य अंतर यह है कि पहचान ऑपरेशन तुरंत परिणाम लौटाते हैं — कोई कार्य निर्माण और फिर पोलिंग नहीं होती है। आप इमेज भेजते हैं, CapSolver इसे पढ़ता है, और टेक्स्ट एक ही अनुरोध-प्रतिक्रिया चक्र में वापस आ जाता है।

आवश्यक पैरामीटर

पैरामीटर मान विवरण
body Base64 स्ट्रिंग कैप्चा इमेज, base64-एन्कोडेड। कोई नई लाइन नहीं, कोई data:image/...;base64, उपसर्ग नहीं — केवल कच्ची base64 स्ट्रिंग
module "common" पहचान मॉड्यूल। "common" सामान्य अल्फ़ान्यूमेरिक OCR को संभालता है

वैकल्पिक पैरामीटर

पैरामीटर विवरण
websiteURL उस पृष्ठ का URL जहाँ कैप्चा दिखाई देता है (CapSolver को पहचान को अनुकूलित करने में मदद करता है)
images (1-9) मल्टी-इमेज न्यूमेरिक कैप्चा को हल करते समय "number" मॉड्यूल के लिए अतिरिक्त इमेज

मॉड्यूल प्रकार

मॉड्यूल उद्देश्य
common सामान्य OCR — अक्षर, संख्या, मिश्रित वर्ण। अधिकांश कैप्चा के लिए डिफ़ॉल्ट
number केवल न्यूमेरिक कैप्चा। images पैरामीटर के माध्यम से 9 अतिरिक्त इमेज के साथ बैच सॉल्विंग का समर्थन करता है

पूर्वापेक्षाएँ

शुरू करने से पहले, सुनिश्चित करें कि आपके पास निम्नलिखित हैं:

  1. एक n8n इंस्टेंस — या तो स्व-होस्टेड या n8n क्लाउड
  2. एक CapSolver खाता — यहां साइन अप करें और अपनी एपीआई कुंजी प्राप्त करें
  3. CapSolver n8n नोड — n8n में एक आधिकारिक नोड के रूप में पहले से ही उपलब्ध है (कोई इंस्टॉलेशन की आवश्यकता नहीं)

महत्वपूर्ण: सुनिश्चित करें कि आपके CapSolver खाते में पर्याप्त शेष राशि है। ImageToText कार्य उपयोग के आधार पर क्रेडिट का उपभोग करते हैं।


n8n में CapSolver सेट करना

CapSolver n8n में एक आधिकारिक एकीकरण के रूप में उपलब्ध है — किसी समुदाय नोड इंस्टॉलेशन की आवश्यकता नहीं है। आप इसे अपने वर्कफ़्लो बनाते समय सीधे नोड पैनल में पा सकते हैं।

चूंकि यह एक आधिकारिक एकीकरण है, आपको n8n में एक क्रेडेंशियल बनाना होगा ताकि CapSolver नोड आपके खाते के साथ प्रमाणित हो सके।

चरण 1: क्रेडेंशियल पृष्ठ खोलें

अपने n8n इंस्टेंस पर जाएं और सेटिंग्स -> क्रेडेंशियल पर नेविगेट करें। आपको यहां अपने सभी कॉन्फ़िगर किए गए क्रेडेंशियल दिखाई देंगे।

n8n क्रेडेंशियल पृष्ठ CapSolver खाता दिखा रहा है

चरण 2: CapSolver क्रेडेंशियल बनाएं

  1. क्रेडेंशियल बनाएं पर क्लिक करें (ऊपर दाएं)
  2. "CapSolver" खोजें और CapSolver API का चयन करें
  3. अपनी एपीआई कुंजी दर्ज करें — इसे सीधे CapSolver डैशबोर्ड से कॉपी करें
  4. अनुमत HTTP अनुरोध डोमेन को All (डिफ़ॉल्ट) पर सेट रहने दें
  5. सहेजें पर क्लिक करें

n8n स्वचालित रूप से कनेक्शन का परीक्षण करेगा। आपको एक हरा "कनेक्शन सफलतापूर्वक परीक्षण किया गया" बैनर दिखाई देना चाहिए जो पुष्टि करता है कि आपकी एपीआई कुंजी वैध है।

सफल कनेक्शन परीक्षण के साथ CapSolver क्रेडेंशियल कॉन्फ़िगरेशन

महत्वपूर्ण: आपके वर्कफ़्लो में प्रत्येक CapSolver नोड इस क्रेडेंशियल को संदर्भित करेगा। आपको इसे केवल एक बार बनाने की आवश्यकता है — आपके सभी सॉल्वर वर्कफ़्लो एक ही क्रेडेंशियल साझा करेंगे।

अब आप अपना इमेज टू टेक्स्ट सॉल्वर वर्कफ़्लो बनाने के लिए तैयार हैं!


कैप्चा इमेज के लिए Base64 एन्कोडिंग को समझना

वर्कफ़्लो में गोता लगाने से पहले, ImageToTextTask के लिए base64 आवश्यकताओं को समझना महत्वपूर्ण है। यह त्रुटियों का सबसे आम स्रोत है।

CapSolver क्या उम्मीद करता है

body पैरामीटर में एक स्वच्छ base64 स्ट्रिंग होनी चाहिए — इमेज फ़ाइल के कच्चे एन्कोडेड बाइट्स। विशेष रूप से:

  • कोई data: उपसर्ग नहीं — यदि आपके पास data:image/png;base64,iVBORw0KGgo... है, तो आपको data:image/png;base64, भाग को हटाना होगा
  • कोई नई लाइन नहीं — base64 स्ट्रिंग में कोई \n वर्ण नहीं होना चाहिए
  • कोई व्हाइटस्पेस नहीं — कोई स्पेस, टैब या अन्य व्हाइटस्पेस वर्ण नहीं

n8n में एक स्वच्छ Base64 स्ट्रिंग कैसे प्राप्त करें

जब आप n8n में एक HTTP अनुरोध नोड के साथ एक इमेज प्राप्त करते हैं, तो प्रतिक्रिया बाइनरी डेटा के रूप में आती है। इसे CapSolver के लिए base64 में बदलने के लिए, एक कोड नोड का उपयोग करें:

javascript Copy
// बाइनरी इमेज डेटा को स्वच्छ base64 में परिवर्तित करें
const binaryData = $input.first().binary.data;
const base64String = binaryData.data; // n8n के बाइनरी प्रारूप में पहले से ही base64

// यदि मौजूद हो तो data: उपसर्ग हटा दें (सुरक्षा जांच)
const cleanBase64 = base64String.replace(/^data:image\/\w+;base64,/, '');

// कोई भी नई लाइन हटा दें
const finalBase64 = cleanBase64.replace(/\n/g, '');

return [{ json: { body: finalBase64 } }];

सामान्य गलतियाँ

गलती परिणाम
data:image/png;base64,... भेजना CapSolver बॉडी को अमान्य के रूप में अस्वीकार करता है
Base64 स्ट्रिंग में नई लाइनें हैं CapSolver इमेज को डिकोड नहीं कर सकता
base64 के बजाय इमेज URL भेजना गलत पैरामीटर — body को base64 की उम्मीद है, URL की नहीं
एक खाली स्ट्रिंग भेजना CapSolver एक त्रुटि लौटाता है

वर्कफ़्लो 1: इमेज टू टेक्स्ट सॉल्वर एपीआई

यह वर्कफ़्लो एक POST एपीआई एंडपॉइंट बनाता है जो एक base64 कैप्चा इमेज को स्वीकार करता है और मान्यता प्राप्त टेक्स्ट लौटाता है।

यह कैसे काम करता है

वर्कफ़्लो में छह नोड होते हैं:

  1. सॉल्वर अनुरोध प्राप्त करें — वेबहुक जो इमेज डेटा के साथ POST अनुरोध प्राप्त करता है
  2. इमेज इनपुट को मान्य करें — कोड नोड जो जांचता है कि body मौजूद है और वैध base64 है
  3. इमेज कैप्चा हल करें — CapSolver नोड संसाधन = पहचान, ऑपरेशन = इमेज टू टेक्स्ट का उपयोग कर रहा है
  4. इमेज कैप्चा त्रुटि? — IF नोड जो हल करने में विफल होने पर शाखाएं बनाता है
  5. वेबहुक को जवाब दें — सफलता पर मान्यता प्राप्त टेक्स्ट लौटाता है
  6. वेबहुक त्रुटि को जवाब दें — विफलता पर त्रुटि संदेश लौटाता है

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

1. सॉल्वर अनुरोध प्राप्त करें (वेबहुक)

सेटिंग मान
HTTP विधि POST
पथ solver-image-to-text
जवाब दें Response Node

यह इस पर एक एंडपॉइंट बनाता है: https://your-n8n-instance.com/webhook/solver-image-to-text

2. इमेज इनपुट को मान्य करें (कोड)

यह नोड जांचता है कि अनुरोध बॉडी में एक वैध body पैरामीटर है और किसी भी आकस्मिक data: उपसर्ग या नई लाइनों को हटा देता है:

javascript Copy
const body = $input.first().json.body;

if (!body || !body.body) {
  return [{ json: { error: 'Missing required field: body (base64 encoded image)' } }];
}

let imageBase64 = String(body.body);

// यदि गलती से शामिल हो तो data: उपसर्ग हटा दें
imageBase64 = imageBase64.replace(/^data:image\/\w+;base64,/, '');

// नई लाइनें और व्हाइटस्पेस हटा दें
imageBase64 = imageBase64.replace(/[\n\r\s]/g, '');

// मूल base64 सत्यापन
if (!/^[A-Za-z0-9+/]+=*$/.test(imageBase64)) {
  return [{ json: { error: 'Invalid base64 encoding in body field' } }];
}

return [{
  json: {
    body: imageBase64,
    module: body.module || 'common'
  }
}];

3. इमेज कैप्चा हल करें (CapSolver)

पैरामीटर मान विवरण
संसाधन Recognition पहचान संसाधन का चयन करता है (टोकन नहीं)
ऑपरेशन Image To Text ImageToTextTask ऑपरेशन
बॉडी {{ $json.body }} स्वच्छ base64 इमेज स्ट्रिंग
मॉड्यूल {{ $json.module }} पहचान मॉड्यूल (डिफ़ॉल्ट: common)

महत्वपूर्ण: CapSolver नोड में, आपको पहले संसाधन = पहचान का चयन करना होगा, फिर ऑपरेशन = इमेज टू टेक्स्ट। यह reCAPTCHA या Turnstile जैसे टोकन ऑपरेशनों से अलग है। इस नोड में अपने CapSolver क्रेडेंशियल का भी चयन करें।

4. इमेज कैप्चा त्रुटि? (IF)

सेटिंग मान
शर्त ={{ $json.error }} खाली नहीं है
सही शाखा त्रुटि वेबहुक नोड को जवाब दें पर रूट करता है
गलत शाखा सफलता वेबहुक नोड को जवाब दें पर रूट करता है

CapSolver नोड त्रुटि पर जारी रहता है (onError: continueRegularOutput), इसलिए विफलताएं यहां { "error": "..." } के रूप में आती हैं, न कि वर्कफ़्लो को क्रैश करती हैं।

5. वेबहुक को जवाब दें (सफलता)

सेटिंग मान
इसके साथ जवाब दें JSON
प्रतिक्रिया बॉडी ={{ JSON.stringify($json.data) }}

6. वेबहुक त्रुटि को जवाब दें

सेटिंग मान
इसके साथ जवाब दें JSON
प्रतिक्रिया बॉडी ={{ JSON.stringify({ error: $json.error }) }}

त्रुटि संदेश दो प्रारूपों में से एक का पालन करते हैं:

विफलता बिंदु प्रारूप
कार्य निर्माण { "error": "..." }
CapSolver त्रुटि { "error": "..." }
वर्कफ़्लो JSON का विस्तार करने के लिए क्लिक करें
json Copy
{
  "nodes": [
    {
      "parameters": {
        "httpMethod": "POST",
        "path": "solver-image-to-text",
        "responseMode": "responseNode",
        "options": {}
      },
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 2.1,
      "position": [
        -400,
        0
      ],
      "id": "fa-101",
      "name": "Receive Solver Request",
      "webhookId": "fa-101-webhook",
      "onError": "continueRegularOutput"
    },
    {
      "parameters": {
        "jsCode": "const body = $input.first().json.body;\n\nif (!body || !body.body) {\n  return [{ json: { error: 'Missing required field: body (base64 encoded image)' } }];\n}\n\nlet imageBase64 = String(body.body);\n\n// Strip data: prefix if accidentally included\nimageBase64 = imageBase64.replace(/^data:image\\/\\w+;base64,/, '');\n\n// Remove newlines and whitespace\nimageBase64 = imageBase64.replace(/[\\n\\r\\s]/g, '');\n\n// Basic base64 validation\nif (!/^[A-Za-z0-9+/]+=*$/.test(imageBase64)) {\n  return [{ json: { error: 'Invalid base64 encoding in body field' } }];\n}\n\nreturn [{\n  json: {\n    body: imageBase64,\n    module: body.module || 'common'\n  }\n}];"
      },
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [
        -96,
        0
      ],
      "id": "fa-102",
      "name": "Validate Image Input"
    },
    {
      "parameters": {
        "resource": "Recognition",
        "module": "={{ $json.module }}",
        "body": "={{ $json.body }}",
        "optional": {}
      },
      "type": "n8n-nodes-capsolver.capSolver",
      "typeVersion": 1,
      "position": [
        208,
        0
      ],
      "id": "fa-103",
      "name": "Solve Image Captcha",
      "credentials": {
        "capSolverApi": {
          "id": "BeBFMAsySMsMGeE9",
          "name": "CapSolver account"
        }
      },
      "onError": "continueRegularOutput"
    },
    {
      "parameters": {
        "conditions": {
          "options": {
            "caseSensitive": false,
            "leftValue": "",
            "typeValidation": "strict",
            "version": 2
          },
          "conditions": [
            {
              "id": "fa-if-001",
              "leftValue": "={{ $json.error }}",
              "rightValue": "",
              "operator": {
                "type": "string",
                "operation": "isNotEmpty"
              }
            }
          ],
          "combinator": "and"
        },
        "options": {}
      },
      "type": "n8n-nodes-base.if",
      "typeVersion": 2.2,
      "position": [
        512,
        0
      ],
      "id": "fa-104",
      "name": "Image Captcha Error?"
    },
    {
      "parameters": {
        "respondWith": "json",
        "responseBody": "={{ JSON.stringify($json.data) }}",
        "options": {}
      },
      "type": "n8n-nodes-base.respondToWebhook",
      "typeVersion": 1.5,
      "position": [
        816,
        -176
      ],
      "id": "fa-105",
      "name": "Respond to Webhook"
    },
    {
      "parameters": {
        "respondWith": "json",
        "responseBody": "={{ JSON.stringify({ error: $json.error }) }}",
        "options": {}
      },
      "type": "n8n-nodes-base.respondToWebhook",
      "typeVersion": 1.5,
      "position": [
        816,
        32
      ],
      "id": "fa-106",
      "name": "Respond to Webhook Error"
    }
  ],
  "connections": {
    "Receive Solver Request": {
      "main": [
        [
          {
            "node": "Validate Image Input",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Validate Image Input": {
      "main": [
        [
          {
            "node": "Solve Image Captcha",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Solve Image Captcha": {
      "main": [
        [
          {
            "node": "Image Captcha Error?",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Image Captcha Error?": {
      "main": [
        [
          {
            "node": "Respond to Webhook Error",
            "type": "main",
            "index": 0
          }
        ],
        [
          {
            "node": "Respond to Webhook",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  },
  "pinData": {},
  "meta": {
    "instanceId": "962ff0267b713be0344b866fa54daae28de8ed2144e2e6867da355dae193ea1f"
  }
}

वर्कफ़्लो 2: फ़ॉर्म ऑटोमेशन — इमेज कैप्चा हल करें और सबमिट करें

यह वर्कफ़्लो एक इमेज कैप्चा द्वारा संरक्षित साइट पर एंड-टू-एंड फ़ॉर्म सबमिशन को स्वचालित करता है। यह लक्ष्य साइट से कैप्चा इमेज प्राप्त करता है, इसे base64 में परिवर्तित करता है, इसे CapSolver के साथ हल करता है, और मान्यता प्राप्त टेक्स्ट के साथ फ़ॉर्म सबमिट करता है।

यह दो सक्रियण मोड का समर्थन करता है:

  • शेड्यूल: हर 6 घंटे में स्वचालित रूप से चलाएं
  • वेबहुक: मांग पर ट्रिगर करें और परिणाम को JSON के रूप में लौटाएं

यह कैसे काम करता है

शेड्यूल पथ:

Copy
हर 6 घंटे → लक्ष्य कॉन्फ़िग सेट करें → कैप्चा इमेज प्राप्त करें → Base64 में परिवर्तित करें
  → इमेज कैप्चा हल करें → समाधान के साथ फ़ॉर्म सबमिट करें → सबमिशन परिणाम जांचें
  → सफलता चिह्नित करें / विफलता चिह्नित करें

वेबहुक पथ:

Copy
वेबहुक ट्रिगर → लक्ष्य कॉन्फ़िग सेट करें [वेबहुक] → कैप्चा इमेज प्राप्त करें [वेबहुक]
  → Base64 में परिवर्तित करें [वेबहुक] → इमेज कैप्चा हल करें [वेबहुक]
  → समाधान के साथ फ़ॉर्म सबमिट करें [वेबहुक] → सबमिशन परिणाम जांचें [वेबहुक]
  → सफलता चिह्नित करें [वेबहुक] / विफलता चिह्नित करें [वेबहुक] → वेबहुक को जवाब दें

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

1. ट्रिगर नोड

शेड्यूल ट्रिगर:

सेटिंग मान
अंतराल हर 6 घंटे

वेबहुक ट्रिगर:

सेटिंग मान
HTTP विधि POST
पथ image-captcha-form
जवाब दें Response Node

2. लक्ष्य कॉन्फ़िग सेट करें

यह नोड लक्ष्य साइट के लिए सभी कॉन्फ़िगरेशन को एक ही स्थान पर संग्रहीत करता है:

कॉन्फ़िग फ़ील्ड उद्देश्य
captchaImageURL कैप्चा इमेज प्रदान करने वाला URL (जैसे, https://example.com/captcha.png)
formActionURL फ़ॉर्म POST प्राप्त करने वाला एंडपॉइंट
captchaFieldName कैप्चा उत्तर के लिए फ़ॉर्म फ़ील्ड नाम (जैसे, captcha, captcha_code, verification)
module CapSolver पहचान मॉड्यूल (सामान्य OCR के लिए common, केवल न्यूमेरिक के लिए number)
userAgent अनुरोधों के साथ भेजने के लिए उपयोगकर्ता एजेंट स्ट्रिंग

3. कैप्चा इमेज प्राप्त करें (HTTP अनुरोध)

सेटिंग मान
विधि GET
URL ={{ $json.captchaImageURL }}
प्रतिक्रिया प्रारूप File (बाइनरी)

यह कैप्चा इमेज को बाइनरी डेटा के रूप में डाउनलोड करता है। प्रतिक्रिया $binary.data में उपलब्ध होगी।

नोट: कुछ साइटों को कैप्चा इमेज प्रदान करने के लिए कुकीज़ या सत्र हेडर की आवश्यकता होती है। यदि कैप्चा सत्र-बाउंड है, तो आपको सत्र कुकी प्राप्त करने और इसे आगे पास करने के लिए एक पूर्व अनुरोध जोड़ने की आवश्यकता हो सकती है।

4. Base64 में परिवर्तित करें (कोड)

javascript Copy
// बाइनरी कैप्चा इमेज को एक स्वच्छ base64 स्ट्रिंग में परिवर्तित करें
const binaryData = $input.first().binary.data;
const base64String = binaryData.data;

// यदि मौजूद हो तो data: उपसर्ग हटा दें
const cleanBase64 = base64String.replace(/^data:image\/\w+;base64,/, '');

// कोई भी नई लाइन हटा दें
const finalBase64 = cleanBase64.replace(/\n/g, '');

// लक्ष्य कॉन्फ़िग को सेट टारगेट कॉन्फ़िग नोड से पास करें
const config = $('Set Target Config').first().json;

return [{
  json: {
    body: finalBase64,
    module: config.module || 'common',
    captchaFieldName: config.captchaFieldName,
    formActionURL: config.formActionURL,
    userAgent: config.userAgent
  }
}];

5. इमेज कैप्चा हल करें (CapSolver पहचान)

पैरामीटर मान
संसाधन Recognition
ऑपरेशन Image To Text
बॉडी {{ $json.body }}
मॉड्यूल {{ $json.module }}

यह $json.data.solution.text में तुरंत मान्यता प्राप्त टेक्स्ट लौटाता है।

6. समाधान के साथ फ़ॉर्म सबमिट करें (HTTP अनुरोध)

सेटिंग मान
विधि POST
URL ={{ $('Set Target Config').first().json.formActionURL }}
बॉडी फ़ील्ड फ़ॉर्म फ़ील्ड + कैप्चा उत्तर

कैप्चा उत्तर captchaFieldName द्वारा निर्दिष्ट फ़ील्ड में जाता है:

फ़ील्ड मान
username your-username
password your-password
{{ captchaFieldName }} ={{ $json.data.solution.text }}

7. सबमिशन परिणाम जांचें (IF)

सेटिंग मान
शर्त {{ $json.statusCode < 400 }} — जांचता है कि HTTP प्रतिक्रिया सफलता का संकेत देती है
सही शाखा सफलता चिह्नित करें
गलत शाखा विफलता चिह्नित करें

इसका परीक्षण करें

फ़ॉर्म ऑटोमेशन को ट्रिगर करने के लिए एक POST अनुरोध भेजें:

bash Copy
curl -X POST https://your-n8n-instance.com/webhook/image-captcha-form \
  -H "Content-Type: application/json" \
  -d '{}'

अपेक्षित प्रतिक्रिया (सफलता):

json Copy
{
  "action": "form_submission",
  "status": "success",
  "captchaText": "xK7mQ",
  "message": "Form submitted successfully with solved captcha",
  "submittedAt": "2026-03-16T12:00:00.000Z"
}

अपेक्षित प्रतिक्रिया (विफलता):

json Copy
{
  "action": "form_submission",
  "status": "failed",
  "statusCode": 403,
  "message": "Form submission was rejected by the target site",
  "submittedAt": "2026-03-16T12:00:00.000Z"
}

इस वर्कफ़्लो को आयात करें

नीचे दिए गए JSON को कॉपी करें और इसे n8n में मेनू -> JSON से आयात करें के माध्यम से आयात करें:

वर्कफ़्लो JSON का विस्तार करने के लिए क्लिक करें
json Copy
{
  "nodes": [
    {
      "parameters": {
        "content": "## फ़ॉर्म ऑटोमेशन — इमेज कैप्चा हल करें और सबमिट करें\n\n### यह कैसे काम करता है\n\n1. हर 6 घंटे में या वेबहुक के माध्यम से फ़ॉर्म ऑटोमेशन शुरू करता है।\n2. कैप्चा इमेज को पुनः प्राप्त करता है और हल करने के लिए Base64 में परिवर्तित करता है।\n3. एक सॉल्वर सेवा का उपयोग करके कैप्चा को हल करता है।\n4. समाधान के साथ फ़ॉर्म सबमिट करता है और परिणाम की जांच करता है।\n5. सबमिशन को सफलता या विफलता के रूप में चिह्नित करता है और उचित रूप से जवाब देता है।\n6. वेबहुक ट्रिगर का उपयोग करते समय वेबहुक को प्रतिक्रिया प्रदान करता है।\n\n### सेटअप चरण\n\n- [ ] 'हर 6 घंटे' में उचित क्रॉन पैटर्न के साथ शेड्यूलिंग सेट करें।\n- [ ] 'वेबहुक ट्रिगर' में वेबहुक एंडपॉइंट कॉन्फ़िगर करें।\n- [ ] 'लक्ष्य कॉन्फ़िग सेट करें' और 'लक्ष्य कॉन्फ़िग सेट करें [वेबहुक]' में URL और फ़ील्ड नाम सेट करें।\n- [ ] 'इमेज कैप्चा हल करें' और 'इमेज कैप्चा हल करें [वेबहुक]' में बाहरी कैप्चा सॉल्विंग सेवा कॉन्फ़िगर करें।\n- [ ] सुनिश्चित करें कि 'समाधान के साथ फ़ॉर्म सबमिट करें' और 'समाधान के साथ फ़ॉर्म सबमिट करें [वेबहुक]' में फ़ॉर्म सही ढंग से सबमिट होता है।\n",
        "width": 480,
        "height": 896
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [
        -1008,
        -368
      ],
      "id": "9d0cbf33-48a7-479e-a214-b74428b8d649",
      "name": "Sticky Note"
    },
    {
      "parameters": {
        "content": "## निर्धारित ट्रिगर सेटअप\n\nहर 6 घंटे में वर्कफ़्लो शुरू करता है।",
        "width": 240,
        "height": 304,
        "color": 7
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [
        -448,
        -128
      ],
      "id": "56fe23e6-067c-4bae-b358-1a03dcccb4ae",
      "name": "Sticky Note1"
    },
    {
      "parameters": {
        "content": "## कैप्चा इमेज प्राप्त करें\n\nनिर्धारित ट्रिगर के लिए कॉन्फ़िगरेशन सेट करता है और कैप्चा इमेज को पुनः प्राप्त करता है।",
        "width": 496,
        "height": 304,
        "color": 7
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [
        -144,
        -128
      ],
      "id": "d95b86f5-1f09-4fe5-a76f-47ab77aaa569",
      "name": "Sticky Note2"
    },
    {
      "parameters": {
        "content": "## कैप्चा को संसाधित और हल करें\n\nकैप्चा इमेज को Base64 में परिवर्तित करता है और इसे हल करता है।",
        "width": 624,
        "height": 272,
        "color": 7
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [
        464,
        -112
      ],
      "id": "84169773-de21-4ae5-9e5b-146067c1da53",
      "name": "Sticky Note3"
    },
    {
      "parameters": {
        "content": "## फ़ॉर्म सबमिट करें और परिणाम जांचें\n\nकैप्चा समाधान के साथ फ़ॉर्म सबमिट करता है और सबमिशन परिणाम की जांच करता है।",
        "width": 496,
        "height": 304,
        "color": 7
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [
        1200,
        -128
      ],
      "id": "223d89bf-0d07-4673-b57a-39468f219885",
      "name": "Sticky Note4"
    },
    {
      "parameters": {
        "content": "## सबमिशन परिणाम को संभालें\n\nपरिणाम के आधार पर सबमिशन को सफलता या विफलता के रूप में चिह्नित करता है।",
        "width": 240,
        "height": 560,
        "color": 7
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [
        1808,
        -368
      ],
      "id": "8dcf905b-2a72-49bd-a426-0825ba802b1e",
      "name": "Sticky Note5"
    },
    {
      "parameters": {
        "content": "## वेबहुक ट्रिगर सेटअप\n\nवेबहुक कॉल पर वर्कफ़्लो शुरू करता है।",
        "width": 240,
        "height": 304,
        "color": 7
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [
        -448,
        400
      ],
      "id": "b17c4781-3b03-44c2-9a74-03886a009e62",
      "name": "Sticky Note6"
    },
    {
      "parameters": {
        "content": "## वेबहुक इमेज प्रोसेसिंग\n\nवेबहुक ट्रिगर के लिए कैप्चा को प्राप्त करता है, संसाधित करता है और हल करता है।",
        "width": 1232,
        "height": 272,
        "color": 7
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [
        -144,
        416
      ],
      "id": "bf814840-0020-4d18-a0b7-43c9ee2f2406",
      "name": "Sticky Note7"
    },
    {
      "parameters": {
        "content": "## वेबहुक फ़ॉर्म सबमिट करें\n\nवेबहुक ट्रिगर के लिए फ़ॉर्म सबमिट करता है और परिणाम की जांच करता है।",
        "width": 496,
        "height": 272,
        "color": 7
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [
        1200,
        416
      ],
      "id": "8ccf3071-0112-4972-9011-cd38816fb8f1",
      "name": "Sticky Note8"
    },
    {
      "parameters": {
        "content": "## वेबहुक सबमिशन परिणाम\n\nसबमिशन परिणाम को संभालता है और वेबहुक कॉल का जवाब देता है।",
        "width": 496,
        "height": 448,
        "color": 7
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [
        1808,
        304
      ],
      "id": "ed3b0f29-a57c-487f-91fc-979bb3d1525b",
      "name": "Sticky Note9"
    },
    {
      "parameters": {
        "rule": {
          "interval": [
            {
              "field": "hours",
              "hoursInterval": 6
            }
          ]
        }
      },
      "type": "n8n-nodes-base.scheduleTrigger",
      "typeVersion": 1.3,
      "position": [
        -400,
        0
      ],
      "id": "fa-201",
      "name": "Every 6 Hours"
    },
    {
      "parameters": {
        "assignments": {
          "assignments": [
            {
              "id": "cfg-001",
              "name": "captchaImageURL",
              "value": "https://YOUR-TARGET-SITE.com/captcha.png",
              "type": "string"
            },
            {
              "id": "cfg-002",
              "name": "formActionURL",
              "value": "https://YOUR-TARGET-SITE.com/submit",
              "type": "string"
            },
            {
              "id": "cfg-003",
              "name": "captchaFieldName",
              "value": "captcha",
              "type": "string"
            },
            {
              "id": "cfg-004",
              "name": "module",
              "value": "common",
              "type": "string"
            },
            {
              "id": "cfg-005",
              "name": "userAgent",
              "value": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
              "type": "string"
            }
          ]
        },
        "options": {}
      },
      "type": "n8n-nodes-base.set",
      "typeVersion": 3.4,
      "position": [
        -96,
        0
      ],
      "id": "fa-202",
      "name": "Set Target Config"
    },
    {
      "parameters": {
        "url": "={{ $json.captchaImageURL }}",
        "sendHeaders": true,
        "headerParameters": {
          "parameters": [
            {
              "name": "user-agent",
              "value": "={{ $json.userAgent }}"
            }
          ]
        },
        "options": {
          "response": {
            "response": {
              "responseFormat": "file"
            }
          }
        }
      },
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.3,
      "position": [
        208,
        0
      ],
      "id": "fa-203",
      "name": "Fetch Captcha Image"
    },
    {
      "parameters": {
        "jsCode": "const binaryData = $input.first().binary.data;\nconst base64String = binaryData.data;\nconst cleanBase64 = base64String.replace(/^data:image\\/\\w+;base64,/, '');\nconst finalBase64 = cleanBase64.replace(/\\n/g, '');\nconst config = $('Set Target Config').first().json;\nreturn [{ json: { body: finalBase64, module: config.module || 'common', captchaFieldName: config.captchaFieldName, formActionURL: config.formActionURL, userAgent: config.userAgent } }];"
      },
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [
        512,
        0
      ],
      "id": "fa-204",
      "name": "Convert to Base64"
    },
    {
      "parameters": {
        "resource": "Recognition",
        "module": "={{ $json.module }}",
        "body": "={{ $json.body }}",
        "optional": {}
      },
      "type": "n8n-nodes-capsolver.capSolver",
      "typeVersion": 1,
      "position": [
        944,
        0
      ],
      "id": "fa-205",
      "name": "Solve Image Captcha",
      "credentials": {
        "capSolverApi": {
          "id": "BeBFMAsySMsMGeE9",
          "name": "CapSolver account"
        }
      },
      "onError": "continueRegularOutput"
    },
    {
      "parameters": {
        "method": "POST",
        "url": "={{ $('Set Target Config').first().json.formActionURL }}",
        "sendHeaders": true,
        "headerParameters": {
          "parameters": [
            {
              "name": "content-type",
              "value": "application/x-www-form-urlencoded"
            },
            {
              "name": "user-agent",
              "value": "={{ $('Set Target Config').first().json.userAgent }}"
            }
          ]
        },
        "sendBody": true,
        "contentType": "form-urlencoded",
        "bodyParameters": {
          "parameters": [
            {
              "name": "username",
              "value": "YOUR_USERNAME"
            },
            {
              "name": "password",
              "value": "YOUR_PASSWORD"
            },
            {
              "name": "={{ $('Set Target Config').first().json.captchaFieldName }}",
              "value": "={{ $json.data.solution.text }}"
            }
          ]
        },
        "options": {
          "response": {
            "response": {
              "fullResponse": true,
              "neverError": true
            }
          }
        }
      },
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.3,
      "position": [
        1248,
        0
      ],
      "id": "fa-206",
      "name": "Submit Form with Solution"
    },
    {
      "parameters": {
        "conditions": {
          "options": {
            "caseSensitive": false,
            "leftValue": "",
            "typeValidation": "strict",
            "version": 2
          },
          "conditions": [
            {
              "id": "fa-if-001",
              "leftValue": "={{ $json.statusCode }}",
              "rightValue": 400,
              "operator": {
                "type": "number",
                "operation": "lt"
              }
            }
          ],
          "combinator": "and"
        },
        "options": {}
      },
      "type": "n8n-nodes-base.if",
      "typeVersion": 2.2,
      "position": [
        1552,
        0
      ],
      "id": "fa-207",
      "name": "Check Submission Result"
    },
    {
      "parameters": {
        "assignments": {
          "assignments": [
            {
              "id": "ms-001",
              "name": "action",
              "value": "form_submission",
              "type": "string"
            },
            {
              "id": "ms-002",
              "name": "status",
              "value": "success",
              "type": "string"
            },
            {
              "id": "ms-003",
              "name": "captchaText",
              "value": "={{ $('Solve Image Captcha').first().json.data.solution.text }}",
              "type": "string"
            },
            {
              "id": "ms-004",
              "name": "message",
              "value": "Form submitted successfully with solved captcha",
              "type": "string"
            },
            {
              "id": "ms-005",
              "name": "submittedAt",
              "value": "={{ new Date().toISOString() }}",
              "type": "string"
            }
          ]
        },
        "options": {}
      },
      "type": "n8n-nodes-base.set",
      "typeVersion": 3.4,
      "position": [
        1856,
        -176
      ],
      "id": "fa-208",
      "name": "Mark Success"
    },
    {
      "parameters": {
        "assignments": {
          "assignments": [
            {
              "id": "mf-001",
              "name": "action",
              "value": "form_submission",
              "type": "string"
            },
            {
              "id": "mf-002",
              "name": "status",
              "value": "failed",
              "type": "string"
            },
            {
              "id": "mf-003",
              "name": "statusCode",
              "value": "={{ $json.statusCode }}",
              "type": "number"
            },
            {
              "id": "mf-004",
              "name": "message",
              "value": "Form submission was rejected by the target site",
              "type": "string"
            },
            {
              "id": "mf-005",
              "name": "submittedAt",
              "value": "={{ new Date().toISOString() }}",
              "type": "string"
            }
          ]
        },
        "options": {}
      },
      "type": "n8n-nodes-base.set",
      "typeVersion": 3.4,
      "position": [
        1856,
        32
      ],
      "id": "fa-209",
      "name": "Mark Failed"
    },
    {
      "parameters": {
        "httpMethod": "POST",
        "path": "image-captcha-form",
        "responseMode": "responseNode",
        "options": {}
      },
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 2.1,
      "position": [
        -400,
        528
      ],
      "id": "fa-210",
      "name": "Webhook Trigger",
      "webhookId": "fa-210-webhook",
      "onError": "continueRegularOutput"
    },
    {
      "parameters": {
        "assignments": {
          "assignments": [
            {
              "id": "wcfg-001",
              "name": "captchaImageURL",
              "value": "={{ $json.body.captchaImageURL }}",
              "type": "string"
            },
            {
              "id": "wcfg-002",
              "name": "formActionURL",
              "value": "={{ $json.body.formActionURL }}",
              "type": "string"
            },
            {
              "id": "wcfg-003",
              "name": "captchaFieldName",
              "value": "={{ $json.body.captchaFieldName || 'captcha' }}",
              "type": "string"
            },
            {
              "id": "wcfg-004",
              "name": "module",
              "value": "={{ $json.body.module || 'common' }}",
              "type": "string"
            },
            {
              "id": "wcfg-005",
              "name": "userAgent",
              "value": "={{ $json.body.userAgent || 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36' }}",
              "type": "string"
            }
          ]
        },
        "options": {}
      },
      "type": "n8n-nodes-base.set",
      "typeVersion": 3.4,
      "position": [
        -96,
        528
      ],
      "id": "fa-211",
      "name": "Set Target Config [Webhook]"
    },
    {
      "parameters": {
        "url": "={{ $json.captchaImageURL }}",
        "sendHeaders": true,
        "headerParameters": {
          "parameters": [
            {
              "name": "user-agent",
              "value": "={{ $json.userAgent }}"
            }
          ]
        },
        "options": {
          "response": {
            "response": {
              "fullResponse": true,
              "responseFormat": "file"
            }
          }
        }
      },
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.3,
      "position": [
        208,
        528
      ],
      "id": "fa-212",
      "name": "Fetch Captcha Image [Webhook]"
    },
    {
      "parameters": {
        "jsCode": "const binaryData = $input.first().binary.data;\nconst base64String = binaryData.data;\nconst cleanBase64 = base64String.replace(/^data:image\\/\\w+;base64,/, '');\nconst finalBase64 = cleanBase64.replace(/\\n/g, '');\nconst config = $('Set Target Config [Webhook]').first().json;\nreturn [{ json: { body: finalBase64, module: config.module || 'common', captchaFieldName: config.captchaFieldName, formActionURL: config.formActionURL, userAgent: config.userAgent } }];"
      },
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [
        512,
        528
      ],
      "id": "fa-213",
      "name": "Convert to Base64 [Webhook]"
    },
    {
      "parameters": {
        "resource": "Recognition",
        "module": "={{ $json.module }}",
        "body": "={{ $json.body }}",
        "optional": {}
      },
      "type": "n8n-nodes-capsolver.capSolver",
      "typeVersion": 1,
      "position": [
        944,
        528
      ],
      "id": "fa-214",
      "name": "Solve Image Captcha [Webhook]",
      "credentials": {
        "capSolverApi": {
          "id": "BeBFMAsySMsMGeE9",
          "name": "CapSolver account"
        }
      },
      "onError": "continueRegularOutput"
    },
    {
      "parameters": {
        "method": "POST",
        "url": "={{ $('Set Target Config [Webhook]').first().json.formActionURL }}",
        "sendHeaders": true,
        "headerParameters": {
          "parameters": [
            {
              "name": "content-type",
              "value": "application/x-www-form-urlencoded"
            },
            {
              "name": "user-agent",
              "value": "={{ $('Set Target Config [Webhook]').first().json.userAgent }}"
            }
          ]
        },
        "sendBody": true,
        "contentType": "form-urlencoded",
        "bodyParameters": {
          "parameters": [
            {
              "name": "username",
              "value": "YOUR_USERNAME"
            },
            {
              "name": "password",
              "value": "YOUR_PASSWORD"
            },
            {
              "name": "={{ $('Set Target Config [Webhook]').first().json.captchaFieldName }}",
              "value": "={{ $json.data.solution.text }}"
            }
          ]
        },
        "options": {
          "response": {
            "response": {
              "fullResponse": true,
              "neverError": true
            }
          }
        }
      },
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.3,
      "position": [
        1248,
        528
      ],
      "id": "fa-215",
      "name": "Submit Form with Solution [Webhook]"
    },
    {
      "parameters": {
        "conditions": {
          "options": {
            "caseSensitive": false,
            "leftValue": "",
            "typeValidation": "strict",
            "version": 2
          },
          "conditions": [
            {
              "id": "fa-if-002",
              "leftValue": "={{ $json.statusCode }}",
              "rightValue": 400,
              "operator": {
                "type": "number",
                "operation": "lt"
              }
            }
          ],
          "combinator": "and"
        },
        "options": {}
      },
      "type": "n8n-nodes-base.if",
      "typeVersion": 2.2,
      "position": [
        1552,
        528
      ],
      "id": "fa-216",
      "name": "Check Submission Result [Webhook]"
    },
    {
      "parameters": {
        "assignments": {
          "assignments": [
            {
              "id": "wms-001",
              "name": "action",
              "value": "form_submission",
              "type": "string"
            },
            {
              "id": "wms-002",
              "name": "status",
              "value": "success",
              "type": "string"
            },
            {
              "id": "wms-003",
              "name": "captchaText",
              "value": "={{ $('Solve Image Captcha [Webhook]').first().json.data.solution.text }}",
              "type": "string"
            },
            {
              "id": "wms-004",
              "name": "message",
              "value": "Form submitted successfully with solved captcha",
              "type": "string"
            },
            {
              "id": "wms-005",
              "name": "submittedAt",
              "value": "={{ new Date().toISOString() }}",
              "type": "string"
            }
          ]
        },
        "options": {}
      },
      "type": "n8n-nodes-base.set",
      "typeVersion": 3.4,
      "position": [
        1856,
        416
      ],
      "id": "fa-217",
      "name": "Mark Success [Webhook]"
    },
    {
      "parameters": {
        "assignments": {
          "assignments": [
            {
              "id": "wmf-001",
              "name": "action",
              "value": "form_submission",
              "type": "string"
            },
            {
              "id": "wmf-002",
              "name": "status",
              "value": "failed",
              "type": "string"
            },
            {
              "id": "wmf-003",
              "name": "statusCode",
              "value": "={{ $json.statusCode }}",
              "type": "number"
            },
            {
              "id": "wmf-004",
              "name": "message",
              "value": "Form submission was rejected by the target site",
              "type": "string"
            },
            {
              "id": "wmf-005",
              "name": "submittedAt",
              "value": "={{ new Date().toISOString() }}",
              "type": "string"
            }
          ]
        },
        "options": {}
      },
      "type": "n8n-nodes-base.set",
      "typeVersion": 3.4,
      "position": [
        1856,
        592
      ],
      "id": "fa-218",
      "name": "Mark Failed [Webhook]"
    },
    {
      "parameters": {
        "respondWith": "json",
        "responseBody": "={{ JSON.stringify($json) }}",
        "options": {}
      },
      "type": "n8n-nodes-base.respondToWebhook",
      "typeVersion": 1.5,
      "position": [
        2160,
        528
      ],
      "id": "fa-219",
      "name": "Respond to Webhook"
    }
  ],
  "connections": {
    "Every 6 Hours": {
      "main": [
        [
          {
            "node": "Set Target Config",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Set Target Config": {
      "main": [
        [
          {
            "node": "Fetch Captcha Image",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Fetch Captcha Image": {
      "main": [
        [
          {
            "node": "Convert to Base64",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Convert to Base64": {
      "main": [
        [
          {
            "node": "Solve Image Captcha",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Solve Image Captcha": {
      "main": [
        [
          {
            "node": "Submit Form with Solution",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Submit Form with Solution": {
      "main": [
        [
          {
            "node": "Check Submission Result",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Check Submission Result": {
      "main": [
        [
          {
            "node": "Mark Success",
            "type": "main",
            "index": 0
          }
        ],
        [
          {
            "node": "Mark Failed",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Webhook Trigger": {
      "main": [
        [
          {
            "node": "Set Target Config [Webhook]",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Set Target Config [Webhook]": {
      "main": [
        [
          {
            "node": "Fetch Captcha Image [Webhook]",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Fetch Captcha Image [Webhook]": {
      "main": [
        [
          {
            "node": "Convert to Base64 [Webhook]",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Convert to Base64 [Webhook]": {
      "main": [
        [
          {
            "node": "Solve Image Captcha [Webhook]",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Solve Image Captcha [Webhook]": {
      "main": [
        [
          {
            "node": "Submit Form with Solution [Webhook]",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Submit Form with Solution [Webhook]": {
      "main": [
        [
          {
            "node": "Check Submission Result [Webhook]",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Check Submission Result [Webhook]": {
      "main": [
        [
          {
            "node": "Mark Success [Webhook]",
            "type": "main",
            "index": 0
          }
        ],
        [
          {
            "node": "Mark Failed [Webhook]",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Mark Success [Webhook]": {
      "main": [
        [
          {
            "node": "Respond to Webhook",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Mark Failed [Webhook]": {
      "main": [
        [
          {
            "node": "Respond to Webhook",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  },
  "pinData": {},
  "meta": {
    "instanceId": "962ff0267b713be0344b866fa54daae28de8ed2144e2e6867da355dae193ea1f"
  }
}

पहचान बनाम टोकन: इमेज टू टेक्स्ट क्यों अलग है

यदि आपने reCAPTCHA, Turnstile, या अन्य चुनौती प्रकारों के लिए CapSolver n8n नोड का उपयोग किया है, तो आप टोकन संसाधन का उपयोग कर रहे हैं। इमेज टू टेक्स्ट पहचान संसाधन का उपयोग करता है, और अंतर मायने रखता है:

टोकन ऑपरेशन (reCAPTCHA, Turnstile, आदि)

  1. CapSolver अपने सर्वर पर एक कार्य बनाता है
  2. कार्य अतुल्यकालिक रूप से चलता है — नोड परिणाम के लिए पोल करता है
  3. हल करने में कई सेकंड से लेकर एक मिनट से अधिक का समय लग सकता है
  4. परिणाम एक टोकन है जिसे आप सत्यापन के लिए लक्ष्य साइट पर सबमिट करते हैं
  5. आपको एक websiteURL और websiteKey की आवश्यकता है

पहचान ऑपरेशन (इमेज टू टेक्स्ट)

  1. CapSolver इमेज को तुरंत संसाधित करता है एक ही अनुरोध में
  2. कोई पोलिंग नहीं — परिणाम उसी प्रतिक्रिया में वापस आता है
  3. हल करना लगभग-तत्काल है (आमतौर पर 1 सेकंड से कम)
  4. परिणाम मान्यता प्राप्त टेक्स्ट है जिसे आप कैप्चा इनपुट फ़ील्ड में टाइप करते हैं
  5. आपको एक base64 इमेज की आवश्यकता है, URL या साइट कुंजी की नहीं

यही कारण है कि CapSolver n8n नोड में दो अलग-अलग संसाधन हैं:

संसाधन ऑपरेशन
टोकन reCAPTCHA v2, reCAPTCHA v3, Cloudflare Turnstile, Cloudflare Challenge, GeeTest V3, GeeTest V4, DataDome, AWS WAF, MTCaptcha
पहचान इमेज टू टेक्स्ट

इमेज टू टेक्स्ट के लिए CapSolver नोड को कॉन्फ़िगर करते समय, सुनिश्चित करें कि आप पहले संसाधन = पहचान का चयन करें — यह उपलब्ध ऑपरेशनों और पैरामीटरों को बदल देता है।


आपको शायद क्या बदलने की आवश्यकता होगी

ये वर्कफ़्लो टेम्पलेट हैं। एक वास्तविक लक्ष्य पर, आपको अनुकूलित करने की उम्मीद करनी चाहिए:

1. कैप्चा इमेज स्रोत

फ़ॉर्म ऑटोमेशन टेम्पलेट एक ही URL (captchaImageURL) से इमेज प्राप्त करता है। व्यवहार में, कैप्चा इमेज हो सकती है:

  • एक गतिशील URL से प्रदान की गई जो प्रत्येक अनुरोध पर बदलती है
  • पृष्ठ HTML में एक base64 <img> टैग के रूप में एम्बेडेड
  • एक सत्र कुकी से बंधी हुई (इसलिए आपको मिलान वाली इमेज प्राप्त करने के लिए कुकी की आवश्यकता है)
  • कैश-बस्टिंग क्वेरी पैरामीटर के साथ प्रदान की गई

2. सत्र और कुकी हैंडलिंग

कई इमेज कैप्चा सिस्टम सत्र-बाउंड होते हैं — कैप्चा इमेज एक सर्वर-साइड सत्र से जुड़ी होती है। यदि आप एक अनुरोध में इमेज प्राप्त करते हैं और दूसरे में उत्तर सबमिट करते हैं, तो आपको इसकी आवश्यकता है:

  • इमेज अनुरोध से सत्र कुकी को कैप्चर करें
  • फ़ॉर्म सबमिट करते समय उसी कुकी को पास करें
  • संभवतः पृष्ठ से एक CSRF टोकन निकालें

3. कैप्चा फ़ील्ड नाम

विभिन्न साइटें कैप्चा उत्तर के लिए विभिन्न फ़ॉर्म फ़ील्ड नामों का उपयोग करती हैं:

सामान्य फ़ील्ड नाम
captcha
captcha_code
verification
captcha_text
answer
security_code

सटीक फ़ील्ड नाम खोजने के लिए फ़ॉर्म HTML का निरीक्षण करें।

4. पहचान मॉड्यूल

अधिकांश इमेज कैप्चा module: "common" के साथ काम करते हैं। लेकिन यदि कैप्चा में केवल संख्याएं हैं, तो module: "number" का प्रयास करें — यह न्यूमेरिक पहचान के लिए अनुकूलित है और बेहतर परिणाम दे सकता है।

5. अतिरिक्त फ़ॉर्म फ़ील्ड

टेम्पलेट में प्लेसहोल्डर username और password फ़ील्ड शामिल हैं। आपके लक्ष्य को इसकी आवश्यकता हो सकती है:

  • विभिन्न फ़ील्ड नाम
  • अतिरिक्त छिपे हुए फ़ील्ड
  • CSRF टोकन
  • रेफ़रर हेडर
  • विशिष्ट कुकीज़

समस्या निवारण

"ImageToTextTask एक्सेस नहीं मिला"

इस त्रुटि का मतलब है कि आपके CapSolver खाते या पैकेज में ImageToText एक्सेस शामिल नहीं है। यह सत्यापित करने के लिए अपने CapSolver डैशबोर्ड की जांच करें कि आपके पैकेज में यह सेवा शामिल है।

CapSolver गलत टेक्स्ट लौटाता है

इमेज कैप्चा पहचान 100% सटीक नहीं होती है। यदि आपको गलत परिणाम मिल रहे हैं:

  • एक अलग module का प्रयास करें — "common" बनाम "number" बनाम विशिष्ट मॉड्यूल आईडी
  • जांचें कि आपकी base64 एन्कोडिंग सही है — अमान्य एन्कोडिंग से गड़बड़ इनपुट उत्पन्न हो सकता है
  • सत्यापित करें कि इमेज दूषित या खाली नहीं है
  • कुछ अत्यधिक विकृत कैप्चा में सफलता दर कम होती है

"अमान्य base64 एन्कोडिंग" या खाली प्रतिक्रिया

सामान्य कारण:

  • data:image/...;base64, उपसर्ग को हटाया नहीं गया था
  • base64 स्ट्रिंग में नई लाइनें मौजूद हैं
  • इमेज URL ने इमेज के बजाय HTML लौटाया (कंटेंट-टाइप की जांच करें)
  • HTTP अनुरोध नोड ने इमेज के बजाय एक त्रुटि पृष्ठ लौटाया

सत्र बेमेल

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

फ़ॉर्म सबमिशन 403 या कैप्चा त्रुटि लौटाता है

इसका आमतौर पर मतलब है:

  • कैप्चा उत्तर बहुत देर से सबमिट किया गया था (कुछ कैप्चा समाप्त हो जाते हैं)
  • सत्र कुकी गायब थी
  • कैप्चा फ़ील्ड नाम गलत है
  • एक CSRF टोकन गायब है
  • अतिरिक्त छिपे हुए फ़ील्ड की आवश्यकता है

सर्वोत्तम अभ्यास

  1. मान्यता प्राप्त टेक्स्ट को तुरंत सबमिट करें — इमेज कैप्चा अक्सर 60-120 सेकंड के भीतर समाप्त हो जाते हैं।
  2. इमेज प्राप्त करने और फ़ॉर्म सबमिशन के बीच सत्र कुकीज़ को बनाए रखें।
  3. data: उपसर्ग को हटा दें — CapSolver को भेजने से पहले हमेशा अपनी base64 को साफ करें।
  4. सही मॉड्यूल का उपयोग करें — मिश्रित अल्फ़ान्यूमेरिक के लिए "common", केवल अंकों के लिए "number"।
  5. एन्कोडिंग त्रुटियों को जल्दी पकड़ने के लिए CapSolver को भेजने से पहले एक कोड नोड में base64 को मान्य करें।
  6. इमेज की जांच करें — यदि पहचान विफल हो जाती है, तो base64 स्ट्रिंग को लॉग करें और मैन्युअल रूप से डिकोड करें ताकि यह सत्यापित हो सके कि यह एक वैध कैप्चा इमेज है।
  7. पुनः प्रयास को संभालें — यदि मान्यता प्राप्त टेक्स्ट अस्वीकार कर दिया जाता है, तो आप एक पुनः प्रयास लूप जोड़ना चाह सकते हैं जो एक नई कैप्चा इमेज प्राप्त करता है और फिर से प्रयास करता है।
  8. किसी प्रॉक्सी की आवश्यकता नहीं है — टोकन ऑपरेशनों के विपरीत, इमेज टू टेक्स्ट को प्रॉक्सी की आवश्यकता नहीं होती है। इमेज डेटा सीधे CapSolver के सर्वर पर भेजा जाता है।

शुरू करने के लिए तैयार हैं? CapSolver के लिए साइन अप करें और अपने पहले रिचार्ज पर अतिरिक्त 8% बोनस के लिए बोनस कोड n8n का उपयोग करें!

CapSolver बोनस कोड बैनर

निष्कर्ष

आपने n8n और CapSolver का उपयोग करके एक इमेज टू टेक्स्ट सॉल्वर एपीआई और एक फ़ॉर्म ऑटोमेशन वर्कफ़्लो बनाना सीखा है — किसी पारंपरिक कोडिंग या OCR मॉडल प्रशिक्षण की आवश्यकता नहीं है।

इस गाइड में, हमने कवर किया:

  • इमेज टू टेक्स्ट टोकन ऑपरेशनों से कैसे अलग है — पहचान तत्काल है, कोई पोलिंग नहीं, कोई प्रॉक्सी की आवश्यकता नहीं है
  • Base64 एन्कोडिंग आवश्यकताएं — केवल स्वच्छ स्ट्रिंग, कोई data: उपसर्ग नहीं, कोई नई लाइन नहीं
  • एक एपीआई सॉल्वर एंडपॉइंट जो base64 इमेज को स्वीकार करता है और मान्यता प्राप्त टेक्स्ट लौटाता है
  • एक फ़ॉर्म ऑटोमेशन वर्कफ़्लो जो एक कैप्चा इमेज प्राप्त करता है, इसे परिवर्तित करता है, इसे हल करता है, और फ़ॉर्म सबमिट करता है
  • कोड नोड का उपयोग करके n8n में इमेज को base64 में कैसे परिवर्तित करें
  • सत्र हैंडलिंग, मॉड्यूल चयन और त्रुटि प्रबंधन के लिए सर्वोत्तम अभ्यास

मुख्य बात यह है: इमेज टू टेक्स्ट एकीकृत करने के लिए सबसे सरल CapSolver ऑपरेशन है — आप एक base64 इमेज भेजते हैं और तुरंत टेक्स्ट वापस प्राप्त करते हैं। चुनौती आमतौर पर आसपास के वर्कफ़्लो में होती है: इमेज को सही ढंग से प्राप्त करना, सत्र स्थिति को बनाए रखना, और उत्तर को सही फ़ॉर्म फ़ील्ड में सबमिट करना।

टिप: ये वर्कफ़्लो शेड्यूल + वेबहुक ट्रिगर का उपयोग करते हैं, लेकिन आप ट्रिगर नोड को किसी भी n8n ट्रिगर में बदल सकते हैं — मैनुअल, ऐप इवेंट, फ़ॉर्म सबमिशन, आदि। कैप्चा को हल करने के बाद, n8n के अंतर्निहित नोड का उपयोग करके परिणामों को Google शीट्स, डेटाबेस, क्लाउड स्टोरेज में सहेजें, या टेलीग्राम/स्लैक/ईमेल के माध्यम से अलर्ट भेजें।


अक्सर पूछे जाने वाले प्रश्न

ImageToTextTask क्या है?

ImageToTextTask CapSolver की OCR-आधारित कैप्चा पहचान सेवा है। आप एक कैप्चा की base64-एन्कोडेड इमेज भेजते हैं, और CapSolver मान्यता प्राप्त टेक्स्ट — अक्षर, संख्या, या दोनों — लौटाता है। यह CapSolver n8n नोड में पहचान संसाधन का उपयोग करता है, जो reCAPTCHA, Turnstile, और अन्य चुनौती प्रकारों के लिए उपयोग किए जाने वाले टोकन संसाधन से अलग है।

एक इमेज कैप्चा को हल करने में कितना खर्च आता है?

मूल्य निर्धारण उपयोग के आधार पर भिन्न होता है। वर्तमान ImageToText दरों के लिए CapSolver मूल्य निर्धारण पृष्ठ देखें। इमेज पहचान कार्य आमतौर पर सबसे किफायती CapSolver ऑपरेशनों में से हैं।

एक इमेज कैप्चा को हल करने में कितना समय लगता है?

इमेज टू टेक्स्ट एक पहचान ऑपरेशन है, जिसका अर्थ है कि परिणाम तुरंत वापस आते हैं — आमतौर पर 1 सेकंड से कम। टोकन ऑपरेशनों की तरह कोई कार्य निर्माण या पोलिंग देरी नहीं होती है।

क्या मुझे इमेज टू टेक्स्ट के लिए प्रॉक्सी की आवश्यकता है?

नहीं। टोकन ऑपरेशनों (reCAPTCHA, Turnstile, Cloudflare Challenge) के विपरीत, इमेज टू टेक्स्ट को प्रॉक्सी की आवश्यकता नहीं होती है। आप इमेज डेटा सीधे CapSolver को भेज रहे हैं — इसमें कोई ब्राउज़र इंटरैक्शन या साइट विज़िट शामिल नहीं है।

कौन से इमेज प्रारूप समर्थित हैं?

CapSolver base64-एन्कोडेड डेटा के रूप में सामान्य इमेज प्रारूपों (PNG, JPEG, GIF, BMP) को स्वीकार करता है। इमेज में एक दृश्यमान कैप्चा होना चाहिए — कोई खाली, दूषित, या अत्यधिक बड़ी इमेज नहीं।

module पैरामीटर क्या करता है?

module पैरामीटर CapSolver को बताता है कि किस पहचान इंजन का उपयोग करना है:

  • "common" — अक्षरों, संख्याओं और मिश्रित वर्णों के लिए सामान्य OCR। यह डिफ़ॉल्ट है और अधिकांश कैप्चा के लिए काम करता है।
  • "number" — केवल न्यूमेरिक कैप्चा के लिए अनुकूलित। 9 अतिरिक्त इमेज के साथ बैच सॉल्विंग का भी समर्थन करता है।
  • "module_001" से "module_032" — विशिष्ट कैप्चा शैलियों के लिए विशेष इंजन। प्रत्येक मॉड्यूल के विवरण के लिए CapSolver दस्तावेज़ देखें।

क्या CapSolver केस-संवेदनशील पहचान का समर्थन करता है?

नहीं। CapSolver की इमेज टू टेक्स्ट पहचान केस संवेदनशीलता का समर्थन नहीं करती है। यदि लक्ष्य साइट को केस-संवेदनशील कैप्चा उत्तर की आवश्यकता है, तो पहचान परिणाम मेल नहीं खा सकता है। यह एक ज्ञात सीमा है।

क्या मैं इस वर्कफ़्लो का उपयोग n8n क्लाउड के साथ कर सकता हूँ?

हाँ। यह वर्कफ़्लो स्व-होस्टेड n8n और n8n क्लाउड दोनों के साथ काम करता है। CapSolver नोड एक आधिकारिक एकीकरण के रूप में पहले से ही उपलब्ध है — बस अपने एपीआई क्रेडेंशियल जोड़ें।

मैं सत्र-बाउंड कैप्चा को कैसे संभालूँ?

कई साइटें कैप्चा इमेज को सर्वर सत्र से जोड़ती हैं। इसे संभालने के लिए:

  1. सत्र कुकी प्राप्त करने के लिए कैप्चा पृष्ठ पर एक प्रारंभिक अनुरोध करें
  2. कैप्चा इमेज प्राप्त करते समय उस कुकी का उपयोग करें
  3. मान्यता प्राप्त टेक्स्ट के साथ फ़ॉर्म सबमिट करते समय उसी कुकी को पास करें

n8n में, आप HTTP अनुरोध प्रतिक्रिया हेडर से कुकीज़ निकाल सकते हैं और उन्हें बाद के अनुरोधों में पास कर सकते हैं।

क्या होगा यदि CapSolver गलत टेक्स्ट लौटाता है?

इमेज कैप्चा पहचान 100% सटीक नहीं होती है — खासकर अत्यधिक विकृत या शोर वाली इमेज के लिए। यदि आपको गलत परिणाम मिल रहे हैं:

  • एक अलग मॉड्यूल ("common", "number", या एक विशिष्ट मॉड्यूल आईडी) का प्रयास करें
  • अपनी base64 एन्कोडिंग को सत्यापित करें
  • विफलता पर एक नई कैप्चा इमेज प्राप्त करने वाला एक पुनः प्रयास लूप जोड़ें
  • विशिष्ट कैप्चा शैलियों के लिए मॉड्यूल सिफारिशों के लिए CapSolver दस्तावेज़ देखें

CapSolver ने एक टोकन लौटाया लेकिन वेबसाइट ने इसे अभी भी अस्वीकार कर दिया — क्यों?

इमेज टू टेक्स्ट के लिए, CapSolver मान्यता प्राप्त टेक्स्ट लौटाता है, टोकन नहीं। यदि फ़ॉर्म सबमिशन अस्वीकार कर दिया जाता है:

  • solution.text मान की जांच करके सत्यापित करें कि कैप्चा उत्तर सही है
  • सत्र हैंडलिंग की जांच करें — कैप्चा समाप्त हो सकता है या सत्र कुकी गायब हो सकती है
  • फ़ॉर्म फ़ील्ड नाम को सत्यापित करें — कैप्चा उत्तर को एक अलग फ़ील्ड में जाने की आवश्यकता हो सकती है
  • अतिरिक्त आवश्यक फ़ील्ड देखें — CSRF टोकन, छिपे हुए इनपुट, या टाइमस्टैम्प
  • समय की जांच करें — कुछ कैप्चा जल्दी समाप्त हो जाते हैं, इसलिए पहचान के तुरंत बाद उत्तर सबमिट करें

और देखें

n8nMar 09, 2026

CapSolver और n8n का उपयोग करके reCAPTCHA v2/v3 कैसे हल करें

CapSolver और n8n का उपयोग करके eCAPTCHA v2/v3 सॉल्वर API बनाएं। बिना कोडिंग के टोकन को ऑटोमेट करने, वेबसाइट पर सबमिट करने और सुरक्षित डेटा निकालने का तरीका सीखें।

Rajinder Singh
Rajinder Singh
n8nMar 09, 2026

CapSolver और n8n का उपयोग करके Cloudflare Turnstile को कैसे हल करें

CapSolver और n8n का उपयोग करके Cloudflare Turnstile को हल करने के लिए एक API बनाएं। सीखें कि टोकन सॉल्विंग को कैसे ऑटोमेट करें, उसे वेबसाइट पर सबमिट करें, और बिना कोडिंग के संरक्षित डेटा निकालें।

विषय-सूची

Rajinder Singh
Rajinder Singh
n8nMar 16, 2026

CapSolver का उपयोग करके n8n में दृश्य पहेलियों को कैसे हल करें

n8n में CapSolver Vision Engine के साथ विज़ुअल CAPTCHA को हल करें। स्लाइडर, रोटेशन, ऑब्जेक्ट चयन और GIF OCR को तुरंत हैंडल करें।

Rajinder Singh
Rajinder Singh
n8nMar 12, 2026

n8n में टीएलएस फिंगरप्रिंटिंग को कैपसॉल्वर के साथ कैसे हल करें

n8n में TLS फिंगरप्रिंटिंग को हल करें कैपसॉल्वर के साथ। मांगें वास्तविक ब्राउज़र की तरह दिखाई दें और बॉट डिटेक्शन ब्लॉक से बचें।

Rajinder Singh
Rajinder Singh