इस कोड से सभी पेड प्लान पर 20 % छूट

Python · Amazon

Python से Amazon की कीमतें ट्रैक करें

Amazon पर कीमतें लगातार बदलती रहती हैं, और कोई भी हर सुबह एक ही प्रोडक्ट पेज खोलना नहीं चाहता। इस गाइड में आप एक छोटी स्क्रिप्ट बनाएँगे जो यह काम आपके लिए करती है: यह आपके चुने प्रोडक्ट की मौजूदा कीमत देखती है, हर जाँच को स्प्रेडशीट में खुलने लायक फ़ाइल में लिखती है, और जब कीमत उस राशि से नीचे जाती है जो आप देने को तैयार हैं, तो आपको बताती है।

आपको ख़ुद Amazon पेज से नहीं जूझना पड़ता। everydata.io आपके लिए लाइव प्रोडक्ट पेज लोड करता है और साफ़ डेटा लौटाता है – टाइटल, कीमत, मुद्रा, उपलब्धता – इसलिए स्क्रिप्ट छोटी रहती है और Amazon के लेआउट बदलने पर टूटती नहीं।

अपडेट: · everydata.io द्वारा

आख़िर में आपके पास क्या होगा

  • एक स्क्रिप्ट जो Amazon प्रोडक्ट की एक लिस्ट जाँचती है और हर कीमत prices.csv में जोड़ती है।
  • कीमत गिरने या आपके टारगेट तक पहुँचने पर एक मैसेज।
  • एक दैनिक शेड्यूल, ताकि यह आपके बिना चले।

आपको क्या चाहिए

  • Python 3.10 या नया और requests पैकेज (pip install requests)।
  • everydata.io की फ़्री API key – यहाँ बनाएँ।
  • हर प्रोडक्ट का ASIN: Amazon पते में /dp/ के बाद वाला 10 अक्षरों का कोड।

01अपनी API key को कोड से बाहर रखें

साइन इन करें, डैशबोर्ड से अपनी key कॉपी करें और उसे एक environment variable में डालें। स्क्रिप्ट उसे वहीं से पढ़ती है, इसलिए key कभी ऐसी फ़ाइल में नहीं पहुँचती जिसे आप शायद शेयर करें।

terminal
export EVERYDATA_API_KEY="ds_your_key"

02एक प्रोडक्ट लुकअप करें

एक अकेली रिक्वेस्ट से शुरू करें, ताकि आप देख सकें कि क्या लौटता है। product-by-ASIN endpoint, ASIN और मार्केटप्लेस लेता है (amazon.com के लिए com, amazon.de के लिए de आदि)।

first_request.py
import os

import requests

API = "https://api.everydata.io"
KEY = os.environ["EVERYDATA_API_KEY"]

resp = requests.get(
    f"{API}/amz/amazon-lookup-product-by-asin",
    params={"asin": "B07ZPKN6YR", "domainCode": "com"},
    headers={"x-api-key": KEY},
    timeout=60,
)
resp.raise_for_status()
product = resp.json()

print(product["productTitle"])
print(product["price"], product["currency"], "-", product["warehouseAvailability"])

जवाब JSON है। हर रिस्पॉन्स responseStatus और responseMessage से शुरू होता है, फिर प्रोडक्ट आता है। यह डॉक्यूमेंटेड उदाहरण का छोटा रूप है:

उदाहरण रिस्पॉन्स · GET /amz/amazon-lookup-product-by-asin
{
  "responseStatus": "PRODUCT_FOUND_RESPONSE",
  "responseMessage": "Product successfully found!",
  "productTitle": "Apple iPhone 11, 64GB, Black - Unlocked (Renewed)",
  "productRating": "4.2 out of 5 stars",
  "countReview": 60024,
  "asin": "B07ZPKN6YR",
  "warehouseAvailability": "This item cannot be shipped to your selected delivery location. Please choose a different delivery location.",
  "retailPrice": 0,
  "price": 0,
  "currency": "USD"
}

इस उदाहरण में price देखें: यह 0 है। ऐसा तब होता है जब पेज पर कोई ख़रीदने लायक कीमत नहीं दिखती – यहाँ इसलिए कि आइटम डिलीवरी लोकेशन पर शिप नहीं हो सकता था। आपकी स्क्रिप्ट को 0 को “अभी कोई कीमत नहीं” मानना चाहिए, मुफ़्त प्रोडक्ट नहीं।

03प्रोडक्ट की लिस्ट जाँचें और हर नतीजा सेव करें

