Diese Seite wurde von der Cloud Translation API übersetzt.

Entwicklerhandbuch: Protokoll

Wichtig: Die Unterstützung der Google Data API 2.0 wird am 30. September 2024 eingestellt. Damit Ihre Anwendungen weiterhin funktionieren, sollten Sie sie auf die neueste API-Version aktualisieren, wenn sie die Google Data API v2.0 verwenden. Die neueste Version finden Sie über die Links in der linken Navigationsleiste. Hinweis: Einige GET-Anfragen (z. B. zu Einträgen) werden weiterhin als Feed-URLs unterstützt. Es gibt jedoch geringfügige Unterschiede im Verhalten. Weitere Informationen finden Sie in der Blogger-Hilfe.

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

Mit der Blogger Data API können Sie in Ihrer Clientanwendung neue Blogbeiträge erstellen, vorhandene Blogbeiträge bearbeiten oder löschen und nach Blogbeiträgen suchen, die bestimmten Kriterien entsprechen.

Dieses Dokument enthält nicht nur einige Hintergrundinformationen zu den Funktionen der Blogger Data API, sondern auch Beispiele für grundlegende Data API-Interaktionen mithilfe von Roh-XML und HTTPS. Wenn Sie nach dem Lesen dieses Dokuments mehr über die Interaktion mit der API über unsere Clientbibliotheken erfahren möchten, lesen Sie die sprachspezifischen Abschnitte dieses Entwicklerhandbuchs.

Inhalt

Zielgruppe

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

In diesem Dokument wird davon ausgegangen, dass Sie mit den allgemeinen Konzepten des Google Data APIs-Protokolls vertraut sind.

Wenn Sie ein UNIX-System verwenden und die Beispiele in diesem Dokument ausprobieren möchten, ohne Code zu schreiben, können Sie die UNIX-Befehlszeilenprogramme curl oder wget verwenden. Weitere Informationen finden Sie in den Manual Pages für diese Dienstprogramme.

Referenzinformationen zur Blogger Data API finden Sie im Referenzhandbuch für Protokolle.

Erste Schritte

Blogger-Konto erstellen

Sie können sich für Testzwecke für ein Blogger-Konto registrieren. Für Blogger werden Google-Konten verwendet. Wenn Sie also bereits ein Google-Konto haben, können Sie sofort loslegen.

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, OAuth 2.0 zur Autorisierung von Anfragen zu verwenden.

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

Wenn für Ihre Anwendung bestimmte ungewöhnliche Autorisierungsanforderungen gelten, z. B. die Anmeldung gleichzeitig mit dem Anfordern des Datenzugriffs (hybrid) oder die domainweite Delegierung von Berechtigungen (2LO), können Sie derzeit keine OAuth 2.0-Tokens verwenden. In solchen Fällen müssen Sie stattdessen OAuth 1.0-Token verwenden.

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 dieses Autorisierungsablaufs für OAuth 2.0 hängen davon ab, welche Art von Anwendung du schreibst. Die folgende allgemeine Vorgehensweise gilt für alle Arten von Anwendungen:

Wenn Sie Ihre Anwendung erstellen, registrieren Sie sie bei Google. Google stellt Ihnen 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, bittet sie Google um einen bestimmten Zugriffsbereich.
Dem Nutzer wird von Google ein OAuth-Dialogfeld angezeigt, auf dem er gebeten wird, Ihre Anwendung dazu zu autorisieren, einige seiner Daten abzufragen.
Wenn der Nutzer zustimmt, erhält Ihre Anwendung von Google ein kurzlebiges Zugriffstoken.
Die Anwendung fordert Nutzerdaten an, wobei das Zugriffstoken an die Anfrage angehängt wird.
Stellt Google fest, 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 Aktualisierungstoken zum Erhalt neuer Zugriffstoken. Weitere Informationen über die Abläufe für die unterschiedlichen Anwendungstypen findest du in der OAuth 2.0-Dokumentation.

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

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

Zur Anforderung eines Zugriffs mit OAuth 2.0 benötigt Ihre Anwendung die Bereichsinformationen sowie die Informationen, die Google bei der Registrierung Ihrer Anwendung bereitstellt, z. B. die Client-ID und/oder den Clientschlüssel.

Tipp:Die Google APIs-Clientbibliotheken können einige Schritte des Autorisierungsvorgangs für Sie übernehmen. Sie sind für verschiedene Programmiersprachen verfügbar. Weitere Informationen erhältst du auf der Seite Bibliotheken und Beispiele.

Version angeben

Bei jeder Anfrage, die Sie über die Blogger Data API senden, muss Version 2 der API angegeben werden.

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

GData-Version: 2

Wenn Sie keine HTTP-Header festlegen können, können Sie v=2 auch als Abfrageparameter in der URL angeben. Der HTTP-Header wird jedoch nach Möglichkeit bevorzugt.

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

Liste der Blogs abrufen

Die Blogger Data API stellt einen Feed bereit, in dem die Blogs eines bestimmten Nutzers aufgeführt sind. Dieser Feed wird als „Metafeed“ bezeichnet.

