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

© 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 में दृश्य पहेलियों को कैसे हल करें
Mar16, 2026

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

Rajinder Singh

Rajinder Singh

Deep Learning Researcher

विजुअल पहेलियाँ हर जगह हैं: स्लाइडर कैप्चा जिसमें एक टुकड़े को सही स्थिति में खींचने की आवश्यकता होती है, रोटेशन चुनौतियाँ जहाँ आप एक छवि को संरेखित करते हैं, ऑब्जेक्ट-चयन ग्रिड, और एनिमेटेड GIF टेक्स्ट पहचान। ये पारंपरिक टेक्स्ट-आधारित कैप्चा नहीं हैं और ये टोकन-आधारित चुनौतियाँ (जैसे reCAPTCHA या Turnstile) नहीं हैं जो एक स्ट्रिंग लौटाती हैं जिसे आप एक फ़ॉर्म के साथ सबमिट करते हैं। ये छवि-आधारित विजुअल चुनौतियाँ हैं जहाँ इनपुट एक तस्वीर है और आउटपुट एक माप है — पिक्सेल में दूरी, डिग्री में कोण, निर्देशांक का एक सेट, या मान्यता प्राप्त टेक्स्ट।

यही वह है जिसे CapSolver‍ का विजन इंजन हल करता है। यह विजुअल पहेली छवि का विश्लेषण करने और आपकी ऑटोमेशन को आगे बढ़ने के लिए आवश्यक सटीक उत्तर लौटाने के लिए AI का उपयोग करता है।

इस गाइड में, आप CapSolver समुदाय नोड के माध्यम से n8n में विजन इंजन का उपयोग करना सीखेंगे। वॉकथ्रू में कोर सॉल्वर एपीआई वर्कफ़्लो और एक व्यावहारिक स्लाइडर पहेली सॉल्वर शामिल है जो पहेली छवियों को प्राप्त करता है, उन्हें base64 में परिवर्तित करता है, स्लाइडर को हल करता है, और पिक्सेल में दूरी लौटाता है।

महत्वपूर्ण: विजन इंजन एक पहचान ऑपरेशन है, टोकन ऑपरेशन नहीं। इसका मतलब है कि परिणाम एक ही एपीआई कॉल में तुरंत वापस आता है — कोई पोलिंग नहीं, कोई getTaskResult लूप नहीं, और कोई टाइमआउट प्रतीक्षा नहीं। आप छवि भेजते हैं, आपको उत्तर मिलता है।


विजन इंजन अन्य CapSolver ऑपरेशनों से कैसे भिन्न है

n8n में अधिकांश CapSolver ऑपरेशन टोकन कार्य हैं। आप साइट पैरामीटर (URL, साइट कुंजी, प्रॉक्सी) सबमिट करते हैं, CapSolver पृष्ठभूमि में चुनौती को हल करता है, और आपका वर्कफ़्लो परिणाम के लिए पोल करता है। आउटपुट एक टोकन स्ट्रिंग है जिसे आप लक्ष्य साइट पर सबमिट करते हैं।

विजन इंजन अलग तरह से काम करता है:

पहलू टोकन ऑपरेशन (reCAPTCHA, Turnstile, आदि) विजन इंजन (पहचान)
संसाधन टोकन पहचान
इनपुट वेबसाइट URL, साइट कुंजी, प्रॉक्सी Base64 छवि(याँ), मॉड्यूल नाम
प्रसंस्करण अतुल्यकालिक — परिणाम के लिए पोल करें तत्काल — एकल एपीआई कॉल
आउटपुट टोकन स्ट्रिंग पिक्सेल, डिग्री, निर्देशांक, या टेक्स्ट
प्रॉक्सी अक्सर आवश्यक आवश्यक नहीं
उपयोग का मामला चुनौती गेट को बायपास करने के लिए टोकन सबमिट करें इंटरैक्शन को स्वचालित करने के लिए विजुअल पहेली की व्याख्या करें

विजन इंजन reCAPTCHA सॉल्विंग की तुलना में इमेज टू टेक्स्ट (OCR) के करीब है, लेकिन यह साधारण टेक्स्ट पहचान से आगे जाता है। जहाँ इमेज टू टेक्स्ट एक स्थिर छवि से वर्णों को पढ़ता है, वहीं विजन इंजन स्थानिक संबंधों को समझता है — यह गणना कर सकता है कि स्लाइडर के टुकड़े को कितनी दूर खींचना है, एक छवि को किस कोण पर घुमाना है, एक तस्वीर के कौन से क्षेत्र एक प्रश्न से मेल खाते हैं, या एक एनिमेटेड GIF में कौन सा टेक्स्ट छिपा है।


उपलब्ध मॉड्यूल

विजन इंजन कई AI मॉडल का समर्थन करता है, प्रत्येक को एक विशिष्ट प्रकार की विजुअल पहेली के लिए डिज़ाइन किया गया है:

मॉड्यूल उद्देश्य इनपुट लौटाता है
slider_1 स्लाइडर पहेली सॉल्विंग image (पहेली का टुकड़ा) + imageBackground (स्लॉट के साथ पृष्ठभूमि) पिक्सेल में दूरी
rotate_1 एकल छवि रोटेशन image + imageBackground डिग्री में कोण
rotate_2 मल्टी-इमेज रोटेशन (आंतरिक + बाहरी) image (आंतरिक छवि) डिग्री में कोण
shein ऑब्जेक्ट/क्षेत्र चयन image + question (क्या चुनना है) rects सरणी — बाउंडिंग बॉक्स [{x1, y1, x2, y2}]
ocr_gif एनिमेटेड GIF टेक्स्ट पहचान image (GIF का base64) मान्यता प्राप्त टेक्स्ट स्ट्रिंग

प्रत्येक मॉड्यूल का उपयोग कब करें

slider_1 — सबसे आम विजुअल कैप्चा प्रकार। उपयोगकर्ता एक लापता टुकड़े और एक अलग पहेली टुकड़े के साथ एक पृष्ठभूमि छवि देखता है। लक्ष्य यह निर्धारित करना है कि टुकड़े को कितने पिक्सेल दाईं ओर खींचना चाहिए। image (पहेली का टुकड़ा) और imageBackground (स्लॉट के साथ पूरी पृष्ठभूमि) दोनों आवश्यक हैं।

rotate_1 — एक एकल छवि जिसे सही अभिविन्यास में घुमाया जाना चाहिए। image और imageBackground दोनों आवश्यक हैं। इंजन डिग्री में कोण लौटाता है।

rotate_2 — दो संकेंद्रित छवियां (एक आंतरिक छवि और एक बाहरी रिंग)। आंतरिक छवि को बाहरी के साथ संरेखित करने के लिए घुमाया जाना चाहिए। केवल image की आवश्यकता है। इंजन कोण लौटाता है।

