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

अगर आपने कभी किसी एंटरप्राइज-कक्षा बॉट डिटेक्शन द्वारा सुरक्षित वेबसाइट को डाउनलोड करने की कोशिश की है, तो आपने शायद एक अदृश्य दीवार के सामने आकर रुक गए होंगे: आपके अनुरोध ब्लॉक कर दिए जाते हैं, भले ही आपके हेडर, कुकीज़ और यूजर-एजेंट सही हों। कारण? TLS फिंगरप्रिंटिंग — और यह आपके HTTP अनुरोध भेजे जाने से पहले होता है।

बॉट-प्रतिरोध सेवाएं जैसे क्लाउडफ़्लेयर, एकामाई, डेटाडॉम, और अन्य लोग ब्राउज़र के बजाय एक ऑटोमेशन टूल के रूप में पहचाने जाने वाले क्लाइंट के लिए रॉ टीएलएस हैंडशेक की जांच करती हैं। मानक HTTP क्लाइंट — गो के net/http, पायथन के requests, curl, नोड.जे.एस axios — सभी के अलग-अलग TLS फिंगरप्रिंट होते हैं जो तुरंत चिह्नित कर दिए जाते हैं।

इस गाइड में, आप httpcloak का उपयोग करके एक हल्का गो सर्वर बनाएंगे जो वास्तविक क्रोम TLS फिंगरप्रिंट के रूप में झूठ बोलता है, और इसे n8n वर्कफ़्लो के साथ जोड़ेंगे ताकि प्रत्येक HTTP अनुरोध नेटवर्क स्तर पर वास्तविक क्रोम ब्राउज़र ट्रैफिक के रूप में दिखाई दे।

TLS फिंगरप्रिंटिंग क्या है?

हर बार जब कोई क्लाइंट HTTPS के माध्यम से वेबसाइट से जुड़ता है, तो यह एक TLS हैंडशेक शुरू करता है जब यह ClientHello संदेश भेजता है। यह संदेश में शामिल होता है:

• सिफर सुट्स — क्लाइंट द्वारा समर्थित एन्क्रिप्शन एल्गोरिदम और उनके क्रम
• TLS एक्सटेंशन — सीएनआई, एएलपीएन, समर्थित समूह, साइनेचर एल्गोरिदम जैसे विशेषताएं
• ईलिप्टिक कर्व और बिंदु प्रारूप — क्रिप्टोग्राफिक पैरामीटर
• TLS संस्करण — अधिकतम TLS संस्करण समर्थित

बॉट-प्रतिरोध सेवाएं इन मानों को निकालती हैं और एक फिंगरप्रिंट गणना करती हैं — जिसे जेए3 या जेए4 फिंगरप्रिंट कहा जाता है — जो क्लाइंट सॉफ्टवेयर की विशिष्टता को निर्दिष्ट करता है। प्रत्येक ब्राउज़र, HTTP लाइब्रेरी, और प्रोग्रामिंग भाषा रनटाइम के अलग-अलग फिंगरप्रिंट होते हैं।

मुख्य अवधारणा: TLS फिंगरप्रिंटिंग हैंडशेक के दौरान होता है, जब आपके HTTP हेडर भेजे जाने से पहले होता है। कोई भी हेडर संशोधन असामान्य ब्राउज़र TLS फिंगरप्रिंट को ठीक नहीं कर सकता।

मानक HTTP क्लाइंट क्यों विफल हो जाते हैं

जब एक ब्राउज़र HTTPS के माध्यम से वेबसाइट से जुड़ता है, तो यह अपने समर्थित सिफर सुट्स, एक्सटेंशन और सेटिंग्स के बारे में विवरण भेजता है। बॉट-प्रतिरोध सेवाएं इस फिंगरप्रिंट को रिकॉर्ड करती हैं (जिसे जेए3 या जेए4 फिंगरप्रिंट कहा जाता है) और इसकी जांच ज्ञात ब्राउज़र प्रोफ़ाइल के साथ करती हैं।

गो के net/http, पायथन के requests, curl और अधिकांश HTTP लाइब्रेरी सभी अलग-अलग TLS फिंगरप्रिंट होते हैं। भले ही आपके कुकीज़ और हेडर सही हों, बॉट-प्रतिरोध प्रणाली अगर वे ब्राउज़र के TLS फिंगरप्रिंट के बजाय गो या पायथन के फिंगरप्रिंट को पहचानती हैं तो अनुरोध ब्लॉक कर दिया जाता है।

