Gibt es eine Amazon.com-API zum Abrufen von Produktbewertungen?

Bietet eine der AWS-APIs / -Dienste Zugriff auf die Produktbewertungen für von Amazon verkaufte Artikel? Ich bin daran interessiert, Bewertungen von (ASIN, user_id) tuple nachzuschlagen. Ich kann sehen, dass die Produktwerbe-API eine URL zu einer Seite (zum Einbetten in einen IFRAME) zurückgibt, die die URLs enthält, aber ich bin nach Möglichkeit an einem maschinenlesbaren Format der Überprüfungsdaten interessiert.

Update 2:

Bitte lesen Sie den Kommentar von @ jpillora. Es ist wahrscheinlich das relevanteste in Bezug auf Update 1 .

Ich habe gerade die Produktwerbe-API ausprobiert (Stand: 17.09.2014). Es scheint, dass diese API nur eine URL zurückgibt, die auf einen Iframe verweist, der nur die Bewertungen enthält. Ich denke, Sie müssten Bildschirmkratzer machen - obwohl ich mir vorstelle, dass dies die Nutzungsbedingungen von Amazon brechen würde.

Update 1:

Könnte sein. Ich habe die ursprüngliche Antwort unten geschrieben. Ich habe momentan keine Zeit, mich damit zu befassen, da ich mich nicht mehr mit einem Projekt befasse, das sich mit Amazon-Bewertungen befasst. Auf der Webseite der Product Advertising API heißt es jedoch: "Mit der Product Advertising API können Sie Amazon-Produkte mithilfe der Produktsuche bewerben und nachschlagen Funktionen, Produktinformationen und Funktionen wie Kundenrezensionen ... "Stand 08.12.2011. Ich hoffe also, jemand schaut sich das an und schreibt hier zurück. Fühlen Sie sich frei, diese Antwort zu bearbeiten.

Original:

Nee.

Hier ist eine interessante Diskussion im Forum über die Tatsache, einschließlich Theorien darüber, warum: http://forums.digitalpoint.com/showthread.php?t=1932326

Wenn ich falsch liege, poste bitte, was du findest. Ich bin daran interessiert, den Inhalt der Bewertungen zu erhalten und wenn möglich die Übermittlung von Bewertungen an Amazon zu ermöglichen.

Vielleicht möchten Sie diesen Link überprüfen: http://reviewazon.com/ . Ich bin nur darauf gestoßen und habe mich nicht damit befasst, aber ich bin überrascht, dass ich auf ihrer Website keine Erwähnung über das Update bezüglich des Abbruchs von Bewertungen aus der Amazon Products Advertising API sehe, die unter folgender Adresse veröffentlicht wird: https: // Affiliate -program.amazon.com/gp/advertising/api/detail/main.html

Hier ist meine kurze Sicht darauf - Sie können die Bewertungen mit etwas mehr Arbeit ganz einfach selbst abrufen:

countries=['com','co.uk','ca','de']
books=[
        '''http://www.amazon.%s/Glass-House-Climate-Millennium-ebook/dp/B005U3U69C''',
        '''http://www.amazon.%s/The-Japanese-Observer-ebook/dp/B0078FMYD6''',
        '''http://www.amazon.%s/Falling-Through-Water-ebook/dp/B009VJ1622''',
      ]
import urllib2;
for book in books:
    print '-'*40
    print book.split('%s/')[1]
    for country in countries:
        asin=book.split('/')[-1]; title=book.split('/')[3]
        url='''http://www.amazon.%s/product-reviews/%s'''%(country,asin)
        try: f = urllib2.urlopen(url)
        except: page=""
        page=f.read().lower(); print '%s=%s'%(country, page.count('member-review'))
print '-'*40

