Diese Seite wurde von der Cloud Translation API übersetzt.

Entwicklerleitfaden: Protokoll

Mit der Blogger Data API können Clientanwendungen Blogger-Inhalte in Form von Google Data API-Feeds abrufen und aktualisieren.

Ihre Clientanwendung kann die Blogger Data API verwenden, um neue Blogposts zu erstellen, vorhandene Blogposts zu bearbeiten oder zu löschen und nach Blogposts zu suchen, die bestimmten Kriterien entsprechen.

Neben Informationen zu den Möglichkeiten der Blogger Data API enthält dieses Dokument auch Beispiele für grundlegende Data API-Interaktionen mit XML und HTTPS. Nachdem Sie dieses Dokument gelesen haben, können Sie mehr über die Interaktion mit der API mithilfe unserer Clientbibliotheken erfahren. Lesen Sie dazu die Abschnitte zu den Programmiersprachen dieses Entwicklerhandbuchs.

Inhalt

Zielgruppe

Dieses Dokument richtet sich an Programmierer, die Client-Anwendungen schreiben möchten, die über XML und HTTPS mit Blogger interagieren können.

In diesem Dokument wird davon ausgegangen, dass Sie mit den allgemeinen Ideen hinter dem Google Data APIs-Protokoll vertraut sind.

Wenn Sie ein UNIX-System verwenden und die Beispiele in diesem Dokument ausprobieren möchten, ohne Code zu schreiben, könnten die UNIX-Befehlszeilendienstprogramme curl oder wget hilfreich sein. Weitere Informationen finden Sie auf den entsprechenden Seiten zu diesen Dienstprogrammen.

Referenzinformationen zur Blogger Data API finden Sie im Referenzleitfaden zum Protokoll.

Erste Schritte

Blogger-Konto erstellen

Du kannst dich auch für ein Blogger-Konto registrieren. Blogger verwendet Google-Konten. Wenn Sie also bereits ein Google-Konto haben, müssen Sie nichts weiter tun.

Anfragen autorisieren

Wenn Ihre Anwendung nicht öffentliche Nutzerdaten anfordert, muss sie ein Autorisierungstoken enthalten. Anhand dieses Tokens wird deine Anwendung Google gegenüber identifiziert.

Autorisierungsprotokolle

Wir empfehlen, für die Autorisierung von Anfragen OAuth 2.0 zu verwenden.

Die Blogger GData API unterstützt auch ältere Autorisierungsoptionen wie OAuth 1.0, AuthSub oder ClientLogin. In den meisten Fällen raten wir jedoch davon ab, diese anderen Optionen zu verwenden. Wenn Ihre Anwendung diese Optionen bereits verwendet, empfehlen wir, nach Möglichkeit zu OAuth 2.0 zu migrieren.

Wenn für Ihre Anwendung gewisse ungewöhnliche Autorisierungsanforderungen gelten, z. B. die gleichzeitige Anmeldung beim Datenabruf (hybrid) oder die domainweite Delegierung der Autorität (2LO), können Sie aktuell keine OAuth 2.0-Tokens verwenden. In diesen Fällen müssen stattdessen OAuth 1.0-Tokens verwendet werden.

Anfragen mit OAuth 2.0 autorisieren

Anfragen an die Blogger GData API für nicht öffentliche Nutzerdaten müssen von einem authentifizierten Nutzer autorisiert werden.

Die Details des Autorisierungsprozesses oder des Ablaufs für OAuth 2.0 variieren je nach Art der Anwendung, die Sie schreiben. Der folgende allgemeine Prozess gilt für alle Anwendungstypen:

Wenn Sie Ihre Anwendung erstellen, registrieren Sie sie bei Google. Google stellt dann die Informationen bereit, die Sie später benötigen, z. B. eine Client-ID und einen Clientschlüssel.
Wenn Ihre Anwendung Zugriff auf Nutzerdaten benötigt, wird Google nach einem bestimmten Umfang des Zugriffs gefragt.
Dem Nutzer wird ein OAuth-Dialogfeld angezeigt, in dem er gebeten wird, Ihre Anwendung dazu zu autorisieren, einige seiner Daten anzufordern.
Wenn der Nutzer zustimmt, erhält deine Anwendung von Google ein kurzlebiges Zugriffstoken.
Die Anwendung fordert Nutzerdaten an und hängt das Zugriffstoken an die Anfrage an.
Wenn Google feststellt, dass Ihre Anfrage und das Token gültig sind, werden die angeforderten Daten zurückgegeben.

Einige Abläufe umfassen zusätzliche Schritte, z. B. die Verwendung von Aktualisierungstokens, um neue Zugriffstokens zu erhalten. Ausführliche Informationen zu Abläufen für unterschiedliche Arten von Anwendungen finden Sie in der OAuth 2.0-Dokumentation von Google.

Hier finden Sie die Informationen zum OAuth 2.0-Bereich für die Blogger GData API:

https://www.blogger.com/feeds/

Zum Anfordern des Zugriffs mit OAuth 2.0 benötigt Ihre Anwendung die Informationen zum Geltungsbereich sowie die Informationen, die Google während der Anwendungsregistrierung zur Verfügung stellt (z. B. die Client-ID und/oder den Clientschlüssel).

Tipp:Die Google API-Clientbibliotheken können einen Teil des Autorisierungsprozesses für Sie übernehmen. Sie sind für verschiedene Programmiersprachen verfügbar. Weitere Informationen erhalten Sie auf der Seite Bibliotheken und Beispiele.

Version angeben

Jede Anfrage, die Sie über die Blogger Data API senden, sollte Version 2 der API angeben.

Verwenden Sie den HTTP-Header GData-Version, um eine Versionsnummer anzugeben:

GData-Version: 2

Wenn du HTTP-Header nicht festlegen kannst, hast du alternativ die Möglichkeit, v=2 als Abfrageparameter in der URL anzugeben. Der HTTP-Header wird nach Möglichkeit bevorzugt.

Hinweis: Da die Clientbibliotheken automatisch die entsprechenden Versionsheader bereitstellen, sollten Sie den Abfrageparameter v=2 nicht verwenden, wenn Sie eine Clientbibliothek verwenden.

Liste von Blogs abrufen

Die Blogger Data API bietet einen Feed, in dem die Blogs eines bestimmten Nutzers aufgelistet werden. Dieser Feed wird als Metametafeed bezeichnet.

Sende eine HTTP-GET an die folgende URL, um die Liste der Blogs abzurufen:

https://www.blogger.com/feeds/profileID/blogs

Dabei ist die Profil-ID die Nummer in der URL für die Profilseite des Nutzers.

Hinweis: Sie können default auch durch die Nutzer-ID ersetzen. Dadurch wird Blogger angewiesen, die Liste der Blogs für den Nutzer zurückzugeben, dessen Anmeldedaten die Anfrage enthalten.

Ein Eintrag im Metafeed könnte so aussehen:

<entry gd:etag='W/"D08FQn8-eip7ImA9WxZbFEw."'>
  <id>tag:blogger.com,1999:user-userNumber.blog-blogID</id>
  <published>2006-08-02T18:44:43.089-07:00</published>
  <updated>2008-04-17T00:03:33.152-07:00</updated>
  <title>Lizzy's Diary</title>
  <summary type='html'>Being the journal of Elizabeth Bennet</summary>
  <link rel='self' type='application/atom+xml'
    href='http://www.blogger.com/feeds/profileID/blogs/blogID' />
  <link rel='alternate' type='text/html'
    href='http://blogName.blogspot.com/' />
  <link rel='http://schemas.google.com/g/2005#feed'
    type='application/atom+xml'
    href='http://blogName.blogspot.com/feeds/posts/default' />
  <link rel='http://schemas.google.com/g/2005#post'
    type='application/atom+xml'
    href='http://www.blogger.com/feeds/blogID/posts/default' />
  ...
  <author>
    <name>Elizabeth Bennet</name>
    <uri>http://www.blogger.com/profile/profileID</uri>
    <email>noreply@blogger.com</email>
  </author>
