Entwicklerhandbuch: Protokoll

Wichtig: Der Support für die Google Data API 2.0 wird am 30. September 2024 eingestellt. Aktualisieren Sie Ihre Anwendungen, die auf Version 2.0 der Google Data API basieren, auf die neueste API-Version, damit sie weiterhin funktionieren. Die aktuelle Version findest du über die Links in der linken Navigationsleiste. Hinweis: Zwar werden einige GET-Anfragen (z. B. Listenbeiträge) weiterhin als Feed-URLs unterstützt, es gibt jedoch geringfügige Unterschiede in ihrem Verhalten. Weitere Informationen findest du in der Blogger-Hilfe.

Mit der Blogger Data API können Client-Anwendungen Blogger-Inhalte in Form von Google Data API-Feeds ansehen und aktualisieren.

Ihre Client-Anwendung kann die Blogger Data API verwenden, um neue Blogposts zu erstellen, vorhandene Blogposts zu bearbeiten oder zu löschen und Blogposts abzufragen, die bestimmten Kriterien entsprechen.

Zusätzlich zu Hintergrundinformationen zu den Funktionen der Blogger Data API enthält dieses Dokument Beispiele für grundlegende Data API-Interaktionen mit Roh-XML und HTTPS. Nachdem Sie dieses Dokument gelesen haben, können Sie in den Abschnitten auf Programmiersprachen in diesem Entwicklerhandbuch mehr über die Interaktion mit der API mithilfe unserer Clientbibliotheken erfahren.

Inhalt

  1. Zielgruppe
  2. Erste Schritte
    1. Blogger-Konto erstellen
  3. Anfragen autorisieren
  4. Version angeben
  5. Eine Liste von Blogs abrufen
  6. Beiträge erstellen
    1. Blogposts veröffentlichen
    2. Blogpostentwurf erstellen
  7. Beiträge abrufen
    1. Alle Blogposts abrufen
    2. Blogpost noch einmal abrufen
    3. Beiträge mit Abfrageparametern abrufen
  8. Beiträge aktualisieren
  9. Beiträge löschen
  10. Kommentare
    1. Kommentare erstellen
    2. Kommentare abrufen
    3. Kommentare löschen
  11. Export format

Zielgruppe

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

In diesem Dokument wird davon ausgegangen, dass Sie die allgemeinen Konzepte hinter dem Google Data APIs-Protokoll kennen.

Wenn Sie ein UNIX-System verwenden und die Beispiele in diesem Dokument ausprobieren möchten, ohne Code schreiben zu müssen, können die UNIX-Befehlszeilendienstprogramme curl oder wget nützlich sein. Weitere Informationen finden Sie auf den Seiten des Handbuchs für diese Dienstprogramme.

Informationen zur Blogger Data API finden Sie im Protokollreferenzhandbuch.

Erste Schritte

Erstellen eines Blogger-Kontos

Du kannst dich zu Testzwecken für ein Blogger-Konto registrieren. Blogger verwendet Google-Konten. Wenn du also bereits ein Google-Konto hast, bist du startklar.

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 die Verwendung von OAuth 2.0 zum Autorisieren von Anfragen.

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. Wenn Ihre Anwendung diese Optionen bereits verwendet, empfehlen wir, nach Möglichkeit zu OAuth 2.0 zu migrieren.

Wenn Ihre Anwendung bestimmte ungewöhnliche Autorisierungsanforderungen hat, z. B. eine gleichzeitige Anmeldung mit Datenzugriff (hybrid) oder eine domainweite Delegierung der Autorität (2LO), können Sie derzeit 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 nach nicht öffentlichen Nutzerdaten müssen von einem authentifizierten Nutzer autorisiert werden.