Gemäß der Amazon Product Advertising API-Lizenzvereinbarung ( https://affiliate-program.amazon.com/gp/advertising/api/detail/agreement.html ) und insbesondere Punkt 4.b.iii:

Sie verwenden nur Produktwerbeinhalte ..., um Endbenutzer an die Amazon-Website zu senden und deren Umsatz zu steigern.

Dies bedeutet, dass es Ihnen untersagt ist, Amazon-Produktbewertungen anzuzeigen, die über die API zum Verkauf von Produkten auf Ihrer Website erstellt wurden. Es ist nur erlaubt, Ihre Website-Besucher zu Amazon umzuleiten und die Partnerprovisionen zu erhalten.

Ich würde so etwas wie die Antwort von @mfs oben verwenden. Leider funktioniert seine Antwort nur für bis zu 10 Bewertungen, da dies das Maximum ist, das auf einer Seite angezeigt werden kann.

Sie können den folgenden Code berücksichtigen:

import requests

nreviews_re = {'com': re.compile('\d[\d,]+(?= customer review)'), 
               'co.uk':re.compile('\d[\d,]+(?= customer review)'),
               'de': re.compile('\d[\d\.]+(?= Kundenrezens\w\w)')}
no_reviews_re = {'com': re.compile('no customer reviews'), 
                 'co.uk':re.compile('no customer reviews'),
                 'de': re.compile('Noch keine Kundenrezensionen')}

def get_number_of_reviews(asin, country='com'):                                 
    url = 'http://www.amazon.{country}/product-reviews/{asin}'.format(country=country, asin=asin)
    html = requests.get(url).text
    try:
        return int(re.compile('\D').sub('',nreviews_re[country].search(html).group(0)))
    except:
        if no_reviews_re[country].search(html):
            return 0
        else:
            return None  # to distinguish from 0, and handle more cases if necessary

Wenn ich dies mit 1433524767 (mit einer signifikant unterschiedlichen Anzahl von Bewertungen für die drei Länder von Interesse) ausführe, bekomme ich:

>> print get_number_of_reviews('1433524767', 'com')
3185
>> print get_number_of_reviews('1433524767', 'co.uk')
378
>> print get_number_of_reviews('1433524767', 'de')
16

Ich hoffe es hilft

Wie bereits von anderen oben erwähnt, hat amazon die Bereitstellung von Bewertungen in seiner API eingestellt. Ich fand jedoch dieses nette Tutorial, um dasselbe mit Python zu tun. Hier ist der Code, den er gibt, funktioniert für mich! Er benutzt Python 2.7

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Written as part of https://www.scrapehero.com/how-to-scrape-amazon-product-reviews-using-python/      
from lxml import html  
import json
import requests
import json,re
from dateutil import parser as dateparser
from time import sleep

def ParseReviews(asin):
    #This script has only been tested with Amazon.com
    amazon_url  = 'http://www.amazon.com/dp/'+asin
    # Add some recent user agent to prevent amazon from blocking the request 
    # Find some chrome user agent strings  here https://udger.com/resources/ua-list/browser-detail?browser=Chrome
    headers = {'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.90 Safari/537.36'}
    page = requests.get(amazon_url,headers = headers).text

    parser = html.fromstring(page)
    XPATH_AGGREGATE = '//span[@id="acrCustomerReviewText"]'
    XPATH_REVIEW_SECTION = '//div[@id="revMHRL"]/div'
    XPATH_AGGREGATE_RATING = '//table[@id="histogramTable"]//tr'
    XPATH_PRODUCT_NAME = '//h1//span[@id="productTitle"]//text()'
    XPATH_PRODUCT_PRICE  = '//span[@id="priceblock_ourprice"]/text()'

    raw_product_price = parser.xpath(XPATH_PRODUCT_PRICE)
    product_price = ''.join(raw_product_price).replace(',','')

    raw_product_name = parser.xpath(XPATH_PRODUCT_NAME)
    product_name = ''.join(raw_product_name).strip()
    total_ratings  = parser.xpath(XPATH_AGGREGATE_RATING)
    reviews = parser.xpath(XPATH_REVIEW_SECTION)

    ratings_dict = {}
    reviews_list = []

    #grabing the rating  section in product page
    for ratings in total_ratings:
        extracted_rating = ratings.xpath('./td//a//text()')
        if extracted_rating:
            rating_key = extracted_rating[0] 
            raw_raing_value = extracted_rating[1]
            rating_value = raw_raing_value
            if rating_key:
                ratings_dict.update({rating_key:rating_value})

    #Parsing individual reviews
    for review in reviews:
        XPATH_RATING  ='./div//div//i//text()'
        XPATH_REVIEW_HEADER = './div//div//span[contains(@class,"text-bold")]//text()'
        XPATH_REVIEW_POSTED_DATE = './/a[contains(@href,"/profile/")]/parent::span/following-sibling::span/text()'
        XPATH_REVIEW_TEXT_1 = './/div//span[@class="MHRHead"]//text()'
        XPATH_REVIEW_TEXT_2 = './/div//span[@data-action="columnbalancing-showfullreview"]/@data-columnbalancing-showfullreview'
        XPATH_REVIEW_COMMENTS = './/a[contains(@class,"commentStripe")]/text()'
        XPATH_AUTHOR  = './/a[contains(@href,"/profile/")]/parent::span//text()'
        XPATH_REVIEW_TEXT_3  = './/div[contains(@id,"dpReviews")]/div/text()'
        raw_review_author = review.xpath(XPATH_AUTHOR)
        raw_review_rating = review.xpath(XPATH_RATING)
        raw_review_header = review.xpath(XPATH_REVIEW_HEADER)
        raw_review_posted_date = review.xpath(XPATH_REVIEW_POSTED_DATE)
        raw_review_text1 = review.xpath(XPATH_REVIEW_TEXT_1)
        raw_review_text2 = review.xpath(XPATH_REVIEW_TEXT_2)
        raw_review_text3 = review.xpath(XPATH_REVIEW_TEXT_3)

        author = ' '.join(' '.join(raw_review_author).split()).strip('By')

        #cleaning data
        review_rating = ''.join(raw_review_rating).replace('out of 5 stars','')
        review_header = ' '.join(' '.join(raw_review_header).split())
        review_posted_date = dateparser.parse(''.join(raw_review_posted_date)).strftime('%d %b %Y')
        review_text = ' '.join(' '.join(raw_review_text1).split())

        #grabbing hidden comments if present
        if raw_review_text2:
            json_loaded_review_data = json.loads(raw_review_text2[0])
            json_loaded_review_data_text = json_loaded_review_data['rest']
            cleaned_json_loaded_review_data_text = re.sub('<.*?>','',json_loaded_review_data_text)
            full_review_text = review_text+cleaned_json_loaded_review_data_text
        else:
            full_review_text = review_text
        if not raw_review_text1:
            full_review_text = ' '.join(' '.join(raw_review_text3).split())

        raw_review_comments = review.xpath(XPATH_REVIEW_COMMENTS)
        review_comments = ''.join(raw_review_comments)
        review_comments = re.sub('[A-Za-z]','',review_comments).strip()
        review_dict = {
                            'review_comment_count':review_comments,
                            'review_text':full_review_text,
                            'review_posted_date':review_posted_date,
                            'review_header':review_header,
                            'review_rating':review_rating,
                            'review_author':author

                        }
        reviews_list.append(review_dict)

    data = {
                'ratings':ratings_dict,
                'reviews':reviews_list,
                'url':amazon_url,
                'price':product_price,
                'name':product_name
            }
    return data


def ReadAsin():
    #Add your own ASINs here 
    AsinList = ['B01ETPUQ6E','B017HW9DEW']
    extracted_data = []
    for asin in AsinList:
        print "Downloading and processing page http://www.amazon.com/dp/"+asin
        extracted_data.append(ParseReviews(asin))
        sleep(5)
    f=open('data.json','w')
    json.dump(extracted_data,f,indent=4)

if __name__ == '__main__':
    ReadAsin()

Hier ist der Link zu seiner Website Bewertungen Scraping mit Python 2.7

Leider können Sie nur eine Iframe-URL mit den Bewertungen erhalten, der Inhalt selbst ist nicht zugänglich.

Quelle: http://docs.amazonwebservices.com/AWSECommerceService/2011-08-01/DG/CHAP_MotivatingCustomerstoBuy.html#GettingCustomerReviews

Es gibt APIs von Drittanbietern, die von Überprüfungsüberwachungstools angeboten werden. Eine davon ist die FeedCheck Review Monitoring API .

Sie können die Amazon Product Advertising API verwenden. Es verfügt über eine Antwortgruppe 'Reviews', die Sie mit der Operation 'ItemLookup' verwenden können. Sie müssen ASIN kennen, dh die eindeutige Artikel-ID des Produkts.

Sobald Sie alle Parameter festgelegt und die signierte URL ausgeführt haben, erhalten Sie eine XML-Datei, die einen Link zu Kundenbewertungen unter dem Tag "IFrameURL" enthält.

Verwenden Sie diese URL und verwenden Sie die Mustersuche in HTML, die von dieser URL zurückgegeben wird, um die Bewertungen zu extrahieren. Für jede Überprüfung im HTML gibt es eine eindeutige Überprüfungs-ID, unter der Sie alle Daten für diese bestimmte Überprüfung abrufen können.