</entry>

Informationen zur Bedeutung der einzelnen Elemente finden Sie in der Protokolldokumentation zum Google Data APIs oder in der Spezifikation von Atom 1.0.

Wenn Ihre Anfrage aus irgendeinem Grund fehlschlägt, gibt Blogger möglicherweise einen anderen Statuscode zurück. Weitere Informationen zu HTTP-Statuscodes finden Sie auch in der Referenz zum Protokoll der Google Data APIs.

Beiträge erstellen

Mit der Blogger Data API können Sie sowohl neue Blogeinträge als auch Entwürfe erstellen und veröffentlichen.

Blogpost veröffentlichen

Nach der Authentifizierung können Sie neue Blogeinträge veröffentlichen.

Erstellen Sie zuerst eine XML-Darstellung des zu veröffentlichenden Posts. Diese XML muss in Form eines Atom-<entry>-Elements vorliegen, das in etwa so aussehen kann:

<entry xmlns='http://www.w3.org/2005/Atom'>
  <title type='text'>Marriage!</title>
  <content type='xhtml'>
    <div xmlns="http://www.w3.org/1999/xhtml">
      <p>Mr. Darcy has <em>proposed marriage</em> to me!</p>
      <p>He is the last man on earth I would ever desire to marry.</p>
      <p>Whatever shall I do?</p>
    </div>
  </content>
  <category scheme="http://www.blogger.com/atom/ns#" term="marriage" />
  <category scheme="http://www.blogger.com/atom/ns#" term="Mr. Darcy" />
</entry>

Hinweis: Das Festlegen eines benutzerdefinierten Autors für Beiträge wird derzeit nicht unterstützt. Alle neuen Beiträge sehen so aus, als wären sie vom derzeit authentifizierten Nutzer erstellt worden.

Wenn Sie diesen Eintrag veröffentlichen möchten, senden Sie ihn folgendermaßen an die Beitrags-URL des Blogs: Platzieren Sie zuerst das Atom-Element <entry> im Textbereich einer neuen POST-Anfrage mit dem Inhaltstyp application/atom+xml. Suchen Sie dann im Post die URL des Blogposts. Suchen Sie dazu das Element <link> dort, wo das Attribut rel mit #post endet. Die Beitrags-URL des Blogs wird als href-Attribut des Elements in folgendem Format angegeben:

https://www.blogger.com/feeds/blogID/posts/default

Hinweis: Diese URL ist mit der URL im Tag <link rel="service.post"> identisch, die im Abschnitt <head> der für Menschen lesbaren Version des Blogs angezeigt wird.

Blogger erstellt einen Blogpost mit dem von Ihnen gesendeten Eintrag und gibt dann den HTTP-Statuscode 201 CREATED zusammen mit einer Kopie des neuen Beitrags in Form eines <entry>-Elements zurück. Der zurückgegebene Eintrag ist derselbe, den Sie gesendet haben, er enthält aber auch verschiedene von Blogger hinzugefügte Elemente, z. B. ein <id>-Element.

Wenn Ihre Anfrage aus irgendeinem Grund fehlschlägt, gibt Blogger möglicherweise einen anderen Statuscode zurück. Informationen zu den Statuscodes finden Sie in der Referenzdokumentation zum Google Data API-Protokoll.

Blogpostentwurf erstellen

Entwürfe werden auf die gleiche Weise wie öffentliche Beiträge erstellt, allerdings wird dem Eintrag ein <app:control>-Element hinzugefügt, das angibt, dass der Beitrag (noch) nicht veröffentlicht werden soll.