अब अकेली रिक्वेस्ट को एक छोटे ट्रैकर में बदलें। WATCHLIST में प्रोडक्ट और वह कीमत होती है जिसका आप इंतज़ार कर रहे हैं। हर रन हर प्रोडक्ट को एक बार लुकअप करता है, prices.csv में एक पंक्ति जोड़ता है और नई कीमत की तुलना आख़िरी सेव की गई कीमत से करता है।

track.py
"""Check the price of a few Amazon products and append each check to prices.csv."""
import csv
import os
import re
import time
from datetime import datetime, timezone
from pathlib import Path

import requests

API = "https://api.everydata.io"
KEY = os.environ["EVERYDATA_API_KEY"]
CSV_FILE = Path("prices.csv")
DOMAIN = "com"  # amazon.com – use "de", "co.uk", "fr" … for other marketplaces

# ASIN -> the price at which you want to hear about it
WATCHLIST = {
    "B07ZPKN6YR": 30.00,
}


def api_get(path: str, params: dict) -> dict:
    """GET an everydata.io endpoint. Waits when rate limited (429) and retries a failed page load (5xx) once."""
    retried = False
    for _ in range(4):
        resp = requests.get(f"{API}{path}", params=params, headers={"x-api-key": KEY}, timeout=60)
        if resp.status_code == 429:
            # Too many requests at once. The answer says how long to wait: "... Try again in 12 seconds."
            wait = re.search(r"in (\d+) seconds", resp.text)
            time.sleep(int(wait.group(1)) + 1 if wait else 60)
            continue
        if resp.status_code >= 500 and not retried:
            retried = True  # 5xx answers are not counted against your quota
            time.sleep(10)
            continue
        resp.raise_for_status()  # 4xx (wrong key, quota used up, bad parameter) or a second 5xx
        return resp.json()
    raise RuntimeError("still rate limited after several waits – try again later")


def last_price(asin: str) -> float | None:
    """The most recent price we saved for this ASIN, if any."""
    if not CSV_FILE.exists():
        return None
    with CSV_FILE.open(newline="") as f:
        rows = [r for r in csv.DictReader(f) if r["asin"] == asin and r["price"]]
    return float(rows[-1]["price"]) if rows else None


def main() -> None:
    previous = {asin: last_price(asin) for asin in WATCHLIST}
    now = datetime.now(timezone.utc).isoformat(timespec="seconds")
    new_file = not CSV_FILE.exists()

    with CSV_FILE.open("a", newline="") as f:
        writer = csv.writer(f)
        if new_file:
            writer.writerow(["checked_at", "asin", "title", "price", "retail_price", "currency", "availability"])

        for asin, target in WATCHLIST.items():
            try:
                p = api_get("/amz/amazon-lookup-product-by-asin", {"asin": asin, "domainCode": DOMAIN})
            except (requests.RequestException, RuntimeError) as exc:
                print(f"{asin}: could not check this time ({exc}) – the next run tries again")
                continue  # one failed product does not stop the others
            price = p.get("price") or None  # 0 means the page showed no price
            writer.writerow([
                now, asin, p.get("productTitle"), price or "", p.get("retailPrice") or "",
                p.get("currency") or "", p.get("warehouseAvailability") or "",
            ])

            if price is None:
                print(f"{asin}: no price on the page ({p.get('warehouseAvailability')})")
            elif price <= target:
                print(f"{asin}: {price} {p.get('currency')} – at or below your target of {target}")
            elif previous[asin] is not None and price < previous[asin]:
                print(f"{asin}: dropped from {previous[asin]} to {price} {p.get('currency')}")


if __name__ == "__main__":
    main()

इसे python3 track.py से चलाएँ। पहला रन फ़ाइल बनाता है; बाद के रन हर प्रोडक्ट के लिए एक पंक्ति जोड़ते हैं। प्राइस चार्ट बनाने के लिए आप prices.csv को किसी भी स्प्रेडशीट प्रोग्राम में खोल सकते हैं।

api_get उन दो जवाबों को संभालता है जो देर-सवेर आपको मिलेंगे। अगर कोई पेज लोड नहीं हो पाता, तो API 502 या 503 जैसे 5xx स्टेटस से जवाब देता है; ये जवाब आपके quota में नहीं गिने जाते, इसलिए स्क्रिप्ट कुछ सेकंड रुककर एक बार फिर कोशिश करती है। अगर आप एक साथ बहुत ज़्यादा रिक्वेस्ट भेजते हैं, तो जवाब 429 होता है और बताता है कि कितने सेकंड रुकना है – स्क्रिप्ट उतना रुकती है और आगे बढ़ती है। जो प्रोडक्ट फिर भी विफल हो, उसकी रिपोर्ट होती है और उसे छोड़ दिया जाता है, और अगला रन उसे फिर उठा लेता है।