shein — उन चुनौतियों के लिए उपयोग किया जाता है जो "मिलान वाली वस्तुओं का चयन करें" या "सही क्षेत्र पर टैप करें" पूछती हैं। image और एक question पैरामीटर की आवश्यकता होती है जो यह बताता है कि क्या खोजना है। प्रत्येक मिलान वाले क्षेत्र के लिए बाउंडिंग-बॉक्स निर्देशांक लौटाता है।

ocr_gif — एनिमेटेड GIF जहाँ टेक्स्ट फ़्रेमों में चमकता है, जिससे यह मानक OCR के लिए अपठनीय हो जाता है। इंजन एनीमेशन का विश्लेषण करता है और टेक्स्ट निकालता है।


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

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

  1. एक n8n इंस्टेंस (स्व-होस्टेड या क्लाउड)
  2. एपीआई कुंजी और शेष राशि के साथ एक CapSolver खाता — यहां साइन अप करें
  3. n8n में स्थापित CapSolver समुदाय नोड (n8n-nodes-capsolver)
  4. n8n में एक कॉन्फ़िगर किया गया CapSolver क्रेडेंशियल (सेटिंग्स > क्रेडेंशियल > CapSolver API)

विजन इंजन कार्यों के लिए किसी प्रॉक्सी की आवश्यकता नहीं है।


विजन इंजन के लिए CapSolver नोड सेटिंग्स

n8n CapSolver नोड में, इन सेटिंग्स को कॉन्फ़िगर करें:

सेटिंग मान
संसाधन Recognition
ऑपरेशन Vision Engine
module मॉडल का नाम (जैसे, slider_1, rotate_1, ocr_gif)
image Base64-एन्कोडेड छवि स्ट्रिंग (कोई data:image/...;base64, उपसर्ग नहीं)
imageBackground Base64-एन्कोडेड पृष्ठभूमि छवि (वैकल्पिक — slider_1 और rotate_1 के लिए आवश्यक)
question टेक्स्ट प्रश्न (वैकल्पिक — केवल shein मॉड्यूल के लिए आवश्यक)
websiteURL स्रोत पृष्ठ URL (वैकल्पिक — सटीकता में सुधार कर सकता है)

जब आप विजन इंजन ऑपरेशन का चयन करते हैं तो type फ़ील्ड स्वचालित रूप से VisionEngine पर सेट हो जाता है।

Base64 छवि आवश्यकताएँ

image और imageBackground फ़ील्ड कच्ची base64 स्ट्रिंग होनी चाहिए — कोई डेटा URI उपसर्ग नहीं, कोई नई लाइन नहीं:

  • सही: /9j/4AAQSkZJRgABA... (कच्ची base64)
  • गलत: data:image/jpeg;base64,/9j/4AAQSkZJRgABA... (उपसर्ग है)

यदि आपकी स्रोत छवि एक URL है, तो आपको इसे पहले प्राप्त करना होगा और इसे base64 में परिवर्तित करना होगा। यदि इसमें पहले से ही data:image/...;base64, उपसर्ग है, तो इसे CapSolver नोड में पास करने से पहले हटा दें।


वर्कफ़्लो 1: विजन इंजन — सॉल्वर एपीआई

यह वर्कफ़्लो विजन इंजन को एक साधारण REST एपीआई एंडपॉइंट के रूप में उजागर करता है। मॉड्यूल नाम और base64 छवि(याँ) के साथ एक POST अनुरोध भेजें, और JSON के रूप में समाधान वापस प्राप्त करें।

नोड फ़्लो

Copy
सॉल्वर अनुरोध प्राप्त करें (वेबहुक POST)
  → इनपुट मान्य करें (कोड)
    → विजुअल पहेली हल करें (CapSolver — पहचान — विजन इंजन)
      → विजन इंजन त्रुटि? (IF)
        → true:  वेबहुक त्रुटि को जवाब दें
        → false: वेबहुक को जवाब दें (सफलता)

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

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

एक वेबहुक एंडपॉइंट JSON बॉडी के साथ POST अनुरोध स्वीकार करता है जिसमें शामिल है:

json Copy
{
  "module": "slider_1",
  "image": "/9j/4AAQSkZJRgABA...",
  "imageBackground": "/9j/4AAQSkZJRgABA...",
  "question": "",
  "websiteURL": ""
}

2. इनपुट मान्य करें

कोड नोड जांचता है कि image मौजूद है और module समर्थित मानों (slider_1, rotate_1, rotate_2, shein, ocr_gif) में से एक है। यदि सत्यापन विफल हो जाता है, तो यह एक error फ़ील्ड सेट करता है।

3. विजुअल पहेली हल करें

CapSolver नोड को इसके साथ कॉन्फ़िगर किया गया है:

  • संसाधन: Recognition
  • ऑपरेशन: Vision Engine
  • module: अनुरोध बॉडी से
  • image: अनुरोध बॉडी से
  • imageBackground: अनुरोध बॉडी से (यदि प्रदान नहीं किया गया है तो खाली स्ट्रिंग)
  • question: अनुरोध बॉडी से (यदि प्रदान नहीं किया गया है तो खाली स्ट्रिंग)

चूंकि यह एक पहचान कार्य है, परिणाम तुरंत वापस आता है।

4. त्रुटि हैंडलिंग

IF नोड त्रुटियों की जांच करता है। यदि CapSolver नोड ने एक त्रुटि लौटाई (गलत मॉड्यूल, अमान्य छवि, आदि), तो त्रुटि प्रतिक्रिया वेबहुक फायर करता है। अन्यथा, सफलता प्रतिक्रिया समाधान लौटाती है।

अपेक्षित अनुरोध और प्रतिक्रिया

स्लाइडर पहेली अनुरोध:

bash Copy
curl -X POST https://your-n8n-instance.com/webhook/vision-engine-solver \
  -H "Content-Type: application/json" \
  -d 
  '{
    "module": "slider_1",
    "image": "BASE64_PUZZLE_PIECE",
    "imageBackground": "BASE64_BACKGROUND"
  }
  '

सफलता प्रतिक्रिया:

json Copy
{
  "solution": {
    "distance": 142,
    "module": "slider_1"
  }
}

GIF OCR अनुरोध:

bash Copy
curl -X POST https://your-n8n-instance.com/webhook/vision-engine-solver \
  -H "Content-Type: application/json" \
  -d 
  '{
    "module": "ocr_gif",
    "image": "BASE64_GIF_DATA"
  }
  '

सफलता प्रतिक्रिया:

json Copy
{
  "solution": {
    "text": "x7Km9",
    "module": "ocr_gif"
  }
}

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

