अमेज़न रुफस अनुशंसाओं की समय के साथ निगरानी कैसे करें

मुख्य बिंदु:

• Amazon Rufus अनुशंसाएँ संरचित उत्पाद डेटा हैं, न कि चैट ट्रांस्क्रिप्ट। type: rufus के साथ scraper.amazon अभिनेता को एक कॉल करने पर एक products एरे लौटता है, जिसमें प्रत्येक प्रविष्टि में ASIN, शीर्षक, मूल्य, रेटिंग, और वह अनुभाग लेबल होता है जिसके अंतर्गत Rufus ने इसे समूहित किया था।
• अनुशंसा का हिस्सा इस पाइपलाइन द्वारा उत्पन्न मेट्रिक है। समय के साथ एक निश्चित प्रश्न सेट के लिए Rufus द्वारा प्रदर्शित होने वाले ASINs को ट्रैक करना एक संवादात्मक शेल्फ को एक मापने योग्य दृश्यता संकेत में बदलता है - यह Rufus का हिस्सा-उच्चारण के समान है।
• Rufus अपनी पसंद को लेबल वाले अनुभागों में विभाजित करता है। प्रतिक्रिया content_blocks के माध्यम से उत्पादों को "Top Picks – Best ANC" और "Great Value Picks" जैसे समूहों में वर्गीकृत करती है, इसलिए प्रत्येक उत्पाद के पास एक समग्र रैंक और उस अनुभाग का शीर्षक होता है जो इसे फ्रेम करता है।
• related_questions अपने आप में प्रारंभिक प्रश्न सेट का विस्तार करता है। प्रत्येक कैप्चर के लिए Rufus द्वारा प्रश्न के लिए सुझाए गए फॉलो-अप प्रश्न लौटते हैं, और वे सीधे अगले रन की प्रॉम्प्ट सूची में वापस आते हैं।
• हर फ़ील्ड नल योग्य है और उत्तर प्रति सत्र उत्पन्न होता है। एक प्रश्न किसी दिए गए क्षेत्र के लिए कोई Rufus उत्तर नहीं लौटा सकता है, और एक उत्पाद स्लॉट बिना bought गिनती के आ सकता है - इसलिए पाइपलाइन प्रति रन स्नैपशॉट संग्रहीत करती है और श्रृंखला को पढ़ती है, कभी एकल कॉल नहीं।
• पाइपलाइन जोड़ने योग्य स्नैपशॉट पर कम होती है। प्रत्येक रन एक JSONL रिकॉर्ड बनाता है जिसे प्रश्न और कैप्चर समय द्वारा कुंजीबद्ध किया जाता है; लगातार रिकॉर्ड की तुलना करने पर रिपोर्ट होती है कि कौन से ASINs ने रन के बीच प्रवेश या ड्रॉप किया।
• शुरू करने के लिए मुफ़्त। नए Scrapeless खातों में मुफ्त परीक्षण क्रेडिट शामिल हैं - app.scrapeless.com पर साइन अप करें।

परिचय: खरीदारी की शेल्फ सहायक के भीतर चली गई

Amazon Rufus खरीदारी के सवालों के उत्तर एक रैंक वाली उत्पादों की सूची के साथ देता है। एक खरीदार सबसे अच्छा नॉइज़-कैंसलिंग हेडफ़ोन पूछता है, और Rufus समूहित पसंद लौटाता है - "Top Picks", "Best for Apple Users", "Great Value Picks" - प्रत्येक के साथ एक मूल्य, एक रेटिंग, और एक खरीद लिंक, सहायक के भीतर और किसी भी खोज-परिणाम पृष्ठ के लोड होने से पहले। एक ब्रांड के लिए, सवाल अब यह नहीं है कि एक उत्पाद परिणाम ग्रिड पर किस स्थान पर है; यह है कि क्या Rufus उत्पाद का नाम देता है, किस अनुभाग में, और किस रैंक पर।

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

यह गाइड Scrapeless Scraping API के शीर्ष पर एक निगरानी पाइपलाइन बनाता है: एक निश्चित प्रश्न सेट अंदर जाता है, scraper.amazon अभिनेता Rufus की अनुशंसाएँ संरचित उत्पादों के रूप में लौटाता है, और पाइपलाइन ASIN, रैंक और अनुभाग निकालती है, प्रत्येक ASIN को एक ब्रांड पर मैप करती है, प्रति रन स्नैपशॉट संग्रहित करती है, और स्नैपशॉट्स का अंतर निकालती है जिससे अनुशंसा का हिस्सा रिपोर्ट होता है। यह Google AI ओवरव्यू में ब्रांड दृश्यता के साथ स्वाभाविक रूप से युग्मित होती है, जो खोज पक्ष पर उसी अनुशंसा प्रश्न को ट्रैक करती है।