Senden Sie eine HTTP-GET-Anfrage an die folgende URL, um die Liste der Blogs abzurufen:

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

Die Profil-ID ist die Zahl in der URL der Profilseite des Nutzers.

Hinweis: Sie können auch default anstelle der Nutzer-ID angeben. In diesem Fall gibt Blogger die Liste der Blogs für den Nutzer zurück, dessen Anmeldedaten mit der Anfrage gesendet wurden.

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 im Dokument Google Data APIs Protocol Reference 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 Google Data APIs Protocol Reference (Referenz zum Google Data APIs-Protokoll).

Beiträge erstellen

Mit der Blogger Data API können Sie neue Blogbeiträge erstellen und veröffentlichen sowie Beitragsentwürfe erstellen.

Blogpost veröffentlichen

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

Erstelle zuerst eine XML-Darstellung des zu veröffentlichenden Beitrags. Diese XML-Datei muss in Form eines Atom-<entry>-Elements vorliegen. Das könnte so aussehen:

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

Wenn Sie diesen Eintrag veröffentlichen möchten, senden Sie ihn wie unten beschrieben an die Post-URL des Blogs. Platzieren Sie zuerst das Atom-Element <entry> im Textkörper einer neuen POST-Anfrage und verwenden Sie den Inhaltstyp application/atom+xml. Suche dann im Metafeed nach der Beitrags-URL des Blogs. Sie findest sie im <link>-Element, in dem das rel-Attribut auf #post endet. Die 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 stimmt mit der URL im <link rel="service.post">-Tag überein, die im Bereich <head> der visuell lesbaren Version des Blogs angezeigt wird.

Blogger erstellt einen Blogpost mit dem von Ihnen gesendeten Eintrag und gibt dann einen HTTP-201 CREATED-Statuscode 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 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 im Referenzdokument zum Google Data API-Protokoll.

Einen Blogpost-Entwurf erstellen

Entwurfsposts werden auf die gleiche Weise wie öffentliche Beiträge erstellt. Dem Eintrag wird jedoch 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 im <app:draft>-Element enthaltenen Daten müssen den String yes enthalten, damit der Beitrag als Entwurf erkannt wird.

Sie können einen vorhandenen Blogpost-Entwurf in einen veröffentlichten Beitrag umwandeln, indem Sie den Entwurf abrufen, die Daten des Elements <app:draft> auf den String no festlegen und den Beitrag dann aktualisieren. 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 abrufen

In den folgenden Abschnitten wird beschrieben, wie Sie eine Liste von Blogbeiträgen 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 Blogbeiträge aus einem öffentlichen Blog abrufen.

Alle Blogbeiträge abrufen

Um die Beiträge des Nutzers abzurufen, 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 der Blogbeiträge für liz@gmail.com abrufen möchtest, sende 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 einen HTTP-Statuscode 200 OK und einen Standard-Atom 1.0-Feed mit den Blogbeiträgen zurück.

Im folgenden Beispiel wird ein Feed für einen Blog mit nur einem Beitrag gezeigt. Beachten Sie, dass wir dieses Beispiel leicht bearbeitet haben, damit es für Menschen leichter lesbar ist. Ein echter Blogger-Feed enthält insbesondere 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 Beitrag abrufen möchten, den Sie schon einmal abgerufen haben, können Sie die Effizienz verbessern, indem Sie Blogger anweisen, den Beitrag nur zu senden, wenn er sich seit dem letzten Abruf geändert hat.

Senden Sie dazu eine HTTP-GET-Anfrage mit einem HTTP-If-None-Match-Header. Geben Sie in der Kopfzeile 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 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 304 Not Modified zurück.

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

Weitere Informationen zu ETags finden Sie im Referenzleitfaden für Google Data APIs.

Beiträge mithilfe von Abfrageparametern abrufen

Mit der Blogger Data API können Sie eine Reihe von Einträgen anfordern, die bestimmten Kriterien entsprechen. So können Sie beispielsweise Blogbeiträge anfordern, die in einem bestimmten Zeitraum veröffentlicht oder aktualisiert wurden.

Wenn Sie beispielsweise eine Abfrage für einen bestimmten Zeitraum senden möchten, fügen Sie der Anfrage-URL die Parameter published-min und published-max hinzu. Wenn Sie alle Blogeinträge abrufen möchten, 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 einen HTTP-200 OK-Statuscode und einen Feed mit allen Blogbeiträgen zurück, die im angegebenen Zeitraum erstellt wurden.

Mit den Parametern updated-min und updated-max können Sie auch alle Blogbeiträge abrufen, die in einem bestimmten Zeitraum aktualisiert wurden. Beachten Sie jedoch, dass diese Parameter ignoriert werden, es sei denn, der Parameter orderby ist ebenfalls auf updated gesetzt.

Die Blogger Data API unterstützt die folgenden Abfrageparameter:

alt: Der Typ des zurückzugebenden Feeds, z. B. atom (Standard) oder rss.
/category: Gibt Kategorien (auch als Labels bezeichnet) an, um die Feedergebnisse zu filtern. Beispiel: https://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie gibt Einträge mit den Labels Fritz und Laurie zurück.
max-results: Die maximale Anzahl der Einträge, die zurückgegeben werden sollen.
orderby: Die Reihenfolge, in der Einträge zurückgegeben werden sollen, z. B. lastmodified (Standardeinstellung), starttime oder updated.
published-min, published-max: Die Grenzen für die Veröffentlichungsdaten von Einträgen.
start-index: Der Index (ab 1) des ersten Ergebnisses, das abgerufen werden soll (für die Paginierung).
updated-min, updated-max: Die Grenzen für die Datumsangaben der Eintragsaktualisierungen. Diese Abfrageparameter werden ignoriert, es sei denn, der Parameter orderby ist auf updated gesetzt.
Pfad: Der Pfad zum Permalink eines Beitrags. Bei einem Beitrag mit der URL http://buzz.blogger.com/2011/08/bloggers-fresh-new-look.html lautet der Pfad des Permalinks /2011/08/bloggers-fresh-new-look.html.
q: Volltext-Suchstring. So können Sie in einem Blog nach Beiträgen suchen, die mit einer Suchanfrage übereinstimmen.

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

Beiträge aktualisieren

Wenn du einen vorhandenen Blogpost aktualisieren möchtest, musst du zuerst den Eintrag abrufen, den du aktualisieren möchtest, dann ändern und dann eine PUT-Anfrage mit dem aktualisierten Eintrag im Nachrichtentext an die Bearbeitungs-URL des Beitrags senden. Der Wert für <id> im Eintrag, den Sie PUT, muss genau mit dem <id> des vorhandenen Eintrags übereinstimmen.

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: Damit der Eintrag auch in Zukunft verwendet werden kann, müssen Sie beim PUT eines aktualisierten Eintrags alle XML-Daten beibehalten, die beim Abrufen des Eintrags aus Blogger vorhanden waren. Andernfalls, wenn wir neue Elemente implementieren und <new-awesome-feature>-Elemente in den Feed aufnehmen, gibt Ihr Kunde sie nicht zurück und Ihre Nutzer gehen leer aus. Die Clientbibliotheken der Google Data API verarbeiten das korrekt. Wenn Sie also eine der Bibliotheken verwenden, ist alles in Ordnung.

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

Tipp zur Fehlerbehebung: Einige Firewalls blockieren HTTP-PUT-Nachrichten. Sie können dieses Problem umgehen, indem 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 löschen

Wenn du einen Beitrag löschen möchtest, sende eine DELETE-Anfrage an die Bearbeitungs-URL des Beitrags. Das ist dieselbe URL, die auch zum Aktualisieren von Beiträgen verwendet wird.

Tipp zur Fehlerbehebung: Einige Firewalls blockieren HTTP-DELETE-Nachrichten. Sie können dieses Problem umgehen, indem 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 in der Weboberfläche verfügbar.

Kommentare erstellen

Wenn du einen Kommentar posten möchtest, erstelle 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 du diesen Kommentar veröffentlichen möchtest, platziere dein Atom-<entry>-Element im Text einer neuen POST-Anfrage und verwende 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 zu einem bestimmten Beitrag abrufen, indem du eine GET an die Kommentarfeed-URL dieses Beitrags sendest:

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

Alternativ kannst du die Kommentare zu allen Beiträgen über die Kommentarfeed-URL des Blogs abrufen:

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

Diese Anfragen geben einen Kommentarfeed zurück, der 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 hervorgehoben.

Exportformat

Mit Blogger können Nutzer ihre Blogs mit einer Blogger-Exportdatei exportieren und importieren. Diese Exportdatei enthält alle Beiträge und Kommentare für einen Blog. Das Format der Exportdatei ist genau das 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 des Blogs auf. Wenn du die Exportdatei für einen Blog mit der Data API abrufen möchtest, verwende die folgende URL:

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

Wenn Sie die Exportdatei importieren möchten, erstellen Sie eine POST-Anfrage an die folgende URL. Verwenden Sie den 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 Abfrageparameter. Beide Anfragen müssen außerdem Authentifizierungsinformationen enthalten. Nur Blogadministratoren können den Blog mithilfe dieser Feed-URLs importieren/exportieren.

Hinweis: Wenn Sie Ihre eigene Blogger-Exportdatei erstellen, gibt es derzeit eine Einschränkung bei der Reihenfolge der Beitrags- und Kommentareinträge. In der Blogger-Exportdatei werden zuerst alle Beiträge und dann alle Kommentare aufgeführt. Es ist erlaubt, Beiträge und Kommentare zu vermischen, solange der Kommentar nach dem Beitrag gepostet wird, auf den er sich bezieht.

Weitere Informationen dazu, wie Blogger das Atom-Format in der Exportdatei verwendet, finden Sie im Referenzhandbuch für Protokolle.

Nach oben