यहां चरण-दर-चरण घटनाएं हैं:

1. आपके n8n वर्कफ़्लो एक सुरक्षित वेबसाइट पर HTTP अनुरोध भेजता है
2. TLS हैंडशेक शुरू होता है — आपका क्लाइंट अपना ClientHello भेजता है
3. बॉट-प्रतिरोध सेवा हैंडशेक के माध्यम से जेए3/जेए4 फिंगरप्रिंट रिकॉर्ड करती है
4. फिंगरप्रिंट गो/पायथन/नोड.जे.एस के साथ मेल खाता है — क्रोम या फायरफॉक्स के साथ नहीं
5. अनुरोध ब्लॉक कर दिया जाता है, चुनौती दी जाती है या एक झूठी पृष्ठ दिखाया जाता है — आपके हेडर जांचे जाने से पहले

इसलिए User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) ... सेट करना काम नहीं करता। User-Agent HTTP-स्तर का हेडर है। TLS फिंगरप्रिंटिंग निम्न स्तर पर काम करता है। अगर आपका User-Agent क्रोम के रूप में बताता है लेकिन आपका TLS फिंगरप्रिंट गो के रूप में बताता है, तो अनुरोध तुरंत चिह्नित कर दिया जाता है।

TLS फिंगरप्रिंटिंग कौन उपयोग करता है?

TLS फिंगरप्रिंटिंग एंटरप्राइज बॉट सुरक्षा में मानक अभ्यास बन गया है। यहां बताए गए सेवाएं जो TLS फिंगरप्रिंट की जांच करती हैं:

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

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

चरण 1 — TLS सर्वर बनाएं

TLS सर्वर एक हल्का गो HTTP सर्वर है जो 7878 पोर्ट पर अनुरोध स्वीकार करता है और httpcloak के क्रोम-145 TLS प्रीसेट के साथ अगले अनुरोध भेजता है।

स्रोत फ़ाइल बनाएं

mkdir -p ~/tls-server && cd ~/tls-server

main.go नाम की फ़ाइल बनाएं जिसमें निम्न सामग्री है:

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"strings"
	"time"

	"github.com/sardanioss/httpcloak/client"
)

type FetchRequest struct {
	URL     string            `json:"url"`
	Method  string            `json:"method"`
	Headers map[string]string `json:"headers"`
	Proxy   string            `json:"proxy"`
	Body    string            `json:"body"`
}

type FetchResponse struct {
	Status  int                 `json:"status"`
	Body    string              `json:"body"`
	Headers map[string][]string `json:"headers"`
}

type ErrorResponse struct {
	Error string `json:"error"`
}

func writeError(w http.ResponseWriter, status int, msg string) {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(status)
	json.NewEncoder(w).Encode(ErrorResponse{Error: msg})
}

func fetchHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		writeError(w, http.StatusMethodNotAllowed, "केवल POST अनुमति है")
		return
	}

	var req FetchRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		writeError(w, http.StatusBadRequest, "अमान्य JSON: "+err.Error())
		return
	}

	if req.URL == "" {
		writeError(w, http.StatusBadRequest, "यूआरएल आवश्यक है")
		return
	}
	if req.Method == "" {
		req.Method = "GET"
	}

	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
	defer cancel()

	c := client.NewClient("chrome-145", client.WithTimeout(60*time.Second))
	defer c.Close()

	if req.Proxy != "" {
		c.SetProxy(req.Proxy)
	}

	headers := make(map[string][]string, len(req.Headers))
	var userAgent string
	for k, v := range req.Headers {
		lower := strings.ToLower(k)
		if lower == "user-agent" {
			userAgent = v
		} else {
			headers[k] = []string{v}
		}
	}

	var bodyReader io.Reader
	if req.Body != "" {
		bodyReader = strings.NewReader(req.Body)
	}

	hcReq := &client.Request{
		Method:    strings.ToUpper(req.Method),
		URL:       req.URL,
		Headers:   headers,
		Body:      bodyReader,
		UserAgent: userAgent,
		FetchMode: client.FetchModeNavigate,
	}

	resp, err := c.Do(ctx, hcReq)
	if err != nil {
		writeError(w, http.StatusBadGateway, "फेच असफल: "+err.Error())
		return
	}

	body, err := resp.Text()
	if err != nil {
		writeError(w, http.StatusInternalServerError, "बॉडी पढ़ना असफल: "+err.Error())
		return
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(FetchResponse{
		Status:  resp.StatusCode,
		Body:    body,
		Headers: resp.Headers,
	})
}