Dieses <app:control>-Element sollte ein einzelnes <app:draft>-Element als untergeordnetes Element enthalten:

<app:control xmlns:app='http://www.w3.org/2007/app'>
  <app:draft>yes</app:draft>
</app:control>

Die Daten im Element <app:draft> müssen den String yes enthalten, damit der Beitrag als Entwurf erkannt wird.

Du kannst einen vorhandenen Blogpost in einen veröffentlichten Beitrag umwandeln. Rufe dazu den Entwurfsbeitrag ab, setze die Daten des <app:draft>-Elements auf den String no und aktualisiere dann den Beitrag. Wie Sie Beiträge abrufen und aktualisieren, erfahren Sie in den nächsten beiden Abschnitten.

Hinweis: Weitere Informationen zum Atom Publishing Protocol, einschließlich der Namespaces <app:control> und <app:draft>, finden Sie unter RFC 5023.

Beiträge werden abgerufen

In den folgenden Abschnitten wird beschrieben, wie Sie eine Liste von Blogposts mit und ohne Suchparameter abrufen.

Sie können einen öffentlichen Blogger-Feed ohne Authentifizierung abfragen. Daher müssen Sie den Autorisierungsparameter nicht festlegen, wenn Sie Blogposts aus einem öffentlichen Blog abrufen.

Alle Blogposts werden abgerufen

Wenn Sie die Beiträge des Nutzers abrufen möchten, senden Sie eine HTTP-GET-Anfrage an die Feed-URL des Blogs. Blogger gibt dann einen Feed mit den entsprechenden Blogeinträgen zurück. Wenn du beispielsweise eine Liste mit Blogposts für marie@gmail.com erhalten möchtest, musst du die folgende HTTP-Anfrage an Blogger senden (natürlich mit dem richtigen Wert anstelle von blogID):

GET https://www.blogger.com/feeds/blogID/posts/default

Blogger gibt dann den HTTP-Statuscode 200 OK und einen Standard-Atom 1.0-Feed zurück, der die Blogposts enthält.

Im Folgenden finden Sie ein Beispiel für einen Feed für einen Blog mit nur einem Beitrag. Beachten Sie, dass wir dieses Beispiel leicht bearbeitet haben, damit es für Menschen besser lesbar ist. Ein echter Blogger-Feed enthält die tatsächlichen IDs und URLs.

<?xml version='1.0' encoding='utf-8'?>
<?xml-stylesheet href="http://www.blogger.com/styles/atom.css"
  type="text/css"?>
<feed xmlns='http://www.w3.org/2005/Atom'
    xmlns:gd='http://schemas.google.com/g/2005'
    gd:etag='W/"D08FQn8-eip7ImA9WxZbFEw."'>
  <id>tag:blogger.com,1999:blog-blogID</id>
  <updated>2008-04-17T00:03:33.152-07:00</updated>
  <title>Lizzy's Diary</title>
  <subtitle type='html'></subtitle>
  <link rel='http://schemas.google.com/g/2005#feed'
    type='application/atom+xml'
    href='http://blogName.blogspot.com/feeds/posts/default' />
  <link rel='self' type='application/atom+xml'
    href='http://www.blogger.com/feeds/blogID/posts/default' />
  <link rel='alternate' type='text/html'
    href='http://blogName.blogspot.com/' />
  <author>
    <name>Elizabeth Bennet</name>
    <uri>http://www.blogger.com/profile/profileID</uri>
    <email>noreply@blogger.com</email>
  </author>
  <generator version='7.00'
    uri='http://www2.blogger.com'>Blogger</generator>
  <entry gd:etag='W/"D0YHRn84eip7ImA9WxZUFk8."'>
    <id>tag:blogger.com,1999:blog-blogID.post-postID</id>
    <published>2008-04-07T20:25:00.005-07:00</published>
    <updated>2008-04-07T20:25:37.132-07:00</updated>
    <title>Quite disagreeable</title>
    <content type='html'>&lt;p&gt;I met Mr. Bingley's friend Mr. Darcy
      this evening. I found him quite disagreeable.&lt;/p&gt;</content>
    <link rel='edit' type='application/atom+xml'
      href='http://www.blogger.com/feeds/blogID/posts/default/postID' />
    <link rel='self' type='application/atom+xml'
      href='http://www.blogger.com/feeds/blogID/posts/default/postID' />
    <link rel='alternate' type='text/html'
      href='http://blogName.blogspot.com/2008/04/quite-disagreeable.html' />
    <author>
      <name>Elizabeth Bennet</name>
      <uri>http://www.blogger.com/profile/profileID</uri>
      <email>noreply@blogger.com</email>
    </author>
  </entry>