पाइपलाइन एक नज़र में

संपूर्ण प्रणाली छह चरणों में है, अंत से अंत तक:

1. प्रश्न सेट परिभाषित करें — खरीदारी के प्रश्नों की एक निश्चित सूची, प्रत्येक कैप्चर द्वारा लौटाए गए related_questions द्वारा विस्तारित।
2. प्रत्येक प्रश्न को कैप्चर करें — scraper.amazon अभिनेता को type: rufus के साथ प्रत्येक प्रश्न को POST करें; एक असमर्थित क्षेत्र कोई Rufus उत्तर नहीं लौटाता है, जिसे पाइपलाइन रिकॉर्ड करती है और छोड़ देती है।
3. उत्पाद निकालें — content_blocks में चलें, प्रत्येक उत्पाद के ASIN, समग्र रैंक, और अनुभाग लेबल को खींचें।
4. ASIN → ब्रांड मैप करें — एक छोटे ह्यूरीस्टिक के साथ उत्पाद के शीर्षक से एक ब्रांड को हल करें ताकि साझा ASIN स्तर से ऊपर समेकित किया जा सके।
5. प्रति-रन स्नैपशॉट संग्रहित करें — प्रत्येक प्रश्न के लिए एक JSONL रिकॉर्ड जोड़ें जिसे प्रश्न और कैप्चर समय द्वारा कुंजीबद्ध किया जाए; कभी भी ओवरराइट न करें।
6. समय के साथ अंतर निकालें — लगातार स्नैपशॉट की तुलना करें ताकि अनुशंसा के हिस्से और कौन से ASINs ने प्रवेश या ड्रॉप किया, वह रिपोर्ट करें।

चरण 1-4 प्रत्येक चक्र में प्रत्येक प्रश्न पर चलते हैं; चरण 5-6 उन कैप्चर को एक समय श्रृंखला में बदलते हैं। नीचे के अनुभाग क्रम में प्रत्येक चरण का निर्माण करते हैं।

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

• Python 3.10 या नया (नीचे दिए गए कोड में केवल मानक पुस्तकालय और requests का उपयोग किया गया है)
• एक Scrapeless खाता और API कुंजी - app.scrapeless.com पर साइन अप करें
• कुंजी को SCRAPELESS_API_KEY के रूप में निर्यात करें
• टर्मिनल और JSON के साथ बुनियादी परिचितता

चरण 1 — प्रश्न सेट को परिभाषित करें

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