Die Details des Autorisierungsprozesses für OAuth 2.0 unterscheiden sich je nach Art der Anwendung, die Sie schreiben. Das folgende allgemeine Verfahren gilt für alle Anwendungstypen:

  1. Wenn Sie Ihre Anwendung erstellen, registrieren Sie diese bei Google. Google stellt Ihnen dann die Informationen bereit, die Sie später benötigen, z. B. eine Client-ID und einen Clientschlüssel.
  2. Wenn Ihre Anwendung Zugriff auf Nutzerdaten benötigt, fordert sie von Google einen bestimmten Zugriffsbereich an.
  3. Dem Nutzer wird ein OAuth-Dialogfeld angezeigt, in dem er aufgefordert wird, Ihre Anwendung zu autorisieren, einige seiner Daten anzufordern.
  4. Wenn der Nutzer zustimmt, erteilt Google Ihrer Anwendung ein kurzlebiges Zugriffstoken.
  5. Ihre Anwendung fordert Nutzerdaten an und das Zugriffstoken wird an die Anfrage angehängt.
  6. Wenn Google feststellt, dass Ihre Anfrage und das Token gültig sind, werden die angeforderten Daten zurückgegeben.

Einige Abläufe enthalten zusätzliche Schritte, beispielsweise die Verwendung von Aktualisierungstokens, um neue Zugriffstokens zu erhalten. Ausführliche Informationen zu den Abläufen für verschiedene Anwendungstypen finden Sie in der OAuth 2.0-Dokumentation von Google.

Hier finden Sie Informationen zum Umfang von OAuth 2.0 für die Blogger GData API:

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

Für die Anforderung eines Zugriffs mit OAuth 2.0 benötigt Ihre Anwendung die Informationen zum Umfang sowie die Informationen, die Google während der Anwendungsregistrierung bereitstellt, z. B. die Client-ID und/oder der Clientschlüssel.

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

Version angeben

Für jede Anfrage, die Sie mit der Blogger Data API senden, sollte Version 2 der API angegeben werden.

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

GData-Version: 2

Falls Sie keine HTTP-Header festlegen können, haben Sie alternativ die Möglichkeit, v=2 als Abfrageparameter in der URL anzugeben. Der HTTP-Header wird jedoch nach Möglichkeit bevorzugt.

Hinweis: Die Clientbibliotheken stellen die entsprechenden Versionsheader automatisch bereit. Verwenden Sie daher den Abfrageparameter v=2 nicht, wenn Sie eine Clientbibliothek nutzen.

Eine Liste von Blogs abrufen

Die Blogger Data API stellt einen Feed zur Verfügung, in dem die Blogs für einen bestimmten Nutzer aufgelistet sind. Dieser Feed wird als „Metafeed“ bezeichnet.

Senden Sie ein 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 Zahl in der URL für die Profilseite des Nutzers.

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

Ein Eintrag im Metafeed könnte wie folgt 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 im Dokument Google Data APIs-Protokollreferenz oder in der Atom 1.0-Spezifikation.

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 im Dokument Protokollreferenz-Referenz für Google Data APIs.

Beiträge erstellen

Mit der Blogger Data API kannst du neue Blog-Einträge erstellen und veröffentlichen sowie Entwürfe von Einträgen erstellen.

Blogposts veröffentlichen

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

Erstelle zuerst eine XML-Darstellung des zu veröffentlichenden Beitrags. Diese XML-Datei muss die Form eines Atom-<entry>-Elements haben, das 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 werden so angezeigt, als wären sie vom aktuell authentifizierten Nutzer erstellt worden.

Um diesen Eintrag zu veröffentlichen, senden Sie ihn wie folgt an die Post-URL des Blogs. Fügen Sie zuerst das Atom-Element <entry> in den Text einer neuen POST-Anfrage ein. Verwenden Sie dazu den Inhaltstyp application/atom+xml. Suchen Sie dann im Metafeed nach der URL des Blogposts. Suchen Sie dazu nach dem <link>-Element, bei dem das Attribut rel mit #post endet. Die Post-URL des Blogposts wird als href-Attribut dieses Elements angegeben. Sie hat folgendes Format:

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

Hinweis: Diese URL ist identisch mit der URL im <link rel="service.post">-Tag, das im <head>-Bereich der visuell lesbaren Version des Blogs angezeigt wird.

Blogger erstellt einen Blogpost mit dem von dir gesendeten Eintrag und gibt dann den HTTP-Statuscode 201 CREATED sowie eine Kopie des neuen Beitrags in Form eines <entry>-Elements zurück. Der zurückgegebene Eintrag ist derselbe, den Sie gesendet haben, enthält aber auch verschiedene Elemente, die von Blogger hinzugefügt wurden, 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 im Referenzdokument zum Google Data API-Protokoll.