</feed>

Blogpost wird noch einmal abgerufen

Wenn Sie einen zuvor abgerufenen Post abrufen möchten, können Sie die Effizienz verbessern, indem Sie Blogger anweisen, den Post nur dann zu senden, wenn er sich seit dem letzten Abruf geändert hat.

Dazu senden Sie eine HTTP-GET-Anfrage mit einem HTTP-If-None-Match-Header. Geben Sie im Header das ETag des Eintrags an, das sich im gd:etag-Attribut des Elements <entry> befindet.

Beispiel:

If-None-Match: W/"D08FQn8-eil7ImA9WxZbFEw."

Wenn Blogger diese Anfrage erhält, wird geprüft, ob der von Ihnen angeforderte Eintrag dasselbe ETag wie das von Ihnen angegebene ETag hat. Wenn die ETags übereinstimmen, hat sich der Eintrag nicht geändert und Blogger gibt den HTTP-Statuscode Not Modified 304 zurück.

Wenn die ETags nicht übereinstimmen, wurde der Eintrag seit der letzten Anforderung geändert und Blogger gibt ihn zurück.

Weitere Informationen zu ETags findest du im Referenzhandbuch für Google Data APIs.

Beiträge mit Suchparametern abrufen

Mit der Blogger Data API können Sie eine Reihe von Einträgen anfordern, die bestimmten Kriterien entsprechen, z. B. das Anfordern von Blogposts, die in einem bestimmten Zeitraum veröffentlicht oder aktualisiert wurden.

Wenn Sie beispielsweise eine Zeitraumabfrage senden möchten, fügen Sie der Anfrage-URL die Parameter published-min und published-max hinzu. Wenn Sie alle zwischen dem 16. März 2008 und dem 24. März 2008 erstellten Blogeinträge abrufen möchten, senden Sie eine HTTP-Anfrage an die Feed-URL des Blogs:

GET https://www.blogger.com/feeds/blogID/posts/default?published-min=2008-03-16T00:00:00&published-max=2008-03-24T23:59:59

Wenn Sie diese GET-Anfrage senden, gibt Blogger einen HTTP-200 OK-Statuscode und einen Feed mit allen Blogposts zurück, die im angegebenen Zeitraum erstellt wurden.

Die Parameter updated-min und updated-max können auch verwendet werden, um alle Blogeinträge innerhalb eines bestimmten Bereichs zu aktualisieren. Diese Parameter werden jedoch ignoriert, sofern der Parameter orderby nicht auf updated gesetzt ist.

Die Blogger Data API unterstützt die folgenden Abfrageparameter:

alt: Der Feedtyp, der zurückgegeben werden soll, z. B. atom (Standardeinstellung) oder rss.
/category: Gibt Kategorien an (auch Labels genannt), um die Feedergebnisse zu filtern. https://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie gibt beispielsweise Einträge mit den Labels Fritz und Laurie zurück.
Max. Ergebnisse: Die maximale Anzahl der Einträge, die zurückgegeben werden sollen.
Orderby: Die Reihenfolge, in der Einträge zurückgegeben werden, z. B. lastmodified (Standardeinstellung), starttime oder updated.
Veröffentlicht-Min., veröffentlicht-max: Die Grenzen des Veröffentlichungsdatums des Eintrags.
Startindex: Der 1-basierte Index des ersten abzurufenden Ergebnisses (für die Seitenordnung).
updated-min, updated-max: Die Grenzen für die Datumsaktualisierung. Diese Suchparameter werden ignoriert, sofern der Parameter orderby nicht auf updated gesetzt ist.
Pfad: Der Permalink-Pfad für einen Beitrag. Für einen Post mit der URL http:// Buzz.blogger.com/2011/08/bloggers-fresh-new-look.html lautet der Permalink-Pfad beispielsweise /2011/08/bloggers-fresh-new-look.html.
q: Vollständiger Textabfragestring. Dadurch kannst du in einem Blog nach Beiträgen suchen, die mit einer Suchanfrage übereinstimmen.

Weitere Informationen zu Suchparametern findest du im Referenzleitfaden für die Blogger Data API und im Referenzhandbuch für Google Data APIs.

Beiträge werden aktualisiert

Zum Aktualisieren eines vorhandenen Blogposts rufen Sie zuerst den zu aktualisierenden Eintrag ab, ändern ihn und senden dann eine PUT-Anfrage mit dem aktualisierten Eintrag im Nachrichtentext an die Bearbeitungs-URL des Beitrags. Achten Sie darauf, dass der <id>-Wert im Eintrag PUT genau mit dem <id> des vorhandenen Eintrags übereinstimmt.

Die Bearbeitungs-URL ist im folgenden Eintrag hervorgehoben:

<entry gd:etag='W/"CUYDSXo8fSp7ImA9WB9UFkU."'>
  <id>tag:blogger.com,1999:blog-blogID.post-postID</id>
  <published>2006-11-08T18:10:00.000-08:00</published>
  <updated>2006-11-08T18:10:14.954-08:00</updated>
  <title type='text'>Quite disagreeable</title>
  <content type='html'>&lt;p&gt;I met Mr. Bingley's friend Mr. Darcy
    this evening. I found him quite disagreeable.&lt;/p&gt;</content>
  <link rel='alternate' type='text/html'
    href='http://blogName.blogspot.com/2006/11/quite-disagreeable.html'>
  </link>
  <link rel='self' type='application/atom+xml'
    href='http://blogName.blogspot.com/feeds/posts/default/postID'>
  </link>
  <link rel='edit' type='application/atom+xml'
    href='http://www.blogger.com/feeds/blogID/posts/default/postID'>
  </link>
  <category scheme="http://www.blogger.com/atom/ns#" term="Mr. Bingley" />
  <category scheme="http://www.blogger.com/atom/ns#" term="Mr. Darcy" />
  <author>
    <name>Elizabeth Bennet</name>
    <email>noreply@blogger.com</email>
    <uri>http://www.blogger.com/profile/profileID</uri>
  </author>
</entry>

WICHTIG: Um die Kompatibilität zu gewährleisten, achte darauf, dass beim PUT-Aktualisieren eines Eintrags alle XML-Inhalte beibehalten werden, die beim Abrufen des Eintrags aus Blogger vorhanden waren. Wenn wir neue Inhalte implementieren und <new-awesome-feature>-Elemente in den Feed aufnehmen, werden diese von Ihrem Client nicht zurückgegeben und Ihre Nutzer versäumen es. In den Google Data API-Clientbibliotheken wird dies alles korrekt verarbeitet. Wenn Sie also eine der Bibliotheken verwenden, sind keine weiteren Schritte nötig.

Hinweis: Das Ändern von mit Beiträgen verknüpften Autorendaten wird derzeit nicht unterstützt.