04तय करें कि आप सूचना कैसे पाना चाहते हैं

स्क्रिप्ट तीन मामलों में एक लाइन प्रिंट करती है: पेज पर कोई कीमत नहीं है, कीमत आपके टारगेट पर या उससे नीचे है, या पिछली जाँच के बाद से गिरी है। अगर आप लॉग पढ़ते हैं तो प्रिंट करना काफ़ी है। अगर आप मैसेज पाना पसंद करें, तो तीनों print कॉल को उससे बदल दें जो आप पहले से इस्तेमाल करते हैं – Python के smtplib से ईमेल, चैट webhook या कोई push सेवा।

05इसे हर दिन चलाएँ

चालू रहने वाली Mac या Linux मशीन पर cron सबसे आसान scheduler है। यह लाइन ट्रैकर को हर सुबह 7:00 बजे चलाती है और एक लॉग रखती है:

crontab
# Every day at 07:00 – edit with: crontab -e
0 7 * * * cd /home/you/price-tracker && EVERYDATA_API_KEY=ds_your_key /usr/bin/python3 track.py >> track.log 2>&1

Windows पर Task Scheduler यही काम करता है। कोई भी छोटा सर्वर या शेड्यूल किया गया CI जॉब भी काम करता है।

हर प्रोडक्ट जाँच एक रिक्वेस्ट है। उदाहरण के लिए: दिन में एक बार जाँचे जाने वाले तीन प्रोडक्ट हर महीने लगभग 90 रिक्वेस्ट हैं, जो 100 रिक्वेस्ट वाले फ़्री प्लान में आ जाती हैं। ज़्यादा प्रोडक्ट या दिन में ज़्यादा जाँच के लिए प्राइसिंग देखें।

06वैकल्पिक: everydata.io के पास पहले से मौजूद मूल्य इतिहास पढ़ें

everydata.io से किया गया हर प्रोडक्ट लुकअप उस समय दिखी कीमत भी सेव करता है। price-history endpoint पिछले days दिनों के वे ऑब्ज़र्वेशन लौटाता है। यह सिर्फ़ उन प्रोडक्ट के बारे में जानता है जिन्हें किसी ने पहले लुकअप किया है, इसलिए जिस प्रोडक्ट को अभी तक किसी ने नहीं जाँचा उसकी लिस्ट ख़ाली होती है – आपकी अपनी CSV फ़ाइल ही भरोसेमंद रिकॉर्ड रहती है।

history.py
resp = requests.get(
    f"{API}/amz/amazon-price-history",
    params={"asin": "B07ZPKN6YR", "domainCode": "com", "days": 90},
    headers={"x-api-key": KEY},
    timeout=60,
)
data = resp.json()
print(data["count"], "observations")
for point in data["history"]:
    print(point["observedAt"], point["price"], point["inStock"])
उदाहरण रिस्पॉन्स · GET /amz/amazon-price-history
{
  "responseStatus": "PRODUCT_FOUND_RESPONSE",
  "responseMessage": "Product successfully found!",
  "asin": "B07ZPKN6YR",
  "domainCode": "com",
  "days": 90,
  "currency": "USD",
  "count": 2,
  "history": [
    {
      "observedAt": "2026-09-18T10:12:00Z",
      "price": 39.99,
      "retailPrice": 49.99,
      "inStock": true
    },
    {
      "observedAt": "2026-09-19T09:40:00Z",
      "price": 34.99,
      "retailPrice": 49.99,
      "inStock": true
    }
  ]
}

इस गाइड में इस्तेमाल किए गए endpoints

GET/amz/amazon-lookup-product-by-asin

Product Details by ASIN · Amazon API

GET/amz/amazon-price-history

Price History (observations collected by this API) · Amazon API

API रेफ़रेंस में सभी पैरामीटर

अपने डेटा के साथ आज़माएँ

फ़्री प्लान में हर महीने 100 रिक्वेस्ट शामिल हैं, हर प्लेटफ़ॉर्म पर इस्तेमाल करने लायक – इस गाइड को शुरू से आख़िर तक फ़ॉलो करने के लिए काफ़ी।