SEED_QUERIES = [
"सर्वश्रेष्ठ शोर रद्द करने वाले हेडफोन",
"यात्रा के लिए सर्वश्रेष्ठ वायरलेस ईयरबड",
"सर्वश्रेष्ठ बजट ओवर-ईयर हेडफोन"
KNOWN_BRANDS = ("सोनी", "बोज़", "एप्पल", "सेनहाइज़र", "बीट्स", "जेबीएल", "आंकर")


def brand_from_title(title: str) -> str | None:
    if not title:
        return None
    lowered = title.lower()
    for brand in KNOWN_BRANDS:
        if brand.lower() in lowered:
            return brand
    return title.split()[0]  # बैकअप: शीर्षक का पहला शब्द

> आपके मुफ्त योजना पर API कुंजी प्राप्त करें: [app.scrapeless.com](https://app.scrapeless.com/passport/login/?utm_source=website&utm_medium=blog&utm_campaign=scraperapi&utm_term=monitor-amazon-rufus-recommendations)

---

## चरण 4 — प्रति-रन स्नैपशॉट स्टोर करें

पाइपलाइन केवल अपेंड-ओनली है: प्रत्येक कैप्चर एक JSONL रिकॉर्ड लिखता है जिसे क्वेरी और कैप्चर समय द्वारा कुंजी बद्ध किया जाता है, और कुछ भी कभी ओवरराइट नहीं होता। यह आपको पूर्ण इतिहास प्रदान करता है जिसे आप भिन्न कर सकते हैं, और इसका मतलब है कि एक खराब या खाली रन पहले के अच्छे को नष्ट नहीं करता।

```python
import json
import time


def append_snapshot(path: str, query: str, rows: list[dict]) -> dict:
    record = {"query": query, "captured_at": int(time.time()), "products": rows}
    with open(path, "a", encoding="utf-8") as handle:
        handle.write(json.dumps(record, ensure_ascii=False) + "\n")
    return record

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

चरण 5 — भिन्नता और सिफारिश का हिस्सा रिपोर्ट करें

दो पढ़ने वाली फ़ंक्शन स्नैपशॉट इतिहास को मेट्रिक्स में बदल देते हैं। सिफारिश का हिस्सा गिनता है कि प्रत्येक ब्रांड कितनी बार एक रन में प्रकट होता है और इसे प्रतिशत में सामान्यीकृत करता है; भिन्नता दो रन की ASIN सेटों की तुलना करती है।

from collections import Counter


def share_of_recommendation(rows: list[dict]) -> dict[str, float]:
    counts = Counter(row["brand"] for row in rows if row.get("brand"))
    total = sum(counts.values())
    if not total:
        return {}
    return {brand: round(100 * n / total, 1) for brand, n in counts.most_common()}


def diff_runs(prev_rows: list[dict], curr_rows: list[dict]) -> dict[str, list[str]]:
    prev = {row["asin"] for row in prev_rows}
    curr = {row["asin"] for row in curr_rows}
    return {
        "entered": sorted(curr - prev),
        "dropped": sorted(prev - curr),
    }

share_of_recommendation को प्रत्येक क्वेरी के लिए चलाएं ताकि आप देख सकें कि कौन से ब्रांड उस प्रश्न के लिए बातचीत की शेल्फ पर हैं, या एक श्रेणी-व्यापी दृश्य के लिए पूरे क्वेरी सेट में। किसी क्वेरी की दो हाल की स्नैपशॉट्स के बीच diff_runs चलाकर यह पता लगाएँ कि कब एक ब्रांड चुनाव में आया या बाहर गया - वह क्षण जिसे अलर्ट करने योग्य है।

अनुसूची और स्केलिंग

कैप्चर लूप चरणों को जोड़ता है: प्रत्येक क्वेरी के लिए, कैप्चर, निष्कर्षण, स्नैपशॉट और खाली परिणाम को एक स्किप के रूप में रिकॉर्ड करें। इसे एक अनुसूची पर चलाएं - दैनिक या साप्ताहिक - और JSONL फ़ाइल समय श्रृंखला बन जाती है।

if __name__ == "__main__":
    snapshot_path = "rufus_snapshots.jsonl"
    for query in SEED_QUERIES:
        result = capture_rufus(query)
        rows = extract_products(result)
        if not rows:
            print(f"{query}: इस क्वेरी/क्षेत्र के लिए कोई रुफस उत्तर नहीं है")
            continue
        append_snapshot(snapshot_path, query, rows)
        share = share_of_recommendation(rows)
        leaders = ", ".join(f"{b} {pct}%" for b, pct in list(share.items())[:3])
        print(f"{query}: {len(rows)} उत्पाद — {leaders}")

जब आप क्वेरी सेट को स्केल करते हैं, तो कुछ व्यावहारिक सीमाएँ:

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

आपको क्या वापस मिलता है

प्रत्येक कैप्चर फ्लैट products सूची और अनुभाग-समूहित content_blocks प्रदान करता है; पाइपलाइन दोनों को स्नैपशॉट पंक्तियों और एक हिस्से की तालिका में कम कर देती है। नीचे की आकृति वही है जो अभिनेता लौटाता है, एक अनुभाग के लिए ट्रिम की गई है।

// Schema वह है जो scraper.amazon (प्रकार: रुफस) लौटाता है; फ़ील्ड मान एक लाइव रन से उदाहरणात्मक नमूना हैं (अनुभाग और उत्पादों को ट्रिम किया गया)।
{
  "metadata": { "type": "rufus", "rawUrl": "https://…" },
  "result": {
    "user_query": "सर्वश्रेष्ठ शोर रद्द करने वाले हेडफ़ोन",
    "content_blocks": [
      {
        "type": "product_section",
        "category": "शीर्ष पसंद – बेहतरीन एएनसी",
Here is the translated text in Hindi:

```json
"उत्पाद": [
          {
            "असिन": "B0GN4CFF6H",
            "शीर्षक": "Sony WH-1000XM6/B वायरलेस नॉइस कैंसलिंग हेडफ़ोन",
            "कीमत": "$398.00",
            "मूल कीमत": "$428.00",
            "रेटिंग": "4.5",
            "समीक्षाएँ": "238",
            "डिलिवरी": "मुफ्त डिलिवरी शुक्रवार, 19 जून",
            "यूआरएल": "https://…"
          }
        ]
      }
    ],
    "उत्पाद": [
      { "असिन": "B0GN4CFF6H", "शीर्षक": "Sony WH-1000XM6/B …", "श्रेणी": "शीर्ष चयन - सर्वश्रेष्ठ एएनसी" }
    ],
    "संबंधित प्रश्न": ["Sony XM6 बनाम Bose QC Ultra 2 की तुलना करें", "क्या इनमें से कोई बिक्री पर है?"]
  }
}