func main() {
	const port = "7878"

	mux := http.NewServeMux()
	mux.HandleFunc("/fetch", fetchHandler)
	mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		fmt.Fprint(w, `{"status":"ok"}`)
	})

	log.Printf("TLS सर्वर (httpcloak chrome-145) :%s पर सुन रहा है", port)
	log.Fatal(http.ListenAndServe(":"+port, mux))
}

पहले अंतर्निहित और बिल्ड करें

go mod init tls-server
go get github.com/sardanioss/httpcloak/client
go build -o main main.go

सर्वर चलाएं

./main

सर्वर फॉरग्राउंड में चलता है। इसे बैकग्राउंड में चलाए रखने के लिए कोई भी प्रक्रिया प्रबंधक (systemd, supervisor, Docker, आदि) या screen/tmux सत्र में चलाएं।

यह सुनिश्चित करें कि यह चल रहा है (नए टर्मिनल में)

curl http://localhost:7878/health

अपेक्षित: {"status":"ok"}

नोट: TLS सर्वर को समान मशीन पर चलाना आवश्यक है जहां आपका n8n इंस्टेंस है। n8n वर्कफ़्लो इसे http://localhost:7878/fetch पर कॉल करता है।

चरण 2 — n8n के लिए localhost कॉल करने की अनुमति दें

डिफ़ॉल्ट रूप से, n8n localhost पतों पर HTTP अनुरोध नोड्स को ब्लॉक कर देता है (SSRF सुरक्षा)। आपके वर्कफ़्लो के लिए आपको इसे अक्षम करना होगा ताकि आपके वर्कफ़्लो localhost:7878 पर TLS सर्वर तक पहुंच सकें।

N8N_BLOCK_ACCESS_TO_LOCALHOST=false पर्यावरण चर को जोड़ें और अपने n8n इंस्टेंस को रीस्टार्ट करें। आप इसे कैसे करते हैं इसके आधार पर अलग-अलग होगा:

अगर आप n8n सीधे चलाते हैं:

export N8N_BLOCK_ACCESS_TO_LOCALHOST=false
n8n start

अगर आप Docker का उपयोग करते हैं:

docker run कमांड में -e N8N_BLOCK_ACCESS_TO_LOCALHOST=false जोड़ें, या इसे docker-compose.yml में environment खंड में जोड़ें।

चरण 3 — n8n से TLS सर्वर का उपयोग करें

TLS सर्वर केवल एक एपीआई बिंदु पर अपने अनुरोध को भेजता है जो किसी भी HTTP अनुरोध स्वीकार करता है और इसे क्रोम TLS फिंगरप्रिंट के साथ फॉरवर्ड करता है।

एपीआई रेफरेंस

एपीआई बिंदु: POST http://localhost:7878/fetch

अनुरोध बॉडी (JSON):

{
  "url": "https://example.com",
  "method": "GET",
  "headers": {
    "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36",
    "cookie": "cf_clearance=abc123; session=xyz"
  },
  "proxy": "http://user:pass@host:port",
  "body": ""
}

उत्तर (JSON):

{
  "status": 200,
  "body": "<html>...</html>",
  "headers": { "content-type": ["text/html"], "..." : ["..."] }
}

n8n HTTP अनुरोध नोड को सेट करें

TLS सर्वर को n8n वर्कफ़्लो से कॉल करने के लिए, एक HTTP अनुरोध नोड का उपयोग इन सेटिंग्स के साथ करें:

महत्वपूर्ण: contentType: "json" के साथ JSON.stringify() के उपयोग से n8n द्वि-सीरियलाइज कर देता है, जिसके कारण {"": ""} के बजाय आपके डेटा को भेजा जाता है। हमेशा contentType: "raw" के साथ rawContentType: "application/json" का उपयोग करें।

उदाहरण: सुरक्षित पृष्ठ को फेच करें

HTTP अनुरोध नोड बॉडी एक्सप्रेशन में:

={{ JSON.stringify({
  url: "https://protected-site.com/data",
  method: "GET",
  headers: {
    "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36",
    "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
    "accept-language": "en-US,en;q=0.9"
  },
  proxy: "http://user:pass@proxy-host:8080"
}) }}

