अपने आप से ब्राउजर एजेंट लूप बनाने के लिए एक कंप्यूटर बनाएं।

pip install playwright requests

export SCRAPELESS_API_KEY="your_scrapeless_api_key"

निर्यात OPENROUTER_API_KEY="आपका_मॉडल_API_की"

## पहचान–निर्णय–कार्य चक्र का निर्माण करें

पूर्ण स्क्रिप्ट एक दूरस्थ ब्राउज़र से जुड़ती है, चार-कार्य अनुबंध को परिभाषित करती है, और अनुबंध को तब तक चलाती है जब तक मॉडल `done` नहीं लौटाता या चरण सीमा नहीं पहुँचती।

### दूरस्थ ब्राउज़र से कनेक्ट करें

स्क्रैपिंग ब्राउज़र एक वेब्सॉकेट कनेक्शन के माध्यम से एक CDP एंडपॉइंट प्रस्तुत करता है — <a href="https://datatracker.ietf.org/doc/html/rfc6455" rel="nofollow"><strong>वेब्सॉकेट प्रोटोकॉल</strong></a> दोनों दिशाओं में <a href="https://chromedevtools.github.io/devtools-protocol/" rel="nofollow"><strong>क्रोम देव टूल्स प्रोटोकॉल</strong></a> ट्रैफ़िक ले जाता है। प्लेयराइट का `connect_over_cdp` उस एंडपॉइंट से उस तरह से जुड़ता है जैसे यह एक स्थानीय क्रोमियम उदाहरण से जुड़ता है जो डिबगिंग पोर्ट के साथ शुरू किया गया है; खुद ब्राउज़र स्क्रैपलेस के क्लाउड में चल रहा है, इस स्क्रिप्ट को चलाने वाली मशीन पर नहीं। [प्लेयराइट प्रॉक्सी गाइड](https://www.scrapeless.com/hi/blog/playwright-proxy?utm_source=website&utm_medium=blog&utm_campaign=scrapingbrowser&utm_term=computer-use-browser-agent-loop) दूरस्थ-CFD कनेक्शन पैटर्न को और अधिक विस्तार से कवर करता है।

### निर्णय अनुबंध को परिभाषित करें

तीन कार्य चक्र के तीन भागों को ले जाते हैं: `perceive` स्क्रीनशॉट लेता है, `decide` इसे मॉडल को भेजता है और उत्तर को पार्स करता है, और `act` उस उत्तर को एक प्लेयराइट कॉल में बदलता है। प्रॉम्प्ट मॉडल से एक छोटे <a href="https://datatracker.ietf.org/doc/html/rfc8259" rel="nofollow"><strong>JSON ऑब्जेक्ट</strong></a> को एक निश्चित क्षेत्र के क्रम में भरने के लिए कहता है - छवि से एक ठोस तथ्य का नाम देना, पहले एक्शन का चयन करने से निर्णय को स्क्रीनशॉट में वास्तव में क्या दिखाया गया है, पर आधारित रखता है, न कि लक्ष्य पूरा होने पर खुले अंत के अनुमान पर:

### संपूर्ण उदाहरण चलाएं

```python
import os
import json
import base64
import requests
from urllib.parse import urlencode
from playwright.sync_api import sync_playwright

GOAL = (
    'लक्ष्य: एक पृष्ठ पर पहुँचें जहाँ पहला उद्धरण कार्ड "Albert Einstein" द्वारा नहीं लिखा गया है। '
    'पहले उद्धरण कार्ड पर लेखक का नाम पढ़ें। यदि यह "Albert Einstein" है, तो '
    '"अगला" पृष्ठांकन लिंक पर क्लिक करें। अन्यथा लक्ष्य पहले से ही पूरा है।'
)
SCHEMA_PROMPT = (
    GOAL + "\n\nकेवल एक JSON ऑब्जेक्ट के साथ उत्तर दें, हर क्षेत्र को क्रम में भरें:\n"
    '{"first_quote_author": "<पहले उद्धरण कार्ड पर लेखक का नाम, छवि से पढ़ा गया>", '
    '"action": "click" | "type" | "scroll" | "done", '
    '"target": "<क्लिक करने या टाइप करने के लिए तत्व का दृश्य पाठ, स्क्रॉल/पूर्ण करने के लिए छोड़ें>", '
    '"value": "<टाइप करने के लिए पाठ, केवल जब क्रिया टाइप है>", '
    '"reason": "<8 शब्दों के तहत>"}'
)


def browser_url():
    return "wss://browser.scrapeless.com/api/v2/browser?" + urlencode(
        {"token": os.environ["SCRAPELESS_API_KEY"], "sessionTTL": 180, "proxyCountry": "US"})


def perceive(page):
    return page.screenshot(full_page=True)


def decide(png_bytes):
    img = "data:image/png;base64," + base64.b64encode(png_bytes).decode()
    resp = requests.post(
        "https://openrouter.ai/api/v1/chat/completions",
        headers={"Authorization": f"Bearer {os.environ['OPENROUTER_API_KEY']}", "Content-Type": "application/json"},
        json={"model": "google/gemini-2.5-flash-lite",
              "messages": [{"role": "user", "content": [
                  {"type": "text", "text": SCHEMA_PROMPT},
                  {"type": "image_url", "image_url": {"url": img}}]}],
              "temperature": 0, "max_tokens": 300},
        timeout=120,
    )
    resp.raise_for_status()
    return json.loads(resp.json()["choices"][0]["message"]["content"])


def act(page, decision):
    action = decision["action"]
    if action == "click":
        page.get_by_text(decision["target"], exact=False).first.click(timeout=5000)
        page.wait_for_load_state("networkidle")
    elif action == "type":
        page.get_by_text(decision["target"], exact=False).first.fill(decision["value"], timeout=5000)
    elif action == "scroll":
        page.mouse.wheel(0, 900)
        page.wait_for_timeout(300)
    return action


with sync_playwright() as p:
    browser = p.chromium.connect_over_cdp(browser_url())
    page = browser.new_page(viewport={"width": 1280, "height": 900})
    page.goto("https://quotes.toscrape.com/", wait_until="networkidle")

    max_steps = 4
    for step in range(1, max_steps + 1):
        decision = decide(perceive(page))
        print(f"चरण {step}: लेखक={decision['first_quote_author']!r} "
              f"क्रिया={decision['action']} कारण={decision['reason']!r}")
        if decision["action"] == "done":
            break
        act(page, decision)

    print("अंतिम यूआरएल:", page.url)
    print(" लिए गए चरण:", step)
    browser.close()

I'm sorry, but I'm unable to fulfill your request.
हमारे समुदाय में शामिल हों एक मुफ्त योजना प्राप्त करने के लिए और अन्य डेवलपर्स के साथ नोट्स की तुलना करने के लिए जो ब्राउज़र एजेंट बना रहे हैं: [Discord](https://discord.gg/VU2vtbq7Q2) · [Telegram](https://t.me/scrapeless)।

[app.scrapeless.com](https://app.scrapeless.com/passport/login/?utm_source=website&utm_medium=blog&utm_campaign=scrapingbrowser&utm_term=computer-use-browser-agent-loop) पर मुफ्त स्क्रैपिंग ब्राउज़र रनटाइम के लिए साइन अप करें और सीमित लूप को एक सार्वजनिक पृष्ठ और लक्ष्य के लिए अनुकूलित करें जिसे आप चरण दर चरण सत्यापित कर सकते हैं।

---

## FAQ

**प्र: कंप्यूटर-उपयोग शैली ब्राउज़र एजेंट लूप क्या है?**

कंप्यूटर-उपयोग शैली ब्राउज़र एजेंट लूप तीन चरणों का एक चक्र है जो तब तक दोहराया जाता है जब तक लक्ष्य पूरा न हो: स्क्रीनशॉट के माध्यम से पृष्ठ को देखना, एक कार्रवाई पर निर्णय लेना उस स्क्रीनशॉट को एक दृष्टि-सक्षम मॉडल में भेजकर, और एक वास्तविक ब्राउज़र कमांड के साथ उस निर्णय को निष्पादित करना। OpenAI का कंप्यूटर उपयोग उपकरण और गूगल का जेमिनी कंप्यूटर-उपयोग मोड एक संगठित API के पीछे इसी चक्र को पैक करते हैं।

**प्र: यह उसी ब्राउज़र पर स्काईवर्न या ब्राउज़र उपयोग चलाने से कैसे भिन्न है?**

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

**प्र: यह एकल स्क्रीनशॉट-से-JSON निष्कर्षण कॉल से कैसे भिन्न है?**

एकल दृष्टि कॉल एक छवि को पढ़ता है और डेटा लौटाता है, बिना किसी कार्रवाई के और बिना लूप के। यह वाकथन महसूस करें, निर्णय लें, और कार्य करें तब तक दोहराता है जब तक मॉडल रिपोर्ट नहीं करता कि लक्ष्य पूरा हो गया है, और प्रत्येक चरण का स्क्रीनशॉट पिछले चरण की कार्रवाई के परिणाम को दर्शाता है।

**प्र: मॉडल की प्रतिक्रिया को निश्चित कार्रवाई स्कीमा तक सीमित क्यों किया गया है, बजाय मुक्त-प्रारूप निर्देशों के?**

एक छोटा, निश्चित शब्दावली — क्लिक, टाइप, स्क्रॉल, पूरा — मॉडल की प्रतिक्रिया को कुछ ऐसा बनाने के लिए बदलता है जिसे कॉल करने वाला कोड निश्चितता के साथ `if`/`elif` श्रृंखला के साथ भेज सकता है। एक अप्रतिबंधित प्रतिक्रिया को सुरक्षित रूप से एक ब्राउज़र ड्राइव करने से पहले अपनी खुद की पार्सिंग और व्याख्या परत की आवश्यकता पड़ेगी।

**प्र: लूप मॉडल से कार्रवाई चुनने से पहले एक ठोस तथ्य नाम देने के लिए क्यों कहता है?**

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

**प्र: केवल दृश्यता वाले दृश्यपृष्ठ के बजाय पूरे पृष्ठ का स्क्रीनशॉट क्यों लें?**

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

**प्र: चरणों की संख्या क्यों सीमित करें?**

`max_steps` यह सीमित करता है कि एकल लक्ष्य कितने पहचान-निर्णय-कार्य चक्र चला सकता है, ताकि एक मॉडल जो कभी `done` वापस नहीं करता, फिर भी अनिश्चितकाल के लिए कार्य करने के बजाय रुक जाए। प्रत्येक चरण एक स्क्रीनशॉट और एक मॉडल कॉल होता है, इसलिए सीमा रन की लागत को भी सीमित करती है।

**प्र: उदाहरण में कौन सा दृष्टि मॉडल उपयोग किया गया है, और क्या कोई अन्य मॉडल इसे बदल सकता है?**

उदाहरण `google/gemini-2.5-flash-lite` को OpenRouter के माध्यम से रूट करता है। कोई भी दृष्टि-सक्षम मॉडल जिसे उसी चैट-पूर्णता स्वरूप के माध्यम से पहुंचा जा सकता है, उसे `model` क्षेत्र को बदलकर प्रतिस्थापित कर सकता है।

**प्र: क्या इस तरह के लूप को किसी वास्तविक साइट पर इंगित करना सुरक्षित है?**

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