Blogpostentwurf erstellen

Beitragsentwürfe werden auf die gleiche Weise wie öffentliche Beiträge erstellt, aber mit einem <app:control>-Element im Eintrag, das angibt, dass der Beitrag (noch) nicht veröffentlicht werden soll.

Dieses <app:control>-Element sollte nur ein <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 im Element <app:draft> enthaltenen Daten müssen der String yes sein, damit der Beitrag als Entwurf erkannt wird.

Sie können einen vorhandenen Blogpost-Entwurf in einen veröffentlichten Post umwandeln. Dazu rufen Sie den Entwurf ab, setzen die Daten des <app:draft>-Elements auf den String no und aktualisieren dann den Post. Das Abrufen und Aktualisieren von Beiträgen wird in den nächsten beiden Abschnitten behandelt.

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 Abfrageparameter abrufen.

Sie können einen öffentlichen Blogger-Feed ohne Authentifizierung abfragen. Daher müssen Sie den Autorisierungsparameter nicht festlegen, wenn Sie Blogposts von 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 Blog-Einträgen zurück. Um beispielsweise eine Liste von Blogposts für liz@gmail.com abzurufen, senden Sie die folgende HTTP-Anfrage an Blogger (natürlich mit dem entsprechenden 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 Post. Wie Sie sehen, haben wir dieses Beispiel geringfügig bearbeitet, um es für Menschen etwas besser lesbar zu machen. Insbesondere ein echter Blogger-Feed enthält tatsächliche 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 noch einmal abrufen

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

Für diese Art von bedingtem Abruf senden Sie eine HTTP-GET-Anfrage, die einen HTTP-If-None-Match-Header enthält. Geben Sie im Header das ETag des Eintrags an, das Sie im Attribut gd:etag des <entry>-Elements finden.

Beispiel:

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

Wenn Blogger diese Anfrage erhält, wird geprüft, ob der 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 304 Not Modified zurück.

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

Weitere Informationen zu ETags finden Sie 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. So können Sie beispielsweise Blogposts anfordern, 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. Um alle Blogeinträge abzurufen, die zwischen dem 16. März 2008 und dem 24. März 2008 erstellt wurden, 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 den HTTP-Statuscode 200 OK 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 abzurufen, die innerhalb eines bestimmten Bereichs aktualisiert werden. Diese Parameter werden jedoch ignoriert, es sei denn, der Parameter orderby ist auch auf updated gesetzt.

Das Blogger Data API unterstützt die folgenden Abfrageparameter:

alt
Der Typ des Feeds, der zurückgegeben werden soll, z. B. atom (Standardeinstellung) oder rss.
/category
Gibt Kategorien (auch als Labels bezeichnet) zum Filtern der Feedergebnisse an. https://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie gibt beispielsweise Einträge mit den Labels Fritz und Laurie zurück.
max-results
Die maximale Anzahl der zurückzugebenden Einträge.
Sortiert nach
Die Reihenfolge, in der Einträge wie lastmodified (Standardeinstellung), starttime oder updated zurückgegeben werden.
Veröffentlichter Mindestwert, veröffentlichter Höchstwert
Die Grenzen des Veröffentlichungsdatums des Eintrags.
start-index
Der auf 1 basierende Index des ersten abzurufenden Ergebnisses (für die Seitenangabe).
aktualisiert-min, aktualisiert-max
Die Grenzen am Datum der Eintragsaktualisierung. Diese Abfrageparameter werden ignoriert, es sei denn, der Parameter orderby ist auf updated festgelegt.
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 Abfragestring in Textform. So können Sie in einem Blog nach Posts suchen, die einer Abfrage entsprechen.

Weitere Informationen zu Abfrageparametern findest du im Referenzhandbuch zur Blogger Data API und im Referenzhandbuch für Google Data APIs.

Beiträge werden aktualisiert

Wenn Sie einen vorhandenen Blogpost aktualisieren möchten, rufen Sie zuerst den zu aktualisierenden Eintrag ab, ändern Sie ihn und senden Sie dann eine PUT-Anfrage mit dem aktualisierten Eintrag im Nachrichtentext an die Bearbeitungs-URL des Beitrags. Achten Sie darauf, dass der Wert <id> in dem Eintrag, für den Sie PUT verwenden, 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 Aufwärtskompatibilität zu gewährleisten, sollten Sie beim Abrufen eines aktualisierten Eintrags mit PUT alle XML-Dateien beibehalten, die beim Abrufen des Eintrags aus Blogger vorhanden waren. Andernfalls gibt dein Client sie nicht zurück, wenn wir neue Elemente implementieren und <new-awesome-feature>-Elemente in den Feed aufnehmen. Die Google Data API-Clientbibliotheken übernehmen dies alle korrekt. Wenn Sie eine der Bibliotheken verwenden, müssen Sie also nichts weiter tun.

Hinweis: Derzeit können die mit Beiträgen verknüpften Autorendaten nicht geändert werden.

Tipp zur Fehlerbehebung: Einige Firewalls blockieren HTTP-PUT-Nachrichten. Um dieses Problem zu umgehen, können Sie einen X-HTTP-Method-Override: PUT-Header in eine POST-Anfrage einfügen. Weitere Informationen finden Sie im Dokument Grundlagen des Google Data API-Protokolls.

Beiträge werden gelöscht

Wenn Sie einen Beitrag löschen möchten, senden Sie eine DELETE-Anfrage an die Bearbeitungs-URL des Beitrags. Dies ist dieselbe URL, die verwendet wird, um Beiträge zu aktualisieren.

Tipp zur Fehlerbehebung: Einige Firewalls blockieren HTTP-DELETE-Nachrichten. Um dieses Problem zu umgehen, können Sie einen X-HTTP-Method-Override: DELETE-Header in eine POST-Anfrage einfügen. Weitere Informationen finden Sie im Dokument Grundlagen des Google Data API-Protokolls.

Kommentare

Mit der Blogger Data API können Kommentare erstellt, abgerufen und gelöscht werden. Das Aktualisieren von Kommentaren wird nicht unterstützt und ist auch nicht auf der Weboberfläche verfügbar.

Kommentare erstellen

Um einen Kommentar zu posten, erstellen Sie ein Atom-<entry>-Element wie das folgende:

  <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>

Wenn Sie diesen Kommentar veröffentlichen möchten, fügen Sie das Atom-<entry>-Element in den Text einer neuen POST-Anfrage ein. Verwenden Sie dazu den Inhaltstyp application/atom+xml. Sende dann die POST-Anfrage an die entsprechende Blogger-URL:

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

Hinweis: Derzeit können Sie nur Kommentare in einem Blog posten, der dem authentifizierten Nutzer gehört.

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 aktuell authentifizierten Nutzer erstellt worden.

Kommentare abrufen

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

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

Sie können auch die Kommentare aus allen Posts abrufen, indem Sie die Kommentar-Feed-URL des Blogs verwenden:

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

Bei solchen Anfragen wird ein Kommentarfeed zurückgegeben, der wie folgt 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 werden gelöscht

Wenn Sie einen Kommentar löschen möchten, senden Sie eine DELETE-Anfrage an die Bearbeitungs-URL des Kommentars. Diese URL wird oben im Kommentarfeed hervorgehoben.

Exportformat

Blogger ermöglicht Nutzern, ihre Blogs mithilfe einer Blogger-Exportdatei zu exportieren und zu importieren. Diese Exportdatei enthält alle Posts und Kommentare eines Blogs. 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 Postfeeds 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

Um die Exportdatei zu importieren, erstellen Sie eine POST-Anfrage an die folgende URL mit dem Inhalt der Exportdatei als Anfragedaten und application/atom+xml als Inhaltstyp:

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

Keine der oben genannten URLs unterstützt Suchparameter. Beide Anfragen müssen außerdem Informationen zur Authentifizierung enthalten und nur Blogadministratoren können den Blog über diese Feed-URLs importieren/exportieren.

Hinweis: Wenn Sie Ihre eigene Blogger-Exportdatei erstellen, gibt es derzeit eine Einschränkung für die Reihenfolge der Post- und Kommentareinträge. In der Blogger-Exportdatei werden zuerst alle Posts und dann Kommentare aufgeführt. Das Verschachteln von Beitrags- und Kommentareinträgen ist zulässig, sofern der Kommentareintrag nach dem Beitrag folgt, für den der Kommentar bestimmt ist.

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

Nach oben