Tipp zur Fehlerbehebung: Einige Firewalls blockieren HTTP-PUT-Nachrichten. Dies lässt sich umgehen, indem Sie einen X-HTTP-Method-Override: PUT-Header in eine POST-Anfrage einfügen. Weitere Informationen findest du im Dokument Grundlagen des Google Data API-Protokolls.

Beiträge löschen

Wenn Sie einen Beitrag löschen möchten, senden Sie eine DELETE-Anfrage an die Bearbeitungs-URL des Beitrags. Dies ist dieselbe URL, die auch zum Aktualisieren von Beiträgen verwendet wird.

Tipp zur Fehlerbehebung: Einige Firewalls blockieren HTTP-DELETE-Nachrichten. Dies lässt sich umgehen, indem Sie einen X-HTTP-Method-Override: DELETE-Header in eine POST-Anfrage einfügen. Weitere Informationen findest du im Dokument Grundlagen des Google Data API-Protokolls.

Kommentare

Mit der Blogger Data API können Sie Kommentare erstellen, abrufen und löschen. Das Aktualisieren von Kommentaren wird weder unterstützt noch in der Weboberfläche verfügbar.

Kommentare erstellen

Erstellen Sie zum Posten eines Kommentars ein Atom-Element vom Typ <entry>. Beispiel:

  <entry xmlns='http://www.w3.org/2005/Atom'>
    <title type="text">This is my first comment</title>
    <content type="html">This is my first comment</content>
  </entry>

Zum Veröffentlichen dieses Kommentars platzieren Sie das Atom-Element <entry> im Textbereich einer neuen POST-Anfrage mit dem Inhaltstyp application/atom+xml. Senden Sie dann die POST-Anfrage an die entsprechende Blogger-URL:

POST https://www.blogger.com/feeds/blogID/postID/comments/default

Hinweis: Derzeit können Sie in einem Blog nur Kommentare veröffentlichen, deren Inhaber der authentifizierte Nutzer ist.

Hinweis: Das Festlegen eines benutzerdefinierten Autors für Kommentare wird derzeit nicht unterstützt. Alle neuen Kommentare werden so angezeigt, als wären sie vom derzeit authentifizierten Nutzer erstellt worden.

Kommentare werden abgerufen

Du kannst die Kommentare für einen bestimmten Beitrag abrufen, indem du GET an die URL des Kommentarfeeds dieses Beitrags sendest:

GET https://www.blogger.com/feeds/blogID/postID/comments/default

Du kannst auch die Kommentare zu allen Beiträgen über die Kommentar-Feed-URL des Blogs abrufen:

GET https://www.blogger.com/feeds/blogID/comments/default

Bei diesen Anfragen wird ein Kommentarfeed zurückgegeben, der in etwa so aussieht:

<?xml version='1.0' encoding='utf-8'?>
<?xml-stylesheet href="http://www.blogger.com/styles/atom.css"
  type="text/css"?>