After Stages 3–5, one snapshot record and its share table look like this:

// पाइपलाइन आउटपुट — चित्रणात्मक नमूना (स्कीमा वास्तविक, असिन/ब्रांड/रैंक मान चित्रणात्मक): एक अपेंड-ओनली स्नैपशॉट पंक्ति plus सिफारिश साझा तालिका।
{
  "स्नैपशॉट": {
    "पूछताछ": "सर्वश्रेष्ठ नॉइस कैंसलिंग हेडफ़ोन",
    "कैप्चर किया गया": 1781716376,
    "उत्पाद": [
      { "असिन": "B0GN4CFF6H", "रैंक": 1, "खंड": "शीर्ष चयन - सर्वश्रेष्ठ एएनसी", "ब्रांड": "Sony" },
      { "असिन": "B0FDKR293G", "रैंक": 2, "खंड": "शीर्ष चयन - सर्वश्रेष्ठ एएनसी", "ब्रांड": "Bose" },
      { "असिन": "B0GSS4SGZR", "रैंक": 3, "खंड": "एप्पल उपयोगकर्ताओं के लिए सर्वश्रेष्ठ", "ब्रांड": "Apple" }
    ]
  },
  "सिफारिश का साझा": { "Sony": 33.3, "Bose": 33.3, "Apple": 33.3 }
}

कुछ ईमानदार टिप्पणियां इसे चलाने से:

• उत्तर प्रति सत्र है। एक ही प्रश्न एक रन से दूसरे रन तक विभिन्न सिफारिश सेट और विभिन्न संबंधित प्रश्न लौटाता है। हर रिकॉर्ड पर कैप्चर किया गया स्टोर करें; समय में श्रृंखला संकेत है, कोई एकल कैप्चर नहीं।
• खंड रैंक को फ्रेम करता है। एक उत्पाद का खंड (सामग्री_ब्लॉक[].श्रेणी) यह बताता है कि वह कहां क्यों रैंक किया गया — "एप्पल उपयोगकर्ताओं के लिए सबसे अच्छा" "महान मूल्य चयन" से अलग अलमारी है। खंड को ले जाएं, केवल स्थिति नहीं।
• क्षेत्र मान शून्य हैं। खरीदा, मूल कीमत, और डिलिवरी कुछ उत्पादों पर प्रकट होते हैं और अन्य पर नहीं; एक आधे-समाधान स्लॉट बिना शीर्षक या असिन के आ सकता है। प्रत्येक को .get() के साथ पढ़ें और खाली स्टोर करने के बजाय पंक्ति को छोड़ दें।
• क्षेत्र तय करता है कि क्या वहां कोई उत्तर है। एक असमर्थित स्टोर उत्पादों के बजाय एक क्षेत्र विफलता लौटाता है। उस क्षेत्र को सुनिश्चित करें जिसे आप मॉनिटर करते हैं और छोड़े गए उत्तर को स्किप के रूप में रिकॉर्ड करें।

इसे जिम्मेदारी से संभालना

यह पाइपलाइन केवल सार्वजनिक उत्पाद सिफारिशें पढ़ती है जो रुफ़स किसी भी खरीदार को दिखाती है — असिन, शीर्षक, कीमत, रेटिंग, और खंड लेबल। इसे उसी सार्वजनिक सतह पर रखें: कोई व्यक्तिगत डेटा एकत्र न करें और न ही खाता-गेटेड सामग्री, अमेज़न की सेवा की शर्तों और रोबोट निर्देशों का सम्मान करें, और केवल उत्पाद क्षेत्रों को स्टोर करें जिनकी निगरानी कार्यक्रम को आवश्यकता है। सिफारिश का साझा एक ब्रांड-विशVisibility मीट्रिक है जो सार्वजनिक लिस्टिंग से बनाई जाती है, बस इतना ही।

निष्कर्ष: समय श्रृंखला के रूप में संवादात्मक शेल्फ