वर्कफ़्लो JSON का विस्तार करने के लिए क्लिक करें
json Copy
{
  "nodes": [
    {
      "parameters": {
        "content": "## विजन इंजन — सॉल्वर एपीआई\n\n### यह कैसे काम करता है\n\n1. एक वेबहुक के माध्यम से एक विजन प्रोसेसिंग अनुरोध प्राप्त करता है।\n2. अनुरोध से इनपुट को मान्य करता है।\n3. विजन इंजन सॉल्वर एपीआई का उपयोग करके अनुरोध को संसाधित करता है।\n4. जांचता है कि प्रोसेसिंग के दौरान कोई त्रुटि हुई है या नहीं।\n5. यदि प्रोसेसिंग सफल रही तो सफलता प्रतिक्रिया भेजता है।\n6. यदि प्रोसेसिंग विफल रही तो त्रुटि प्रतिक्रिया भेजता है।\n\n### सेटअप चरण\n\n- [ ] \'रिसीव विजन रिक्वेस्ट\' नोड के लिए अनुरोध प्राप्त करने के लिए एक वेबहुक URL सेट करें।\n- [ ] किसी भी आवश्यक इनपुट सत्यापन तर्क के साथ \'वैलिडेट इनपुट\' नोड को कॉन्फ़िगर करें।\n- [ ] उपयुक्त एपीआई कुंजी या एक्सेस क्रेडेंशियल के साथ \'सॉल्व विजन इंजन\' नोड को कॉन्फ़िगर करें।\n- [ ] प्रोसेसिंग परिणामों का आकलन करने के लिए \'त्रुटि?\' नोड में शर्तें परिभाषित करें।\n",
        "height": 624,
        "width": 480
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [
        -992,
        -368
      ],
      "id": "f0d88aeb-a5cd-4f57-8d08-05b388ec38c3",
      "name": "Sticky Note"
    },
    {
      "parameters": {
        "content": "## इनपुट प्राप्त करें और मान्य करें\n\nआने वाले अनुरोधों को संभालता है और प्रोसेसिंग से पहले उन्हें मान्य करता है।",
        "height": 304,
        "width": 496,
        "color": 7
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [
        -432,
        -208
      ],
      "id": "03c30168-9556-4ff3-ae53-c236685f9fef",
      "name": "Sticky Note1"
    },
    {
      "parameters": {
        "content": "## विजन इंजन प्रोसेसिंग\n\nविजन इंजन सॉल्वर के माध्यम से मान्य अनुरोध को संसाधित करता है।",
        "height": 352,
        "color": 7
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [
        288,
        -272
      ],
      "id": "8d1a1b1b-1a1a-1a1a-1a1a-1a1a1a1a1a1a",
      "name": "Sticky Note2"
    },
    {
      "parameters": {
        "content": "## प्रतिक्रिया संभालें\n\nपरिणाम का मूल्यांकन करता है और सफलता या त्रुटि के साथ प्रतिक्रिया देता है।",
        "height": 528,
        "width": 512,
        "color": 7
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [
        640,
        -368
      ],
      "id": "8aa644e9-135c-4381-b47b-f20acf83dd4f",
      "name": "Sticky Note3"
    },
    {
      "parameters": {
        "httpMethod": "POST",
        "path": "vision-engine-solver",
        "responseMode": "responseNode",
        "options": {}
      },
      "id": "ve-api-001",
      "name": "Receive Vision Request",
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 2.1,
      "position": [
        -384,
        -80
      ],
      "webhookId": "27e68e0b-9e2a-4c8d-ac43-92cda6e512e2",
      "onError": "continueRegularOutput"
    },
    {
      "parameters": {
        "jsCode": "const body = $input.first().json.body || {};\nconst validModules = [\'slider_1\', \'rotate_1\', \'rotate_2\', \'shein\', \'ocr_gif\'];\nconst module = (body.module || \'\').trim();\nconst image = (body.image || \'\').trim();\nconst imageBackground = (body.imageBackground || \'\').trim();\nconst question = (body.question || \'\').trim();\nconst websiteURL = (body.websiteURL || \'\').trim();\nif (!image) return [{ json: { error: \'Missing required field: image (base64 encoded)\' } }];\nif (!module) return [{ json: { error: \'Missing required field: module\' } }];\nif (!validModules.includes(module)) return [{ json: { error: `Invalid module: ${module}. Must be one of: ${validModules.join(\\'\\', \\'`)}` } }];\nif ((module === \'slider_1\' || module === \'rotate_2\') && !imageBackground) return [{ json: { error: `Module ${module} requires imageBackground` } }];\nif (module === \'shein\' && !question) return [{ json: { error: \'Module shein requires a question parameter\' } }];\nreturn [{ json: { module, image, imageBackground, question, websiteURL, validated: true } }];"
      },
      "id": "ve-api-002",
      "name": "Validate Input",
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [
        -80,
        -80
      ]
    },
    {
      "parameters": {
        "resource": "Recognition",
        "operation": "Vision Engine",
        "websiteURL": "={{ $json.websiteURL }}",
        "module": "={{ $json.module }}",
        "image": "={{ $json.image }}",
        "imageBackground": "={{ $json.imageBackground }}",
        "question": "={{ $json.question }}",
        "optional": {}
      },
      "id": "ve-api-003",
      "name": "Solve Vision Engine",
      "type": "n8n-nodes-capsolver.capSolver",
      "typeVersion": 1,
      "position": [
        336,
        -80
      ],
      "credentials": {
        "capSolverApi": {
          "id": "BeBFMAsySMsMGeE9",
          "name": "CapSolver account"
        }
      },
      "onError": "continueRegularOutput"
    },
    {
      "parameters": {
        "conditions": {
          "options": {
            "version": 2,
            "caseSensitive": true,
            "leftValue": "",
            "typeValidation": "strict"
          },
          "combinator": "and",
          "conditions": [
            {
              "id": "condition-1",
              "operator": {
                "type": "string",
                "operation": "isNotEmpty",
                "singleValue": true
              },
              "leftValue": "={{ $json.error }}",
              "rightValue": ""
            }
          ]
        },
        "options": {}
      },
      "id": "ve-api-004",
      "name": "Error?",
      "type": "n8n-nodes-base.if",
      "typeVersion": 2.2,
      "position": [
        688,
        -80
      ]
    },
    {
      "parameters": {
        "respondWith": "json",
        "responseBody": "={{ JSON.stringify($json.data) }}",
        "options": {}
      },
      "id": "ve-api-005",
      "name": "Respond Success",
      "type": "n8n-nodes-base.respondToWebhook",
      "typeVersion": 1.5,
      "position": [
        1008,
        -240
      ]
    },
    {
      "parameters": {
        "respondWith": "json",
        "responseBody": "={{ JSON.stringify({ error: $json.error }) }}",
        "options": {
          "responseCode": 400
        }
      },
      "id": "ve-api-006",
      "name": "Respond Error",
      "type": "n8n-nodes-base.respondToWebhook",
      "typeVersion": 1.5,
      "position": [
        1008,
        -16
      ]
    }
  ],
  "connections": {
    "Receive Vision Request": {
      "main": [
        [
          {
            "node": "Validate Input",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Validate Input": {
      "main": [
        [
          {
            "node": "Solve Vision Engine",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Solve Vision Engine": {
      "main": [
        [
          {
            "node": "Error?",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Error?": {
      "main": [
        [
          {
            "node": "Respond Error",
            "type": "main",
            "index": 0
          }
        ],
        [
          {
            "node": "Respond Success",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  },
  "pinData": {},
  "meta": {
    "instanceId": "962ff0267b713be0344b866fa54daae28de8ed2144e2e6867da355dae193ea1f"
  }
}

वर्कफ़्लो 2: स्लाइडर पहेली सॉल्वर — प्राप्त करें और हल करें

यह वर्कफ़्लो एक व्यावहारिक एंड-टू-एंड स्लाइडर पहेली सॉल्वर को प्रदर्शित करता है। यह URL से पहेली के टुकड़े और पृष्ठभूमि छवियों को प्राप्त करता है, उन्हें base64 में परिवर्तित करता है, उन्हें slider_1 मॉड्यूल के साथ विजन इंजन पर भेजता है, और स्लाइडर को पूरा करने के लिए आवश्यक पिक्सेल दूरी लौटाता है।

यह वह पैटर्न है जिसका आप स्लाइडर कैप्चा सॉल्विंग को एक बड़े ऑटोमेशन में एकीकृत करते समय उपयोग करेंगे — लौटाई गई दूरी आपके ब्राउज़र ऑटोमेशन (Puppeteer, Playwright, Selenium) को ठीक-ठीक बताती है कि स्लाइडर हैंडल को कितनी दूर खींचना है।

नोड फ़्लो

Copy
शेड्यूल ट्रिगर (हर 1 घंटे) ─┐
                                 ├→ पहेली कॉन्फ़िग सेट करें → पहेली छवि प्राप्त करें → पृष्ठभूमि छवि प्राप्त करें
वेबहुक ट्रिगर (POST) ──────────┘    → छवियों को Base64 में परिवर्तित करें → स्लाइडर पहेली हल करें
      → परिणाम जांचें और जवाब दें

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

1. दोहरे ट्रिगर

  • शेड्यूल ट्रिगर: स्वचालित परीक्षण या आवर्ती पहेली-सुलझाने के लिए हर घंटे चलता है
  • वेबहुक ट्रिगर: दूसरे वर्कफ़्लो या बाहरी सेवा से ऑन-डिमांड सक्रियण

2. पहेली कॉन्फ़िग सेट करें

पहेली के टुकड़े की छवि और पृष्ठभूमि छवि के लिए URL को परिभाषित करता है, साथ ही बेहतर सटीकता के लिए कोई भी वैकल्पिक websiteURL। एक वास्तविक एकीकरण में, ये URL लक्ष्य साइट की कैप्चा चुनौती प्रतिक्रिया से आएंगे।

3. पहेली छवि प्राप्त करें + पृष्ठभूमि छवि प्राप्त करें

दो HTTP अनुरोध नोड पहेली के टुकड़े और पृष्ठभूमि छवियों को बाइनरी डेटा के रूप में डाउनलोड करते हैं।

4. छवियों को Base64 में परिवर्तित करें

एक कोड नोड दोनों बाइनरी छवियों को कच्ची base64 स्ट्रिंग में परिवर्तित करता है, किसी भी data:image/...;base64, उपसर्ग को हटाता है।

5. स्लाइडर पहेली हल करें

CapSolver नोड के साथ:

  • संसाधन: Recognition
  • ऑपरेशन: Vision Engine
  • module: slider_1
  • image: base64 पहेली का टुकड़ा
  • imageBackground: base64 पृष्ठभूमि

पिक्सेल में दूरी तुरंत लौटाता है।

6. परिणाम जांचें और जवाब दें

IF नोड त्रुटियों की जांच करता है। सफलता पर, समाधान को स्वरूपित किया जाता है और लौटाया जाता है। त्रुटि पर, त्रुटि संदेश लौटाया जाता है।

अपेक्षित प्रतिक्रिया

सफलता:

json Copy
{
  "success": true,
  "module": "slider_1",
  "distance": 142,
  "unit": "pixels",
  "rawSolution": {
    "distance": 142
  },
  "solvedAt": "2026-03-16T10:00:00.000Z"
}

त्रुटि:

json Copy
{
  "success": false,
  "error": "ERROR_INVALID_IMAGE",
  "solvedAt": "2026-03-16T10:00:00.000Z"
}

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

वर्कफ़्लो JSON का विस्तार करने के लिए क्लिक करें
json Copy
{
  "nodes": [
    {
      "parameters": {
        "content": "## स्लाइडर पहेली सॉल्वर — प्राप्त करें और हल करें — विजन इंजन\n\n### यह कैसे काम करता है\n\n1. हर घंटे या वेबहुक के माध्यम से शुरू होता है।\n2. आवश्यक URL के साथ पहेली कॉन्फ़िगरेशन सेट करता है।\n3. पहेली और पृष्ठभूमि छवियों को प्राप्त करता है।\n4. प्रोसेसिंग के लिए छवियों को Base64 प्रारूप में परिवर्तित करता है।\n5. स्लाइडर पहेली को हल करता है और त्रुटियों की जांच करता है।\n6. वेबहुक के माध्यम से परिणाम या त्रुटियों को स्वरूपित करता है और वापस भेजता है।\n\n### सेटअप चरण\n\n- [ ] शेड्यूल ट्रिगर या वेबहुक को कॉन्फ़िगर और सक्षम करें।\n- [ ] पहेली और पृष्ठभूमि छवियों के लिए उचित URL सेट करें।\n- [ ] उपयुक्त एपीआई कुंजी या सेटिंग्स के साथ सॉल्व स्लाइडर नोड को कॉन्फ़िगर करें।\n\n### अनुकूलन\n\nविभिन्न पहेलियों के लिए पहेली छवि URL और पृष्ठभूमि छवि URL को समायोजित करें।",
        "height": 672,
        "width": 480
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [
        -1184,
        -368
      ],
      "id": "acf16f0f-c0e6-4ad8-91ea-5a3dff2be080",
      "name": "Sticky Note"
    },
    {
      "parameters": {
        "content": "## वर्कफ़्लो शुरू करें\n\nवर्कफ़्लो को या तो समय-समय पर या बाहरी अनुरोध के माध्यम से शुरू करता है।",
        "height": 672,
        "color": 7
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [
        -624,
        -368
      ],
      "id": "3de3100b-ee70-409f-8ce5-6b7052e7e177",
      "name": "Sticky Note1"
    },
    {
      "parameters": {
        "content": "## पहेली सेटिंग्स कॉन्फ़िगर करें\n\nपहेली समाधान के लिए आवश्यक छवियों के लिए URL सेट करता है।",
        "height": 352,
        "color": 7
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [
        -80,
        -192
      ],
      "id": "7d44115c-6e2b-4f92-a077-a6c275561580",
      "name": "Sticky Note2"
    },
    {
      "parameters": {
        "content": "## छवियां प्राप्त करें\n\nकॉन्फ़िगर की गई सेटिंग्स के आधार पर पहेली और पृष्ठभूमि छवियों को डाउनलोड करता है।",
        "height": 304,
        "width": 528,
        "color": 7
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [
        192,
        -128
      ],
      "id": "a06f0443-9cd5-483e-a8d7-12e1294e52e4",
      "name": "Sticky Note3"
    },
    {
      "parameters": {
        "content": "## छवियों को संसाधित करें\n\nआगे की प्रोसेसिंग के लिए प्राप्त छवियों को Base64 में परिवर्तित करता है।",
        "height": 320,
        "color": 7
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [
        768,
        -112
      ],
      "id": "cfb5588a-4447-4274-a972-3d4eaaa89d52",
      "name": "Sticky Note4"
    },
    {
      "parameters": {
        "content": "## पहेली हल करें\n\nपहेली सॉल्विंग और त्रुटि जांच को विशेष घटकों को सौंपता है।",
        "height": 304,
        "width": 528,
        "color": 7
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [
        1136,
        -80
      ],
      "id": "7ebc0c4e-5b29-4a5f-b754-89bcca4672f4",
      "name": "Sticky Note5"
    },
    {
      "parameters": {
        "content": "## परिणाम स्वरूपित करें और वापस करें\n\nसमाधान या त्रुटि को स्वरूपित करता है और वेबहुक के माध्यम से प्रतिक्रिया वापस भेजता है।",
        "height": 544,
        "width": 512,
        "color": 7
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [
        1792,
        -288
      ],
      "id": "86a92570-1529-4ca9-963c-b1d0792222ee",
      "name": "Sticky Note6"
    },
    {
      "parameters": {
        "rule": {
          "interval": [
            {
              "field": "hours"
            }
          ]
        }
      },
      "id": "ve-slider-201",
      "name": "Every 1 Hour",
      "type": "n8n-nodes-base.scheduleTrigger",
      "typeVersion": 1.2,
      "position": [
        -576,
        -208
      ]
    },
    {
      "parameters": {
        "httpMethod": "POST",
        "path": "slider-puzzle-solver",
        "responseMode": "responseNode",
        "options": {}
      },
      "id": "ve-slider-202",
      "name": "Webhook Trigger",
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 2,
      "position": [
        -560,
        144
      ],
      "webhookId": "67cb24f0-257f-4a60-8820-d57595d5bb3a"
    },
    {
      "parameters": {
        "assignments": {
          "assignments": [
            {
              "id": "puzzleImageURL",
              "name": "puzzleImageURL",
              "value": "={{ $json.body?.puzzleImageURL || $json.puzzleImageURL || \'\' }}",
              "type": "string"
            },
            {
              "id": "backgroundImageURL",
              "name": "backgroundImageURL",
              "value": "={{ $json.body?.backgroundImageURL || $json.backgroundImageURL || \'\' }}",
              "type": "string"
            },
            {
              "id": "websiteURL",
              "name": "websiteURL",
              "value": "={{ $json.body?.websiteURL || $json.websiteURL || \'\' }}",
              "type": "string"
            }
          ]
        },
        "options": {}
      },
      "id": "ve-slider-203",
      "name": "Set Puzzle Config",
      "type": "n8n-nodes-base.set",
      "typeVersion": 3.4,
      "position": [
        -32,
        0
      ]
    },
    {
      "parameters": {
        "url": "={{ $json.puzzleImageURL }}",
        "options": {
          "response": {
            "response": {
              "responseFormat": "file"
            }
          }
        }
      },
      "id": "ve-slider-204",
      "name": "Fetch Puzzle Image",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [
        240,
        0
      ]
    },
    {
      "parameters": {
        "url": "={{ $(\'Set Puzzle Config\').first().json.backgroundImageURL }}",
        "options": {
          "response": {
            "response": {
              "responseFormat": "file"
            }
          }
        }
      },
      "id": "ve-slider-205",
      "name": "Fetch Background Image",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [
        576,
        0
      ]
    },
    {
      "parameters": {
        "jsCode": "const puzzleBinary = $input.first().binary;\nconst config = $(\'Set Puzzle Config\').first().json;\nif (!puzzleBinary || !puzzleBinary.data) {\n  return [{ json: { error: \'Failed to fetch puzzle image\' } }];\n}\nconst puzzleBuffer = await this.helpers.getBinaryDataBuffer(0, \'data\');\nconst puzzleBase64 = puzzleBuffer.toString(\'base64\');\nlet backgroundBase64 = \'\';\ntry {\n  const bgBinary = $input.first().binary;\n  if (bgBinary && bgBinary.data) {\n    const bgBuffer = await this.helpers.getBinaryDataBuffer(0, \'data\');\n    backgroundBase64 = bgBuffer.toString(\'base64\');\n  }\n} catch (e) {}\nreturn [{ json: { image: puzzleBase64, imageBackground: backgroundBase64, websiteURL: config.websiteURL || \'\', module: \'slider_1\' } }];"
      },
      "id": "ve-slider-206",
      "name": "Convert to Base64",
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [
        816,
        48
      ]
    },
    {
      "parameters": {
        "resource": "Recognition",
        "operation": "Vision Engine",
        "websiteURL": "={{ $json.websiteURL }}",
        "module": "={{ $json.module }}",
        "image": "={{ $json.image }}",
        "imageBackground": "={{ $json.imageBackground }}",
        "optional": {}
      },
      "id": "ve-slider-207",
      "name": "Solve Slider",
      "type": "n8n-nodes-capsolver.capSolver",
      "typeVersion": 1,
      "position": [
        1184,
        48
      ],
      "credentials": {
        "capSolverApi": {
          "id": "BeBFMAsySMsMGeE9",
          "name": "CapSolver account"
        }
      },
      "onError": "continueRegularOutput"
    },
    {
      "parameters": {
        "conditions": {
          "options": {
            "version": 2,
            "leftValue": "",
            "caseSensitive": true,
            "typeValidation": "strict"
          },
          "combinator": "and",
          "conditions": [
            {
              "id": "slider-err-check",
              "operator": {
                "type": "string",
                "operation": "isNotEmpty",
                "singleValue": true
              },
              "leftValue": "={{ $json.error }}",
              "rightValue": ""
            }
          ]
        },
        "options": {}
      },
      "id": "ve-slider-208",
      "name": "Slider Error?",
      "type": "n8n-nodes-base.if",
      "typeVersion": 2.2,
      "position": [
        1520,
        48
      ]
    },
    {
      "parameters": {
        "jsCode": "const solution = $input.first().json.data?.solution || $input.first().json.data || {};\nconst distance = solution.distance || solution.slide_distance || null;\nreturn [{ json: { success: true, module: \'slider_1\', distance: distance, unit: \'pixels\', rawSolution: solution, solvedAt: new Date().toISOString() } }];"
      },
      "id": "ve-slider-209",
      "name": "Format Solution",
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [
        1840,
        -160
      ]
    },
    {
      "parameters": {
        "jsCode": "return [{ json: { success: false, error: $input.first().json.error || \'Unknown Vision Engine error\', solvedAt: new Date().toISOString() } }];"
      },
      "id": "ve-slider-210",
      "name": "Format Error",
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [
        1840,
        80
      ]
    },
    {
      "parameters": {
        "respondWith": "json",
        "responseBody": "={{ $json }}",
        "options": {}
      },
      "id": "ve-slider-211",
      "name": "Return Result",
      "type": "n8n-nodes-base.respondToWebhook",
      "typeVersion": 1.1,
      "position": [
        2160,
        -160
      ]
    },
    {
      "parameters": {
        "respondWith": "json",
        "responseBody": "={{ $json }}",
        "options": {
          "responseCode": 400
        }
      },
      "id": "ve-slider-212",
      "name": "Return Error",
      "type": "n8n-nodes-base.respondToWebhook",
      "typeVersion": 1.1,
      "position": [
        2160,
        80
      ]
    }
  ],
  "connections": {
    "Every 1 Hour": {
      "main": [
        [
          {
            "node": "Set Puzzle Config",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Webhook Trigger": {
      "main": [
        [
          {
            "node": "Set Puzzle Config",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Set Puzzle Config": {
      "main": [
        [
          {
            "node": "Fetch Puzzle Image",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Fetch Puzzle Image": {
      "main": [
        [
          {
            "node": "Fetch Background Image",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Fetch Background Image": {
      "main": [
        [
          {
            "node": "Convert to Base64",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Convert to Base64": {
      "main": [
        [
          {
            "node": "Solve Slider",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Solve Slider": {
      "main": [
        [
          {
            "node": "Slider Error?",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Slider Error?": {
      "main": [
        [
          {
            "node": "Format Error",
            "type": "main",
            "index": 0
          }
        ],
        [
          {
            "node": "Format Solution",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Format Solution": {
      "main": [
        [
          {
            "node": "Return Result",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Format Error": {
      "main": [
        [
          {
            "node": "Return Error",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  ],
  "pinData": {},
  "meta": {
    "instanceId": "962ff0267b713be0344b866fa54daae28de8ed2144e2e6867da355dae193ea1f"
  }
}

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

सॉल्वर एपीआई का परीक्षण करना

एक बार जब आप CapSolver क्रेडेंशियल कॉन्फ़िगर कर लेते हैं और वर्कफ़्लो को सक्रिय कर लेते हैं, तो सॉल्वर एपीआई का परीक्षण करें:

स्लाइडर पहेली:

bash Copy
curl -X POST https://your-n8n-instance.com/webhook/vision-engine-solver \
  -H "Content-Type: application/json" \
  -d 
  '{
    "module": "slider_1",
    "image": "BASE64_PUZZLE_PIECE_HERE",
    "imageBackground": "BASE64_BACKGROUND_HERE"
  }
  '

रोटेशन पहेली:

bash Copy
curl -X POST https://your-n8n-instance.com/webhook/vision-engine-solver \
  -H "Content-Type: application/json" \
  -d 
  '{
    "module": "rotate_1",
    "image": "BASE64_IMAGE_TO_ROTATE"
  }
  '

ऑब्जेक्ट चयन (shein):

bash Copy
curl -X POST https://your-n8n-instance.com/webhook/vision-engine-solver \
  -H "Content-Type: application/json" \
  -d 
  '{
    "module": "shein",
    "image": "BASE64_IMAGE",
    "question": "Select all shoes"
  }
  '

GIF OCR:

bash Copy
curl -X POST https://your-n8n-instance.com/webhook/vision-engine-solver \
  -H "Content-Type: application/json" \
  -d 
  '{
    "module": "ocr_gif",
    "image": "BASE64_GIF_DATA"
  }
  '

स्लाइडर पहेली सॉल्वर का परीक्षण करना

bash Copy
curl -X POST https://your-n8n-instance.com/webhook/slider-puzzle-solver \
  -H "Content-Type: application/json" \
  -d 
  '{
    "puzzleImageURL": "https://example.com/captcha/puzzle-piece.png",
    "backgroundImageURL": "https://example.com/captcha/background.png",
    "websiteURL": "https://example.com"
  }
  '

एक संख्यात्मक distance मान के साथ एक प्रतिक्रिया पुष्टि करती है कि पूरी पाइपलाइन ने काम किया — छवियां प्राप्त की गईं, base64 में परिवर्तित की गईं, विजन इंजन ने स्लाइडर को हल किया, और पिक्सेल दूरी वापस कर दी गई।


प्रतिक्रिया को समझना

विजन इंजन मॉड्यूल के आधार पर विभिन्न समाधान आकार लौटाता है:

slider_1

json Copy
{
  "solution": {
    "distance": 142
  }
}

distance पिक्सेल में है — यह वह दूरी है जिसे स्लाइडर हैंडल को पहेली को पूरा करने के लिए दाईं ओर खींचना होगा।

rotate_1 / rotate_2

json Copy
{
  "solution": {
    "angle": 73
  }
}

angle डिग्री में है — यह वह कोण है जिस पर छवि को सही अभिविन्यास तक पहुंचने के लिए घुमाया जाना चाहिए (घड़ी की दिशा में)।

shein

json Copy
{
  "solution": {
    "rects": [
      { "x1": 45, "y1": 120, "x2": 180, "y2": 250 },
      { "x1": 300, "y1": 90, "x2": 420, "y2": 210 }
    ]
  }
}

सरणी में प्रत्येक आयत छवि में एक मिलान वाले क्षेत्र के लिए एक बाउंडिंग बॉक्स (ऊपर-बाएं और नीचे-दाएं निर्देशांक) है।

ocr_gif

json Copy
{
  "solution": {
    "text": "x7Km9"
  }
}

text एनिमेटेड GIF से मान्यता प्राप्त स्ट्रिंग है।


अन्य मॉड्यूल प्रकारों के लिए अनुकूलन

सॉल्वर एपीआई वर्कफ़्लो अनुरोध बॉडी के माध्यम से सभी पांच मॉड्यूल का समर्थन करता है। एक समर्पित वर्कफ़्लो बनाने के लिए, आपको कॉन्फ़िग नोड, फ़ेच नोड, CapSolver नोड और फ़ॉर्मेट सॉल्यूशन नोड को विशिष्ट मॉड्यूल के लिए अनुकूलित करना होगा। उदाहरण के लिए, rotate_1 के लिए:

  1. कॉन्फ़िग नोड: puzzleImageURL / backgroundImageURL को केवल रोटेशन छवि URL से बदलें
  2. फ़ेच नोड: केवल एक HTTP अनुरोध की आवश्यकता है (rotate_1 के लिए कोई पृष्ठभूमि छवि नहीं)
  3. CapSolver नोड: module को rotate_1 में बदलें
  4. समाधान स्वरूपित करें: distance के बजाय angle निकालें

shein के लिए, आपको कॉन्फ़िग में question पैरामीटर भी जोड़ना होगा और इसे CapSolver नोड में पास करना होगा।


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

"ERROR_INVALID_IMAGE"

base64 स्ट्रिंग गलत या खाली है। जांचें कि:

  • छवि सफलतापूर्वक प्राप्त की गई थी (HTTP 200)
  • बाइनरी-टू-base64 रूपांतरण ने एक गैर-खाली स्ट्रिंग का उत्पादन किया
  • data:image/...;base64, उपसर्ग को हटा दिया गया था
  • base64 स्ट्रिंग में कोई नई लाइन या स्पेस नहीं है

"ERROR_INVALID_MODULE"

module मान किसी भी समर्थित मॉडल से मेल नहीं खाता है। ठीक एक का उपयोग करें: slider_1, rotate_1, rotate_2, shein, ocr_gif।

दूरी 0 या नल लौटाती है

छवियां एक वैध स्लाइडर पहेली जोड़ी नहीं हो सकती हैं। जांचें कि:

  • image पहेली का टुकड़ा है (छोटा खींचने योग्य टुकड़ा)
  • imageBackground लापता स्लॉट के साथ पूरी पृष्ठभूमि है
  • दोनों छवियां एक ही चुनौती इंस्टेंस से हैं
  • छवियां दूषित या बहुत छोटी नहीं हैं

CapSolver नोड कोई "विजन इंजन" विकल्प नहीं दिखाता है

सुनिश्चित करें कि आपके पास n8n-nodes-capsolver संस्करण 1.x या बाद का स्थापित है। विजन इंजन ऑपरेशन हाल के संस्करणों में जोड़ा गया था। यदि आवश्यक हो तो समुदाय नोड को अपडेट करें:

  1. सेटिंग्स > समुदाय नोड्स पर जाएं
  2. n8n-nodes-capsolver खोजें
  3. नवीनतम संस्करण में अपडेट करें
  4. n8n को पुनरारंभ करें

वेबहुक 404 लौटाता है

वेबहुक के लाइव होने के लिए वर्कफ़्लो सक्रिय होना चाहिए। वर्कफ़्लो आयात करें, क्रेडेंशियल कॉन्फ़िगर करें, फिर n8n में वर्कफ़्लो को सक्रिय पर टॉगल करें।


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

  1. कच्ची base64 स्ट्रिंग का उपयोग करें — CapSolver नोड में छवियों को पास करने से पहले हमेशा data:image/...;base64, उपसर्ग को हटा दें।

  2. छवियों को मॉड्यूल से मिलाएं — slider_1 को image और imageBackground दोनों की आवश्यकता होती है। rotate_1 को केवल image की आवश्यकता होती है। shein को image और question की आवश्यकता होती है। गलत संयोजन का उपयोग करने से विफल हो जाएगा या गलत परिणाम वापस आ जाएंगे।

  3. छवियों को ताज़ा प्राप्त करें — विजुअल पहेली छवियां आमतौर पर एकल-उपयोग होती हैं और जल्दी समाप्त हो जाती हैं। उन्हें हल करने के समय के जितना संभव हो उतना करीब प्राप्त करें।

  4. विजन इंजन तत्काल है — टोकन ऑपरेशनों के विपरीत जो परिणामों के लिए पोल करते हैं, पहचान ऑपरेशन तुरंत वापस आते हैं। आपके वर्कफ़्लो को पुनः प्रयास तर्क या पोलिंग देरी की आवश्यकता नहीं है।

  5. किसी प्रॉक्सी की आवश्यकता नहीं है — विजन इंजन छवियों का सर्वर-साइड विश्लेषण करता है। लक्ष्य साइट के साथ कोई ब्राउज़र इंटरैक्शन नहीं है, इसलिए किसी प्रॉक्सी की आवश्यकता नहीं है।

  6. हल करने से पहले मान्य करें — जांचें कि छवि डेटा मौजूद है और CapSolver नोड को कॉल करने से पहले मॉड्यूल नाम वैध है। यह उन अनुरोधों पर एपीआई क्रेडिट बर्बाद करने से बचाता है जो विफल हो जाएंगे।

  7. उपलब्ध होने पर websiteURL का उपयोग करें — हालांकि वैकल्पिक, स्रोत पृष्ठ URL प्रदान करने से कुछ पहेली प्रकारों के लिए सटीकता में सुधार हो सकता है।

  8. मॉड्यूल-विशिष्ट प्रतिक्रियाओं को संभालें — विभिन्न मॉड्यूल विभिन्न फ़ील्ड (distance, angle, rects, text) लौटाते हैं। आपके डाउनस्ट्रीम तर्क को यह जांचना चाहिए कि किस मॉड्यूल का उपयोग किया गया था और सही फ़ील्ड को निकालना चाहिए।

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

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

निष्कर्ष

विजन इंजन CapSolver के टोकन ऑपरेशनों की तुलना में एक अलग अंतर को भरता है। जहाँ reCAPTCHA, Turnstile, और Cloudflare चैलेंज सॉल्विंग टोकन लौटाते हैं जिन्हें आप एक गेट को बायपास करने के लिए सबमिट करते हैं, वहीं विजन इंजन माप लौटाता है जिसका उपयोग आपका ऑटोमेशन विजुअल पहेलियों के साथ इंटरैक्ट करने के लिए करता है — स्लाइडर खींचना, छवियों को घुमाना, वस्तुओं का चयन करना, या एनिमेटेड टेक्स्ट पढ़ना।

याद रखने योग्य मुख्य अंतर:

  • पहचान संसाधन, टोकन नहीं — तत्काल परिणाम, कोई पोलिंग नहीं
  • Base64 छवियां अंदर, माप बाहर — पिक्सेल, डिग्री, निर्देशांक, या टेक्स्ट
  • किसी प्रॉक्सी की आवश्यकता नहीं है — AI छवियों का सर्वर-साइड विश्लेषण करता है
  • पांच मॉड्यूल — प्रत्येक को एक विशिष्ट विजुअल पहेली प्रकार के लिए डिज़ाइन किया गया है

इस लेख में दो वर्कफ़्लो दो सबसे आम एकीकरण पैटर्न को कवर करते हैं:

  1. सॉल्वर एपीआई — एक सामान्य वेबहुक एंडपॉइंट जो किसी भी मॉड्यूल को स्वीकार करता है और समाधान लौटाता है
  2. स्लाइडर पहेली सॉल्वर — स्लाइडर कैप्चा के लिए एक पूर्ण फ़ेच-कन्वर्ट-सॉल्व पाइपलाइन

दोनों निष्क्रिय के रूप में आयात होते हैं। अपने CapSolver क्रेडेंशियल को कॉन्फ़िगर करें, प्लेसहोल्डर मानों को बदलें, वर्कफ़्लो को सक्रिय करें, और परीक्षण करें।


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

विजन इंजन इमेज टू टेक्स्ट (OCR) से कैसे भिन्न है?

इमेज टू टेक्स्ट एक स्थिर छवि में वर्णों को पहचानता है — मानक OCR। विजन इंजन आगे जाता है: यह विजुअल पहेलियों में स्थानिक संबंधों को समझता है। यह स्लाइडर दूरी, रोटेशन कोण, ऑब्जेक्ट बाउंडिंग बॉक्स की गणना कर सकता है, और यहां तक कि एनिमेटेड GIF से टेक्स्ट भी पढ़ सकता है। वे दोनों पहचान ऑपरेशन हैं (तत्काल परिणाम, कोई पोलिंग नहीं), लेकिन वे विभिन्न प्रकार की समस्याओं को हल करते हैं।

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

नहीं। विजन इंजन आपके द्वारा प्रदान की गई छवियों का सर्वर-साइड विश्लेषण करता है। कोई ब्राउज़र सत्र नहीं है, कोई कुकी नहीं है, और लक्ष्य वेबसाइट के साथ कोई इंटरैक्शन नहीं है। प्रॉक्सी की आवश्यकता नहीं है और CapSolver नोड विजन इंजन कार्यों के लिए प्रॉक्सी पैरामीटर स्वीकार नहीं करता है।

क्या मैं एक वर्कफ़्लो निष्पादन में कई पहेलियों को हल कर सकता हूँ?

हाँ। CapSolver नोड एक समय में एक आइटम को संसाधित करता है, लेकिन n8n का आइटम-आधारित निष्पादन का मतलब है कि आप नोड के माध्यम से कई आइटम पास कर सकते हैं। प्रत्येक आइटम को अपनी पहचान कॉल मिलती है और अपना समाधान लौटाता है। एक स्प्लिट इन बैचेस नोड का उपयोग करें या एक कोड नोड से कई आइटम फ़ीड करें।

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

image और imageBackground फ़ील्ड base64-एन्कोडेड JPEG, PNG, GIF, और WebP स्वीकार करते हैं। base64 स्ट्रिंग कच्ची होनी चाहिए — कोई data:image/...;base64, उपसर्ग नहीं, कोई नई लाइन नहीं।

मैं एक वास्तविक साइट से पहेली छवियों को कैसे प्राप्त करूँ?

एक वास्तविक स्लाइडर कैप्चा एकीकरण में, लक्ष्य साइट चुनौती प्रतिक्रिया के हिस्से के रूप में पहेली छवियों को प्रदान करती है। आमतौर पर आप करेंगे:

  1. पृष्ठ लोड करें (HTTP अनुरोध या ब्राउज़र ऑटोमेशन के माध्यम से)
  2. कैप्चा विजेट के DOM या नेटवर्क अनुरोधों से छवि URL निकालें
  3. छवियां प्राप्त करें
  4. base64 में परिवर्तित करें
  5. विजन इंजन पर भेजें

स्लाइडर पहेली सॉल्वर वर्कफ़्लो चरण 3-5 को प्रदर्शित करता है। चरण 1-2 विशिष्ट लक्ष्य साइट पर निर्भर करते हैं।

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

question पैरामीटर का उपयोग केवल shein मॉड्यूल द्वारा किया जाता है। यह AI को बताता है कि छवि में क्या खोजना है — उदाहरण के लिए, "सभी जूते चुनें" या "मिलान वाली वस्तुओं पर टैप करें।" अन्य सभी मॉड्यूल के लिए, इसे खाली छोड़ दें।

क्या मैं hCaptcha छवि चुनौतियों के लिए विजन इंजन का उपयोग कर सकता हूँ?

विजन इंजन के मॉड्यूल (slider_1, rotate_1, rotate_2, shein, ocr_gif) को विशिष्ट विजुअल पहेली प्रकारों के लिए डिज़ाइन किया गया है। hCaptcha छवि वर्गीकरण चुनौतियाँ एक अलग दृष्टिकोण का उपयोग करती हैं। hCaptcha-विशिष्ट समाधानों के लिए CapSolver दस्तावेज़ देखें।

विजन इंजन कितना तेज़ है?

विजन इंजन एक पहचान ऑपरेशन है, जिसका अर्थ है कि परिणाम एक ही एपीआई कॉल में वापस आता है — आमतौर पर 2 सेकंड से कम। कोई पोलिंग लूप नहीं है, कोई getTaskResult कॉल नहीं है, और कोई टाइमआउट प्रतीक्षा नहीं है। यह इसे टोकन ऑपरेशनों की तुलना में काफी तेज़ बनाता है, जिन्हें पूरा होने में 10-30 सेकंड लग सकते हैं।

यदि छवि बहुत छोटी या बहुत बड़ी है तो क्या होगा?

बहुत छोटी छवियों में सटीक विश्लेषण के लिए पर्याप्त विवरण नहीं हो सकता है। बहुत बड़ी छवियां base64 पेलोड आकार को बढ़ाएंगी और अनुरोध को धीमा कर सकती हैं। सर्वोत्तम परिणामों के लिए, कैप्चा चुनौती द्वारा प्रदान किए गए मूल रिज़ॉल्यूशन का उपयोग करें — छवियों का आकार न बदलें।

क्या मैं विजन इंजन को ब्राउज़र ऑटोमेशन के साथ जोड़ सकता हूँ?

हाँ, और यह अधिकांश वास्तविक दुनिया के अनुप्रयोगों के लिए इच्छित उपयोग का मामला है। विशिष्ट प्रवाह है:

  1. ब्राउज़र ऑटोमेशन (n8n के माध्यम से Puppeteer/Playwright) पृष्ठ लोड करता है
  2. पहेली छवियों के साथ कैप्चा चुनौती दिखाई देती है
  3. आपका वर्कफ़्लो छवि URL निकालता है और उन्हें प्राप्त करता है
  4. विजन इंजन समाधान लौटाता है (दूरी, कोण, आदि)
  5. ब्राउज़र ऑटोमेशन चुनौती को पूरा करने के लिए समाधान का उपयोग करता है (स्लाइडर खींचें, छवि घुमाएं, निर्देशांक पर क्लिक करें)

विजन इंजन वर्कफ़्लो चरण 3-4 को संभालता है। चरण 1-2 और 5 आपके ब्राउज़र ऑटोमेशन नोड्स द्वारा संभाले जाते हैं।

और देखें

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 12, 2026

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

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

Rajinder Singh
Rajinder Singh
n8nMar 12, 2026

कैसे AWS WAF को n8n में CapSolver के साथ हल करें

आपके n8n वर्कफ्लोव्स में AWS WAF अप्रकट कैपचा को स्वचालित रूप से हल करने के लिए CapSolver AI का उपयोग करें — बिना कोई बात को लिखे एक्सपोर्टेज-ग्रेड स्क्रैपर्स, लॉगइन ऑटोमेशन और बहुबारीकरणीय सोल्वर API का निर्माण करें।

Rajinder Singh
Rajinder Singh