TLS सर्वर इस अनुरोध को क्रोम-145 TLS फिंगरप्रिंट के साथ फॉरवर्ड करेगा, और लक्ष्य एक वास्तविक क्रोम ब्राउज़र कनेक्शन देखेगा।

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

कमांड लाइन से सीधे TLS सर्वर का परीक्षण करें:

curl -X POST http://localhost:7878/fetch \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://tls-check.example.com",
    "method": "GET",
    "headers": {
      "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36"
    }
  }'

आप जेए3/जेए4 फिंगरप्रिंट चेकर पर सर्वर को दिशा देकर अपना TLS फिंगरप्रिंट की जांच कर सकते हैं — परिणाम वास्तविक क्रोम ब्राउज़र के साथ मेल खाना चाहिए, न कि गो मानक प per लाइब्रेरी क्लाइंट के साथ।

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

इस वर्कफ़्लो एक वेबहुक एंडपॉइंट बनाता है जो किसी भी अनुरोध को क्रोम TLS फिंगरप्रिंट के साथ TLS सर्वर के माध्यम से फॉरवर्ड करता है। POST भेजें url, method, headers, और वैकल्पिक proxy के साथ — वर्कफ़्लो localhost:7878/fetch पर इसे पास करता है और परिणाम वापस करता है।

वेबहुक (POST /tls-fetch) → TLS सर्वर के माध्यम से फेच करें → वेबहुक पर प्रतिक्रिया दें

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