अमेज़न रुफ़स की निगरानी एक लूप में घटित होती है: scraper.amazon अभिनेता के खिलाफ प्रत्येक प्रश्न को कैप्चर करें जिसमें प्रकार: रुफ़स, सामग्री_ब्लॉक से असिन, रैंक से लेकर खंड तक निकालें, प्रत्येक असिन को एक ब्रांड से मैप करें, प्रति-रन स्नैपशॉट जोड़ें, और सिफारिश के हिस्से के लिए स्नैपशॉट में अंतर करें। क्षेत्र को पिन करें, प्रत्येक फ़ील्ड को मान शून्य के रूप में व्यवहार करें, एक गुम उत्तर को स्किप के रूप में रिकॉर्ड करें, और संबंधित प्रश्न को प्रश्न सेट बढ़ाने दें। वही निगरानी आकार अन्य उत्तर सतहों पर लागू होता है — रुफ़स को Google के AI ओवरव्यूज़ को स्क्रैपिंग के साथ मिलाना दोनों शॉपिंग सहायक और खोज के लिए एक कार्यक्रम देता है। यहाँ अभिनेता, अंतिम बिंदु, और फ़ील्ड नाम लाइव Scrapeless स्क्रैपिंग API संदर्भ के खिलाफ पुष्टि की गई हैं।

क्या आप अपने AI-सिफारिश निगरानी पाइपलाइन बनाने के लिए तैयार हैं?

हमारे समुदाय में शामिल हों मुफ्त योजना का दावा करने और ऐसे डेवलपर्स से जुड़ने के लिए जो AI-उत्तर डेटा पाइपलाइनों का निर्माण कर रहे हैं: Discord · Telegram.

app.scrapeless.com पर मुफ्त ट्रायल क्रेडिट के लिए साइन अप करें और ऊपर दिए गए प्रश्न सेट को रुफ़स श्रेणियों और क्षेत्रों की ओर इंगित करें जिन्हें आपका ब्रांड-विशVisibility कार्यक्रम ट्रैक करता है।

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

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

प्रश्न: एक प्रश्न ने रुफ़स जवाब क्यों नहीं लौटाया?

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

**प्रश्न: क्या मुझे एक प्रॉक्सी या ब्राउज़र की आवश्यकता है?**
नहीं। रेंडरिंग, क्षेत्र प्रबंधन और पार्सिंग सर्वर-साइड पर चलती हैं। आप एक `x-api-token` हेडर के साथ एक POST भेजते हैं और JSON वापस पढ़ते हैं; अभिनेता पहले से संरचित सिफारिश सेट लौटाता है।

**प्रश्न: मैं एक उत्पाद का रैंक और वह अनुभाग कैसे प्राप्त कर सकता हूँ जिसमें वह दिखाई दिया?**
`result.content_blocks` पर चलें: प्रत्येक `product_section` ब्लॉक एक `category` शीर्षक और इसका अपना `products` ऐरे रखता है। जब आप ब्लॉकों को फ्लैट करते हैं तो उत्पादों की गिनती कुल रैंक देती है, और ब्लॉक की `category` अनुभाग देती है — दोनों को स्नैपशॉट प्रति स्टोर करना लाभकारी है।

**प्रश्न: सिफारिश का हिस्सा क्या है?**
यह सिफारिश किए गए स्लॉटों का प्रतिशत है जो एक क्वेरी या क्वेरी सेट के पार एक ब्रांड द्वारा ग्रहण किया जाता है, जो कैप्चर किए गए उत्पादों से एकत्रित होता है। समय के साथ देखा जाए, यह दर्शाता है कि कोई ब्रांड रुफस शेल्फ पर उपस्थिति प्राप्त कर रहा है या खो रहा है - यह बातचीत-खरीद के समकक्ष वॉयस का हिस्सा है।

**प्रश्न: एकल वर्तमान दृश्य के बजाय स्नैपशॉट क्यों स्टोर करें?**
रुफस अपने उत्तर को प्रति सत्र उत्पन्न करता है, इसलिए कोई भी एक कैप्चर एक समय बिंदु है। प्रश्न और कैप्चर समय द्वारा की गई केवल-ऐपेंड स्नैपशॉट्स आपको अंतर करने के लिए इतिहास देती हैं, ताकि आप रिपोर्ट कर सकें कि कौन से ASINs दो रन के बीच में शामिल हुए या छोड़ दिए गए, न कि एकल प्रतिक्रिया से अनुमान लगाकर।

**प्रश्न: मैं एक साथ कितने प्रश्नों की निगरानी कर सकता हूँ?**
सह-समवर्तीता को मध्यम रखें - उड़ान में एक मुट्ठी भर प्रश्न स्थिर निगरानी रन के लिए पर्याप्त है। सेट को उन प्रश्नों तक सीमित करें जिन पर आप कार्य करते हैं और `related_questions` को सुझाव देने दें कि अगला क्या जोड़ना है, ताकि प्रत्येक बिल योग्य कॉल को उसका स्थान मिल सके।