<feed xmlns='http://www.w3.org/2005/Atom'
    xmlns:openSearch='http://a9.com/-/spec/opensearch/1.1/'
    xmlns:gd='http://schemas.google.com/g/2005'
    gd:etag='W/"CUYMQ348fyp7ImA9WB9UFkU."'>
  <id>tag:blogger.com,1999:blog-blogID.postpostID..comments</id>
  <updated>2007-12-14T17:46:22.077-08:00</updated>
  <title>Comments on Lizzy's Diary: Quite disagreeable</title>
  <link rel='http://schemas.google.com/g/2005#feed'
    type='application/atom+xml'
    href='http://blogName.blogspot.com/feeds/postID/comments/default' />
  <link rel='self' type='application/atom+xml'
    href='http://www.blogger.com/feeds/blogID/postID/comments/default' />
  <link rel='alternate' type='text/html'
    href='http://blogName.blogspot.com/2007/12/quite-disagreeable_5283.html' />
  <author>
    <name>Elizabeth Bennet</name>
    <uri>http://www.blogger.com/profile/profileID</uri>
    <email>noreply@blogger.com</email>
  </author>
  <generator version='7.00'
    uri='http://www.blogger.com'>Blogger</generator>
  <openSearch:totalResults>1</openSearch:totalResults>
  <openSearch:startIndex>1</openSearch:startIndex>
  <entry gd:etag='W/"CUYCQX47eSp7ImA9WB9UFkU."'>
    <id>tag:blogger.com,1999:blog-blogID.post-commentID</id>
    <published>2007-12-14T17:46:00.001-08:00</published>
    <updated>2007-12-14T17:46:00.001-08:00</updated>
    <title>Darcy FTW!</title>
    <content type='html'>Darcy FTW!</content>
    <link rel='edit' type='application/atom+xml'
      href='http://www.blogger.com/feeds/blogID/postID/comments/default/commentID' />
    <link rel='self' type='application/atom+xml'
      href='http://www.blogger.com/feeds/blogID/postID/comments/default/commentID' />
    <link rel='alternate' type='text/html'
      href='http://blogName.blogspot.com/2007/12/quite-disagreeable_5283.html?showComment=1197683160001#ccommentID'
      title='' />
    <author>
      <name>Elizabeth Bennet</name>
      <uri>http://www.blogger.com/profile/profileID</uri>
      <email>liz@gmail.com</email>
    </author>
    <thr:in-reply-to xmlns:thr='http://purl.org/syndication/thread/1.0'
      href='http://blogName.blogspot.com/2007/12/quite-disagreeable_5283.html'
      ref='tag:blogger.com,1999:blog-blogID.post-postID'
      source='http://www.blogger.com/feeds/blogID/posts/default/postID'
      type='text/html' />
  </entry>
</feed>

Kommentare löschen

Wenn du einen Kommentar löschen möchtest, sende eine DELETE-Anfrage an die Bearbeitungs-URL des Kommentars. Diese URL ist im Kommentarfeed oben markiert.

Exportformat

Mit Blogger können Nutzer ihre Blogs mit einer Blogger-Exportdatei exportieren und importieren. Diese Exportdatei enthält alle Posts und Kommentare für einen Blog. Das Format für die Exportdatei entspricht genau dem Atom-Format, das in den Abschnitten zum Abrufen von Beiträgen und Kommentaren beschrieben wird. Diese Exportdatei enthält den Inhalt des Beitragsfeeds und den Inhalt des Kommentarfeeds in einem Dokument.

Wenn Sie Blogdaten im Exportformat exportieren oder importieren möchten, rufen Sie die Seite Einstellungen für den Blog auf. Verwenden Sie die folgende URL, um die Exportdatei für einen Blog mithilfe der Data API abzurufen:

GET https://www.blogger.com/feeds/blogID/archive

Erstellen Sie zum Importieren der Exportdatei eine POST-Anfrage an die folgende URL, die den Inhalt der Exportdatei als Anfragedaten und application/atom+xml als Inhaltstyp enthält:

POST https://www.blogger.com/feeds/blogID/archive/full

Keine der oben genannten URLs unterstützt Suchparameter. Beide Anfragen müssen auch Authentifizierungsinformationen enthalten und nur Blogadministratoren können den Blog mit diesen Feed-URLs importieren/exportieren.

Hinweis: Wenn Sie eine eigene Blogger-Exportdatei erstellen, gibt es derzeit eine Einschränkung für die Sortierung der Beitrags- und Kommentareinträge. Die Blogger-Exportdatei listet zuerst alle Posts und dann alle Kommentare auf. Das Verschränken von Beitrags- und Kommentareinträgen ist zulässig, solange der Kommentareintrag nach dem Beitrag kommt, für den er gedacht ist.

Weitere Informationen dazu, wie Blogger das Atom-Format in der Exportdatei verwendet, finden Sie im Protokoll-Referenzhandbuch.

Nach oben