{
  "nodes": [
    {
      "parameters": {
        "content": "## TLS फेच - क्रोम फिंगरप्रिंट प्रॉक्सी\n\n### कैसे काम करता है\n\n1. एक वेबहुक आगमन अनुरोध को ट्रिगर करता है।\n2. वर्कफ़्लो TLS सर्वर पर POST अनुरोध भेजता है ताकि डेटा फेच किया जा सके।\n3. फेच किया गया डेटा प्रारंभिक वेबहुक अनुरोध के लिए प्रतिक्रिया के रूप में भेजा जाता है।\n\n### सेटअप चरण\n\n- [ ] आगमन अनुरोध को ग्रहण करने के लिए वेबहुक URL सेट करें।\n- [ ] आवश्यकता होने पर HTTP अनुरोध नोड को सही सर्वर एंडपॉइंट और प्राथमिकता के साथ सेट करें।\n- [ ] प्रतिक्रिया नोड को सही रूप से मैप करें ताकि अपेक्षित परिणाम लौटाए जा सकें।\n\n### अनुकूलन\n\nHTTP अनुरोध में एंडपॉइंट और प्राथमिकता सेटिंग्स को आवश्यकता होने पर अनुकूलित किया जा सकता है।",
        "width": 480,
        "height": 656
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [
        -768,
        -112
      ],
      "id": "d41de645-08b4-45a5-ac9b-6c96287f6729",
      "name": "स्टिकी नोट"
    },
    {
      "parameters": {
        "content": "## वेबहुक शुरू करें\n\nवर्कफ़्लो को ट्रिगर करता है जब एक वेबहुक अनुरोध प्राप्त करता है।",
        "width": 240,
        "height": 320,
        "color": 7
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [
        -208,
        -112
      ],
      "id": "a5fbb0e3-ae83-4526-96c9-2b5ceb33b25e",
      "name": "स्टिकी नोट1"
    },
    {
      "parameters": {
        "content": "## TLS डेटा फेच\n\nTLS सर्वर पर POST अनुरोध करता है ताकि आवश्यक डेटा फेच किया जा सके।",
        "width": 240,
        "height": 320,
"color": 7
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [
        160,
        -112
      ],
      "id": "a984c3d2-c59a-4a22-b056-dad8d6ae5bd8",
      "name": "स्टिकी नोट2"
    },
    {
      "parameters": {
        "content": "## प्रतिक्रिया भेजें\n\nप्राप्त डेटा के साथ मूल हूबवेब अनुरोध के साथ प्रतिक्रिया देता है।",
        "width": 240,
        "height": 320,
        "color": 7
      },
      "type": "n8n-nodes-base.stickyNote",
      "typeVersion": 1,
      "position": [
        448,
        -112
      ],
      "id": "cd733c4f-140c-4c88-a498-1d1636c22a43",
      "name": "स्टिकी नोट3"
    },
    {
      "parameters": {
        "httpMethod": "POST",
        "path": "tls-fetch",
        "responseMode": "responseNode",
        "options": {}
      },
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 2.1,
      "position": [
        -160,
        48
      ],
      "id": "tls-001",
      "name": "अनुरोध प्राप्त करें",
      "webhookId": "tls-001-webhook"
    },
    {
      "parameters": {
        "method": "POST",
        "url": "http://localhost:7878/fetch",
        "sendBody": true,
        "contentType": "raw",
        "rawContentType": "application/json",
        "body": "={{ JSON.stringify($json.body) }}",
        "options": {
          "timeout": 60000
        }
      },
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.3,
      "position": [
        208,
        48
      ],
      "id": "tls-002",
      "name": "TLS सर्वर के माध्यम से फेच करें"
    },
    {
      "parameters": {
        "respondWith": "json",
        "responseBody": "={{ JSON.stringify($json) }}",
        "options": {}
      },
      "type": "n8n-nodes-base.respondToWebhook",
      "typeVersion": 1.5,
      "position": [
        496,
        48
      ],
      "id": "tls-003",
      "name": "हूबवेब के लिए प्रतिक्रिया दें"
    }
  ],
  "connections": {
    "Receive Request": {
      "main": [
        [
          {
            "node": "Fetch via TLS Server",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Fetch via TLS Server": {
      "main": [
        [
          {
            "node": "Respond to Webhook",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  },
  "pinData": {},
  "meta": {
    "instanceId": "962ff0267b713be0344b866fa54daae28de8ed2144e2e6867da355dae193ea1f"
  }
}

निष्कर्ष

आपने एक TLS फिंगरप्रिंट झूठ बोलने वाला सर्वर सेट कर लिया है जो n8n के HTTP मांग को नेटवर्क स्तर पर वास्तविक Chrome ब्राउज़र ट्रैफिक के रूप में दिखाता है। यह ऐंटी-बॉट सेवाओं के लिए आवश्यक है जो TLS फिंगरप्रिंट की जांच करती हैं।

इस TLS सर्वर का उपयोग बाहर निकालने के लिए उपयोगी है:

• Cloudflare Bot Management — पूर्ण-पृष्ठ चुनौतियां जो TLS फिंगरप्रिंट की जांच करती हैं
• Akamai Bot Manager — TLS विश्लेषण के साथ एंटरप्राइज बॉट डिटेक्शन
• DataDome — व्यवहार + TLS फिंगरप्रिंट विश्लेषण
• PerimeterX / HUMAN — डिवाइस + TLS फिंगरप्रिंटिंग
• अन्य कई ऐंटी-बॉट सेवाएं जो CapSolver समर्थित हैं

httpcloak प per अपने Chrome-145 प्रीसेट के साथ JA3/JA4 फिंगरप्रिंट झूठ बोलना, HTTP/2 SETTINGS फ्रेम, ALPN निगोशिएशन, और हेडर क्रम के साथ-साथ नियंत्रित करता है — जो आपके मांग को वास्तविक Chrome ब्राउज़र के रूप में TLS स्तर पर अलग नहीं कर सकता।

TLS झूठ बोलने के साथ CAPTCHA हल करने की आवश्यकता है? CapSolver के बारे में जांचें — यह n8n के साथ आधिकारिक नोड के रूप में सीधे एकीकृत है और Cloudflare चैलेंज, Turnstile, reCAPTCHA और अन्य कई कैप्चा का समर्थन करता है। पहली भरती पर 8% अतिरिक्त बोनस के लिए n8n बोनस कोड का उपयोग करें!

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

TLS फिंगरप्रिंटिंग क्या है?

TLS फिंगरप्रिंटिंग एक तकनीक है जहां सर्वर आपके TLS ClientHello संदेश के विशेषताओं की जांच करते हैं — शामिल करते हैं सीफर सूट, एक्सटेंशन और उनके क्रम को। प्रत्येक HTTP क्लाइंट (Chrome, Firefox, curl, Go, Python) के लिए अद्वितीय फिंगरप्रिंट पैटर्न होता है।

मैं केवल User-Agent हेडर को Chrome पर सेट क्यों नहीं कर सकता?

User-Agent हेडर HTTP स्तर का एक गुण है। TLS फिंगरप्रिंटिंग एक निम्न स्तर पर होता है — TLS हैंडशेक के दौरान, जब कोई HTTP हेडर भेजा जाता है। ऐंटी-बॉट सेवाएं दोनों स्तरों की तुलना करती हैं: अगर आपका User-Agent Chrome कहता है लेकिन आपका TLS फिंगरप्रिंट Go/Python कहता है, तो मांग बॉट के रूप में चिह्नित कर दी जाती है।

httpcloak क्या है?

httpcloak Go लाइब्रेरी है जो वास्तविक ब्राउज़र TLS प्रोफाइल झूठ बोलता है। यह JA3/JA4 फिंगरप्रिंट मैचिंग, HTTP/2 SETTINGS फ्रेम, ALPN निगोशिएशन और हेडर क्रम का प्रबंधन करता है। chrome-145 प्रीसेट वास्तविक Chrome 145 ब्राउज़र के साथ अलग नहीं कर सकता।

क्या मैं अलग Chrome संस्करण प्रीसेट का उपयोग कर सकता हूं?

हां। httpcloak कई ब्राउज़र प्रीसेट का समर्थन करता है। उपलब्ध प्रीसेट के लिए httpcloak दस्तावेज़ीकरण देखें। प्रीसेट बदलने के लिए, main.go में client.NewClient("chrome-145", ...) को अपने अपेक्षित ब्राउज़र प्रोफाइल में बदलें।

क्या यह n8n Cloud के साथ काम करता है?

नहीं, आसानी से नहीं। TLS सर्वर एक स्थानीय Go बाइनरी है जिसे n8n के साथ एक ही मशीन पर चलाना आवश्यक है ताकि वर्कफ़्लो कार्यक्रम http://localhost:7878/fetch के लिए कॉल कर सकें। n8n Cloud में वर्कफ़्लो के साथ स्थानीय सेवाओं के चलाने की अनुमति नहीं है। आपको एक स्व-स्थापित n8n उदाहरण की आवश्यकता होगी।

क्या मैं अलग मशीन पर TLS सर्वर चला सकता हूं?

हां, लेकिन आपको n8n HTTP मांग नोड्स में URL को http://localhost:7878/fetch से http://your-server-ip:7878/fetch में बदलना होगा, और सुनिश्चित करें कि पोर्ट 7878 एक्सेसिबल है। आपको n8n के SSRF सुरक्षा को अक्षम करना होगा या सर्वर के IP को सफेद सूची में जोड़ें।

जब एक नई संस्करण जारी होती है तो मैं च्रोम प्रीसेट कैसे अपडेट करूं?

httpcloak डिपेंडेंसी अपडेट करें: go get -u github.com/sardanioss/httpcloak/client, main.go में प्रीसेट स्ट्रिंग को नई संस्करण में बदलें, go build -o main main.go के साथ बिल्ड करें, और सर्वर रीस्टार्ट करें।

क्या TLS सर्वर समानांतर मांगों का समर्थन करता है?

हां। Go के HTTP सर्वर समानांतर मांगों का स्वयं समर्थन करता है। प्रत्येक मांग अपने स्वयं के TLS संपर्क के साथ एक नई httpcloak क्लाइंट इंस्टेंस बनाता है। उच्च आउटपुट कार्यभार के लिए, स्मृति उपयोग की निगरानी करें क्योंकि प्रत्येक संपर्क अपने TLS स्थिति को बरकरार रखता है।

क्या प्रदर्शन अतिरिक्त लागत है?

TLS सर्वर न्यूनतम लैटेंसी जोड़ता है — आमतौर पर स्थानीय प्रॉक्सी चरण के लिए 10-50ms। वास्तविक HTTPS कनेक्शन के लिए अधिकांश मांग समय खर्च होता है। Chrome TLS हैंडशेक गो के डिफ़ॉल्ट के मुकाबले थोड़ा भारी होता है, लेकिन व्यावहारिक रूप से यह नगण्य है।

कैसे निश्चित करें कि TLS सर्वर रीबूट के बाद चलता रहे?

किसी भी प्रक्रिया प्रबंधक का उपयोग करें — systemd, supervisor, Docker, या समान — ताकि TLS सर्वर को बूट पर शुरू होने वाली सेवा के रूप में पंजीकृत करें। एक तेज सेटअप के लिए, आप screen या tmux सेशन में इसे चला सकते हैं।