Blogger API: API verwenden

Mit der Blogger API kannst du Blogger-Inhalte mithilfe der REST APIs in deine Anwendung einbinden. Bevor Sie beginnen, müssen Sie die Autorisierung einrichten.

Einleitung

Dieses Dokument richtet sich an Entwickler, die Anwendungen schreiben möchten, die mit der Blogger API interagieren können. Blogger ist ein Tool zum Erstellen von Websites, auf denen Nutzer fortlaufend ihre Gedanken veröffentlichen können.

Wenn Sie mit den Konzepten von Blogger nicht vertraut sind, sollten Sie zuerst den Artikel Erste Schritte lesen, bevor Sie mit dem Programmieren beginnen.

Anfragen autorisieren und Ihre Anwendung identifizieren

Jede Anfrage, die Ihre Anwendung an die Blogger-APIs sendet, muss Ihre Anwendung bei Google identifizieren. Dafür gibt es zwei Möglichkeiten: die Verwendung eines OAuth 2.0-Tokens, das auch die Anfrage autorisiert, und/oder die Verwendung des API-Schlüssels der Anwendung. Welche dieser Optionen Sie nutzen sollten, hängt von Folgendem ab:

• Wenn die Anfrage eine Autorisierung erfordert (z. B. wenn die privaten Daten einer Person angefordert werden), muss die Anwendung ein OAuth 2.0-Token zusammen mit der Anfrage bereitstellen. Die Anwendung kann auch den API-Schlüssel bereitstellen, muss dies jedoch nicht tun.
• Wenn die Anfrage keine Autorisierung erfordert, beispielsweise bei einer Anfrage in Bezug auf öffentliche Daten, muss die Anwendung entweder den API-Schlüssel oder ein OAuth 2.0-Token oder beides bereitstellen, je nachdem, was für Sie am bequemsten ist.

Über Autorisierungsprotokolle

Ihre Anwendung muss zur Autorisierung von Anfragen OAuth 2.0 verwenden. Andere Autorisierungsprotokolle werden nicht unterstützt. Wenn deine Anwendung Über Google anmelden verwendet, werden einige Schritte der Autorisierung automatisch ausgeführt.

Anfragen mit OAuth 2.0 autorisieren

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

Dieser Vorgang wird mit einer OAuth-Client-ID ermöglicht.

Alternativ können Sie auf der Seite "Anmeldedaten" einen Schlüssel erstellen.

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:

1. Wenn deine Anwendung Zugriff auf Nutzerdaten benötigt, bittet sie Google um einen bestimmten Zugriffsbereich.
2. Dem Nutzer wird von Google ein Zustimmungsbildschirm angezeigt, auf dem er gebeten wird, deine Anwendung dazu zu autorisieren, einige seiner Daten abzufragen.
3. Wenn der Nutzer zustimmt, erhält deine Anwendung von Google ein kurzlebiges Zugriffstoken.
4. Die Anwendung fordert Nutzerdaten an, wobei das Zugriffstoken an die Anfrage angehängt wird.
5. 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 Umfang von OAuth 2.0 für die Blogger APIs:

https://www.googleapis.com/auth/blogger

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

Tipp: Die Google APIs-Clientbibliotheken können einige Schritte des Autorisierungsvorgangs für Sie übernehmen. Diese sind in zahlreichen Programmiersprachen verfügbar. Weitere Informationen dazu finden Sie auf der Seite mit Bibliotheken und Beispielen.

API-Schlüssel erhalten und nutzen

Anfragen an die Blogger APIs nach öffentlichen Daten muss eine Kennung angehängt werden. Diese kann ein API-Schlüssel oder ein Zugriffstoken sein.

Alternativ können Sie auf der Seite "Anmeldedaten" einen Schlüssel erstellen.

Nachdem Sie einen API-Schlüssel haben, kann Ihre Anwendung den Abfrageparameter key=yourAPIKey an alle Anfrage-URLs anhängen.

Der API-Schlüssel lässt sich sicher in URLs einbetten. Eine Codierung ist nicht notwendig.

Arbeiten mit Blogs

Abrufen eines Blogs

Du kannst Informationen für einen bestimmten Blog abrufen, indem du eine HTTP-GET-Anfrage an den URI des Blogs sendest. Der URI für einen Blog hat folgendes Format:

https://www.googleapis.com/blogger/v3/blogs/blogId

Anfragen

GET https://www.googleapis.com/blogger/v3/blogs/2399953?key=YOUR-API-KEY

Ein Nutzer muss nicht authentifiziert sein, um einen öffentlichen Blog abzurufen. Die Anwendung muss bei einer öffentlichen Bloganfrage keinen Authorization-HTTP-Header einfügen, du musst aber den API-Schlüssel angeben.

Blogger verfügt auch über private Blogs, für die eine Authentifizierung erforderlich ist.

Antwort

Wenn die Anfrage erfolgreich ist, antwortet der Server mit dem HTTP-Statuscode 200 OK und den Blogdaten:

{
  "kind": "blogger#blog",
  "id": "2399953",
  "name": "Blogger Buzz",
  "description": "The Official Buzz from Blogger at Google",
  "published": "2007-04-23T22:17:29.261Z",
  "updated": "2011-08-02T06:01:15.941Z",
  "url": "http://buzz.blogger.com/",
  "selfLink": "https://www.googleapis.com/blogger/v3/blogs/2399953",
  "posts": {
    "totalItems": 494,
    "selfLink": "https://www.googleapis.com/blogger/v3/blogs/2399953/posts"
  },
  "pages": {
    "totalItems": 2,
    "selfLink": "https://www.googleapis.com/blogger/v3/blogs/2399953/pages"
  },
  "locale": {
    "language": "en",
    "country": "",
    "variant": ""
  }
}

Blog über seine URL abrufen

Du kannst einen Blog über seine URL abrufen, indem du eine HTTP-GET-Anfrage mit einem url-Parameter an den folgenden URI sendest:

https://www.googleapis.com/blogger/v3/blogs/byurl?url=blog-url

Anfragen

https://www.googleapis.com/blogger/v3/blogs/byurl?url=http://code.blogger.com/

Antwort

Wenn die Anfrage erfolgreich ist, antwortet der Server mit dem HTTP-Statuscode 200 OK und der vollständigen Darstellung des identifizierten Blogs:

{
 "kind": "blogger#blog",
 "id": "3213900",
 "name": "Blogger Developers Network",
 "description": "The official Blogger Developers Network weblog.",
 "published": "2007-02-09T10:13:10-08:00",
 "updated": "2012-04-15T19:38:01-07:00",
 "url": "http://code.blogger.com/",
 "selfLink": "https://www.googleapis.com/blogger/v3/blogs/3213900",
 "posts": {
  "totalItems": 55,
  "selfLink": "https://www.googleapis.com/blogger/v3/blogs/3213900/posts"
 },
 "pages": {
  "totalItems": 1,
  "selfLink": "https://www.googleapis.com/blogger/v3/blogs/3213900/pages"
 },
 "locale": {
  "language": "en",
  "country": "US",
  "variant": ""
 }
}

Blogs eines Nutzers abrufen

Sie können eine Liste der Blogs eines Nutzers abrufen. Senden Sie dazu eine HTTP-GET-Anfrage an den URI der Blogssammlung:

https://www.googleapis.com/blogger/v3/users/userId/blogs

Anfragen

GET https://www.googleapis.com/blogger/v3/users/self/blogs
Authorization: /* OAuth 2.0 token here */

Hinweis: Der Nutzer muss authentifiziert sein, um seine eigenen Blogs aufzulisten. Daher musst du den HTTP-Header Authorization in der GET-Anfrage angeben.

Antwort

Wenn die Anfrage erfolgreich ist, antwortet der Server mit dem HTTP-Statuscode 200 OK und der vollständigen Darstellung der Liste der Blogs des Nutzers:

{
  "kind": "blogger#blogList",
  "items": [
    {
      "kind": "blogger#blog",
      "id": "4967929378133675647",
      "name": "Brett's Test Blawg",
      "description": "",
      "published": "2010-10-06T23:33:31.662Z",
      "updated": "2011-08-08T06:50:02.005Z",
      "url": "http://brettmorgan-test-blawg.blogspot.com/",
      "selfLink": "https://www.googleapis.com/blogger/v3/blogs/4967929378133675647",
      "posts": {
        "totalItems": 13,
        "selfLink": "https://www.googleapis.com/blogger/v3/blogs/4967929378133675647/posts"
      },
      "pages": {
        "totalItems": 1,
        "selfLink": "https://www.googleapis.com/blogger/v3/blogs/4967929378133675647/pages"
      },
      "locale": {
        "language": "en",
        "country": "",
        "variant": ""
      }
    }
  ]
}

Mit Beiträgen arbeiten

Posts von einem Blog abrufen

Sie können eine Liste der Posts aus einem bestimmten Blog abrufen, indem Sie eine GET-Anfrage an den URI der Beitragssammlung senden. Der URI für eine Beitragssammlung hat folgendes Format:

https://www.googleapis.com/blogger/v3/blogs/blogId/posts

Anfragen

Hier ein Beispiel:

GET https://www.googleapis.com/blogger/v3/blogs/2399953/posts?key=YOUR-API-KEY

Ein Nutzer muss nicht authentifiziert sein, um einen öffentlichen Blog abzurufen. Die Anwendung muss bei einer öffentlichen Bloganfrage keinen Authorization-HTTP-Header einfügen, du musst aber den API-Schlüssel angeben.

Blogger verfügt auch über private Blogs, für die eine Authentifizierung erforderlich ist.

Antwort

Wenn die Anfrage erfolgreich ist, antwortet der Server mit dem HTTP-Statuscode 200 OK und der Liste der Beiträge:

{
  "kind": "blogger#postList",
  "nextPageToken": "CgkIChiAkceVjiYQ0b2SAQ",
  "items": [
    {
      "kind": "blogger#post",
      "id": "7706273476706534553",
      "blog": {
        "id": "2399953"
      },
      "published": "2011-08-01T19:58:00.000Z",
      "updated": "2011-08-01T19:58:51.947Z",
      "url": "http://buzz.blogger.com/2011/08/latest-updates-august-1st.html",
      "selfLink": "https://www.googleapis.com/blogger/v3/blogs/2399953/posts/7706273476706534553",
      "title": "Latest updates, August 1st",
      "content": "elided for readability",
      "author": {
        "id": "401465483996",
        "displayName": "Brett Wiltshire",
        "url": "http://www.blogger.com/profile/01430672582309320414",
        "image": {
          "url": "http://4.bp.blogspot.com/_YA50adQ-7vQ/S1gfR_6ufpI/AAAAAAAAAAk/1ErJGgRWZDg/S45/brett.png"
         }
      },
      "replies": {
        "totalItems": "0",
        "selfLink": "https://www.googleapis.com/blogger/v3/blogs/2399953/posts/7706273476706534553/comments"
      }
    },
    {
      "kind": "blogger#post",
      "id": "6069922188027612413",
      elided for readability
    }
  ]
}

Einen bestimmten Beitrag abrufen

Sie können einen bestimmten Post aus einem Blog abrufen, indem Sie eine GET-Anfrage an den Ressourcen-URI des Posts senden. Der URI für eine Beitragsressource hat folgendes Format:

https://www.googleapis.com/blogger/v3/blogs/blogId/posts/postId

Anfragen

GET https://www.googleapis.com/blogger/v3/blogs/2399953/posts/7706273476706534553?key=YOUR-API-KEY

Ein Nutzer muss nicht authentifiziert sein, um einen öffentlichen Blog abzurufen. Die Anwendung muss bei einer öffentlichen Bloganfrage keinen Authorization-HTTP-Header einfügen, du musst aber den API-Schlüssel angeben.

Blogger verfügt auch über private Blogs, für die eine Authentifizierung erforderlich ist.

Antwort

Wenn die Anfrage erfolgreich ist, antwortet der Server mit dem HTTP-Statuscode 200 OK und dem Inhalt des Beitrags:

{
  "kind": "blogger#post",
  "id": "7706273476706534553",
  "blog": {
    "id": "2399953"
  },
  "published": "2011-08-01T19:58:00.000Z",
  "updated": "2011-08-01T19:58:51.947Z",
  "url": "http://buzz.blogger.com/2011/08/latest-updates-august-1st.html",
  "selfLink": "https://www.googleapis.com/blogger/v3/blogs/2399953/posts/7706273476706534553",
  "title": "Latest updates, August 1st",
  "content": "elided for readability",
  "author": {
    "id": "401465483996",
    "displayName": "Brett Wiltshire",
    "url": "http://www.blogger.com/profile/01430672582309320414",
    "image": {
      "url": "http://4.bp.blogspot.com/_YA50adQ-7vQ/S1gfR_6ufpI/AAAAAAAAAAk/1ErJGgRWZDg/S45/brett.png"
    }
  },
  "replies": {
    "totalItems": "0",
    "selfLink": "https://www.googleapis.com/blogger/v3/blogs/2399953/posts/7706273476706534553/comments"
  }
}

Nach einem Beitrag suchen

Wenn Sie nach Beiträgen in einem Blog suchen möchten, senden Sie eine GET-Anfrage mit dem Suchparameter „q“ an den URI für die Post-Suche:

https://www.googleapis.com/blogger/v3/blogs/blogId/posts/search?q=query terms

Anfragen

GET https://www.googleapis.com/blogger/v3/blogs/3213900/posts/search?q=documentation&key=YOUR-API-KEY

Ein Nutzer muss nicht authentifiziert sein, um einen öffentlichen Blog abzurufen. Die Anwendung muss bei einer öffentlichen Bloganfrage keinen Authorization-HTTP-Header einfügen, du musst aber den API-Schlüssel angeben.

Blogger verfügt auch über private Blogs, für die eine Authentifizierung erforderlich ist.

Antwort

Wenn die Anfrage erfolgreich ist, antwortet der Server mit dem HTTP-Statuscode 200 OK und dem Inhalt des Beitrags:

{
  "kind": "blogger#postList",
  "nextPageToken": "CgkIChiAj86CpB8QzJTEAQ",
  "items": [
  {
    "kind": "blogger#post",
    "id": "1387873546480002228",
    "blog": {
      "id": "3213900"
    },
    "published": "2012-03-23T01:58:00-07:00",
    "updated": "2012-03-23T01:58:12-07:00",
    "url": "http://code.blogger.com/2012/03/blogger-documentation-has-moved-to.html",
    "selfLink": "https://www.googleapis.com/blogger/v3/blogs/3213900/posts/1387873546480002228",
    "title": "Blogger Documentation has moved to developers.google.com",
    "content": "content elided for readability",
    "author": {
      "id": "16258312240222542576",
      "displayName": "Brett Morgan",
      "url": "http://www.blogger.com/profile/16258312240222542576",
      "image": {
        "url": "https://resources.blogblog.com/img/b16-rounded.gif"
      }
    },
    "replies": {
      "totalItems": "0",
      "selfLink": "https://www.googleapis.com/blogger/v3/blogs/3213900/posts/1387873546480002228/comments"
    }
  },
  ...
  ]
}

Beitrag hinzufügen

Du kannst einen Post für einen Blog hinzufügen, indem du eine POST-Anfrage mit dem JSON-Text eines Posts an den URI der Beitragssammlung sendest:

https://www.googleapis.com/blogger/v3/blogs/blogId/posts/

Anfragen

POST https://www.googleapis.com/blogger/v3/blogs/8070105920543249955/posts/
Authorization: /* OAuth 2.0 token here */
Content-Type: application/json

{
  "kind": "blogger#post",
  "blog": {
    "id": "8070105920543249955"
  },
  "title": "A new post",
  "content": "With <b>exciting</b> content..."
}

Du musst authentifiziert sein, um einen Beitrag erstellen zu können.

Antwort

Wenn die Anfrage erfolgreich ist, antwortet der Server mit dem HTTP-Statuscode 200 OK und dem Inhalt des Beitrags:

{
 "kind": "blogger#post",
 "id": "6819100329896798058",
 "blog": {
  "id": "8070105920543249955"
 },
 "published": "2012-05-20T20:08:00-07:00",
 "updated": "2012-05-20T20:08:35-07:00",
 "url": "http://brettmorgan-test2.blogspot.com/2012/05/new-post.html",
 "selfLink": "https://www.googleapis.com/blogger/v3/blogs/8070105920543249955/posts/6819100329896798058",
 "title": "A new post",
 "content": "With <b>exciting</b> content...",
 "author": {
  "id": "16258312240222542576",
  "displayName": "Brett Morgan",
  "url": "http://www.blogger.com/profile/16258312240222542576",
  "image": {
   "url": "https://resources.blogblog.com/img/b16-rounded.gif"
  }
 },
 "replies": {
  "totalItems": "0",
  "selfLink": "https://www.googleapis.com/blogger/v3/blogs/8070105920543249955/posts/6819100329896798058/comments"
 }
}

Einen Beitrag löschen

Zum Löschen eines Posts für einen Blog senden Sie eine DELETE-Anfrage an den Ressourcen-URI des Posts:

https://www.googleapis.com/blogger/v3/blogs/blogId/posts/postId

Anfragen

Hier ein Beispiel:

DELETE https://www.googleapis.com/blogger/v3/blogs/8070105920543249955/posts/6819100329896798058
Authorization: /* OAuth 2.0 token here */

Du musst authentifiziert sein, um einen Beitrag löschen zu können.

Antwort

Wenn die Anfrage erfolgreich ist, antwortet der Server mit dem HTTP-Statuscode 200 OK.

Beitrag anhand seines Pfads abrufen

Du kannst einen Post aus einem Blog abrufen, indem du eine GET-Anfrage an den nach Pfad-URI des Posts mit einem path-Parameter sendest. Der URI für eine Anfrage nach Pfad hat folgendes Format:

https://www.googleapis.com/blogger/v3/blogs/blogId/posts/bypath?path=post-path

Anfragen

https://www.googleapis.com/blogger/v3/blogs/2399953/posts/bypath?path=/2011/08/latest-updates-august-1st.html&key=YOUR-API-KEY

Ein Nutzer muss nicht authentifiziert sein, um einen öffentlichen Blog abzurufen. Die Anwendung muss bei einer öffentlichen Bloganfrage keinen Authorization-HTTP-Header einfügen, du musst aber den API-Schlüssel angeben.

Blogger verfügt auch über private Blogs, für die eine Authentifizierung erforderlich ist.

Antwort

Wenn die Anfrage erfolgreich ist, antwortet der Server mit dem HTTP-Statuscode 200 OK und dem Inhalt des Beitrags:

{
  "kind": "blogger#post",
  "id": "7706273476706534553",
  "blog": {
    "id": "2399953"
  },
  "published": "2011-08-01T19:58:00.000Z",
  "updated": "2011-08-01T19:58:51.947Z",
  "url": "http://buzz.blogger.com/2011/08/latest-updates-august-1st.html",
  "selfLink": "https://www.googleapis.com/blogger/v3/blogs/2399953/posts/7706273476706534553",
  "title": "Latest updates, August 1st",
  "content": "elided for readability",
  "author": {
    "id": "401465483996",
    "displayName": "Brett Wiltshire",
    "url": "http://www.blogger.com/profile/01430672582309320414",
    "image": {
      "url": "http://4.bp.blogspot.com/_YA50adQ-7vQ/S1gfR_6ufpI/AAAAAAAAAAk/1ErJGgRWZDg/S45/brett.png"
    }
  },
  "replies": {
    "totalItems": "0",
    "selfLink": "https://www.googleapis.com/blogger/v3/blogs/2399953/posts/7706273476706534553/comments"
  }
}

Aktualisieren von Beiträgen

Zum Aktualisieren eines Posts für einen Blog senden Sie eine PUT-Anfrage mit dem JSON-Text des Posts an den Ressourcen-URI des Posts:

https://www.googleapis.com/blogger/v3/blogs/blogId/posts/postId

Anfragen

PUT https://www.googleapis.com/blogger/v3/blogs/8070105920543249955/posts/3445355871727114160
Authorization: /* OAuth 2.0 token here */
Content-Type: application/json

{
 "kind": "blogger#post",
 "id": "3445355871727114160",
 "blog": {
  "id": "8070105920543249955"
 },
 "url": "http://brettmorgan-test2.blogspot.com/2012/05/new-post_20.html",
 "selfLink": "https://www.googleapis.com/blogger/v3/blogs/8070105920543249955/posts/3445355871727114160",
 "title": "An updated post",
 "content": "With really <b>exciting</b> content..."
}

Du musst authentifiziert sein, um einen Beitrag aktualisieren zu können.

Antwort

Wenn die Anfrage erfolgreich ist, antwortet der Server mit dem HTTP-Statuscode 200 OK und dem Inhalt des Beitrags:

{
 "kind": "blogger#post",
 "id": "6819100329896798058",
 "blog": {
  "id": "8070105920543249955"
 },
 "published": "2012-05-20T20:08:00-07:00",
 "updated": "2012-05-20T20:08:35-07:00",
 "url": "http://brettmorgan-test2.blogspot.com/2012/05/new-post.html",
 "selfLink": "https://www.googleapis.com/blogger/v3/blogs/8070105920543249955/posts/6819100329896798058",
 "title": "An updated post",
 "content": "With really <b>exciting</b> content...",
 "author": {
  "id": "16258312240222542576",
  "displayName": "Brett Morgan",
  "url": "http://www.blogger.com/profile/16258312240222542576",
  "image": {
   "url": "https://resources.blogblog.com/img/b16-rounded.gif"
  }
 },
 "replies": {
  "totalItems": "0",
  "selfLink": "https://www.googleapis.com/blogger/v3/blogs/8070105920543249955/posts/6819100329896798058/comments"
 }
}

Beitrag mit Patch-Semantik aktualisieren

Sie können einen Post mit Patch-Semantik aktualisieren, indem Sie eine PATCH-Anfrage an den Post-Ressourcen-URI mit einem Post-JSON-Text senden:

https://www.googleapis.com/blogger/v3/blogs/blogId/posts/postId

Anfragen

Hier ein Beispiel:

PATCH https://www.googleapis.com/blogger/v3/blogs/8070105920543249955/posts/3445355871727114160
Authorization: /* OAuth 2.0 token here */
Content-Type: application/json

{
 "content": "With absolutely <b>fabulous</b> content..."
}

Du musst authentifiziert sein, um einen Beitrag aktualisieren zu können.

Antwort

Wenn die Anfrage erfolgreich ist, antwortet der Server mit dem HTTP-Statuscode 200 OK und dem Inhalt des Beitrags:

{
 "kind": "blogger#post",
 "id": "6819100329896798058",
 "blog": {
  "id": "8070105920543249955"
 },
 "published": "2012-05-20T20:08:00-07:00",
 "updated": "2012-05-20T20:08:35-07:00",
 "url": "http://brettmorgan-test2.blogspot.com/2012/05/new-post.html",
 "selfLink": "https://www.googleapis.com/blogger/v3/blogs/8070105920543249955/posts/6819100329896798058",
 "title": "An updated post",
 "content": "With absolutely <b>fabulous</b> content...",
 "author": {
  "id": "16258312240222542576",
  "displayName": "Brett Morgan",
  "url": "http://www.blogger.com/profile/16258312240222542576",
  "image": {
   "url": "https://resources.blogblog.com/img/b16-rounded.gif"
  }
 },
 "replies": {
  "totalItems": "0",
  "selfLink": "https://www.googleapis.com/blogger/v3/blogs/8070105920543249955/posts/6819100329896798058/comments"
 }
}

Arbeiten mit Kommentaren

Kommentare zu einem Beitrag abrufen

Sie können eine Liste der Kommentare für einen Beitrag abrufen, indem Sie eine GET-Anfrage an den URI der Kommentarsammlung senden. Der URI für eine Kommentarsammlung hat folgendes Format:

https://www.googleapis.com/blogger/v3/blogs/blogId/posts/postId/comments

Anfragen

GET https://www.googleapis.com/blogger/v3/blogs/2399953/posts/6069922188027612413/comments?key=YOUR-API-KEY

„Ein Nutzer muss nicht authentifiziert sein, um einen öffentlichen Blog abzurufen. Die Anwendung muss bei einer öffentlichen Bloganfrage keinen Authorization-HTTP-Header einfügen, du musst aber den API-Schlüssel angeben.

Blogger verfügt auch über private Blogs, für die eine Authentifizierung erforderlich ist.

Antwort

Wenn die Anfrage erfolgreich ist, antwortet der Server mit dem HTTP-Statuscode 200 OK und der Liste der Kommentare:

{
  "kind": "blogger#commentList",
  "nextPageToken": "CgkIFBDwjvDXlyYQ0b2SARj9mZe9n8KsnlQ",
  "prevPageToken": "CgkIFBisvMGRlyYQ0b2SARj9mZe9n8KsnlQ",
  "items": [
    {
       "kind": "blogger#comment",
       "id": "9200761938824362519",
       "post": {
         "id": "6069922188027612413"
       },
       "blog": {
         "id": "2399953"
       },
       "published": "2011-07-28T19:19:57.740Z",
       "updated": "2011-07-28T21:29:42.015Z",
       "selfLink": "https://www.googleapis.com/blogger/v3/blogs/2399953/posts/6069922188027612413/comments/9200761938824362519",
       "content": "elided",
       "author": {
         "id": "530579030283",
         "displayName": "elided",
         "url": "elided",
         "image": {
           "url": "elided"
         }
       }
    },
    {
      "kind": "blogger#comment",
      "id": "400101178920857170",
      elided for readability
    }
  ]
}

Einen bestimmten Kommentar abrufen

Sie können einen bestimmten Kommentar aus einem Beitrag abrufen, indem Sie eine GET-Anfrage an den URI der Kommentarressource senden. Der URI für eine Kommentarressource hat folgendes Format:

https://www.googleapis.com/blogger/v3/blogs/blogId/posts/postId/comments/commentId

Anfragen

GET https://www.googleapis.com/blogger/v3/blogs/2399953/posts/6069922188027612413/comments/9200761938824362519?key=YOUR-API-KEY

„Ein Nutzer muss nicht authentifiziert sein, um einen öffentlichen Blog abzurufen. Die Anwendung muss bei einer öffentlichen Bloganfrage keinen Authorization-HTTP-Header einfügen, du musst aber den API-Schlüssel angeben.

Blogger verfügt auch über private Blogs, für die eine Authentifizierung erforderlich ist.

Antwort

Wenn die Anfrage erfolgreich ist, antwortet der Server mit dem HTTP-Statuscode 200 OK und den Kommentardaten:

{
  "kind": "blogger#comment",
  "id": "9200761938824362519",
  "post": {
    "id": "6069922188027612413"
  },
  "blog": {
    "id": "2399953"
  },
  "published": "2011-07-28T19:19:57.740Z",
  "updated": "2011-07-28T21:29:42.015Z",
  "selfLink": "https://www.googleapis.com/blogger/v3/blogs/2399953/posts/6069922188027612413/comments/9200761938824362519",
  "content": "elided",
  "author": {
    "id": "530579030283",
    "displayName": "elided",
    "url": "elided",
    "image": {
      "url": "elided"
    }
  }
}

Mit Seiten arbeiten

Seiten für einen Blog abrufen

Wenn Sie eine Liste mit Seiten für einen Blog abrufen möchten, senden Sie eine GET-Anfrage an den URI der Seitensammlung. Der URI für eine Seitensammlung hat folgendes Format:

https://www.googleapis.com/blogger/v3/blogs/blogId/pages

Anfragen

GET https://www.googleapis.com/blogger/v3/blogs/4967929378133675647/pages?key=YOUR-API-KEY

„Ein Nutzer muss nicht authentifiziert sein, um einen öffentlichen Blog abzurufen. Die Anwendung muss bei einer öffentlichen Bloganfrage keinen Authorization-HTTP-Header einfügen, du musst aber den API-Schlüssel angeben.

Blogger verfügt auch über private Blogs, für die eine Authentifizierung erforderlich ist.

Antwort

Wenn die Anfrage erfolgreich ist, antwortet der Server mit dem HTTP-Statuscode 200 OK und der Liste der Seiten:

{
  "kind": "blogger#pageList",
  "items": [
    {
      "kind": "blogger#page",
      "id": "273541696466681878",
      "blog": {
        "id": "4967929378133675647"
      },
      "published": "2011-07-14T16:16:00.000Z",
      "updated": "2011-07-14T16:16:23.602Z",
      "url": "http://brettmorgan-test-blawg.blogspot.com/p/static-content.html",
      "selfLink": "https://www.googleapis.com/blogger/v3/blogs/4967929378133675647/pages/273541696466681878",
      "title": "Static Content",
      "content": "elided for readability",
      "author": {
        "id": "901569848744",
        "displayName": "brett",
        "url": "http://www.blogger.com/profile/16258312240222542576",
        "image": {
          "url": "https://resources.blogblog.com/img/b16-rounded.gif"
        }
      }
    }
  ]
}

Bestimmte Seite abrufen

Sie können eine bestimmte Seite aus einem Blog abrufen, indem Sie eine GET-Anfrage an den URI der Seitenressource senden. Der URI für eine Seitenressource hat folgendes Format:

https://www.googleapis.com/blogger/v3/blogs/blogId/pages/pageId

Anfragen

GET https://www.googleapis.com/blogger/v3/blogs/4967929378133675647/pages/273541696466681878?key=YOUR-API-KEY

„Ein Nutzer muss nicht authentifiziert sein, um einen öffentlichen Blog abzurufen. Die Anwendung muss bei einer öffentlichen Bloganfrage keinen Authorization-HTTP-Header einfügen, du musst aber den API-Schlüssel angeben.

Blogger verfügt auch über private Blogs, für die eine Authentifizierung erforderlich ist.

Antwort

Wenn die Anfrage erfolgreich ist, antwortet der Server mit dem HTTP-Statuscode 200 OK und den Seitendaten:

{
  "kind": "blogger#page",
  "id": "273541696466681878",
  "blog": {
    "id": "4967929378133675647"
  },
  "published": "2011-07-14T16:16:00.000Z",
  "updated": "2011-07-14T16:16:23.602Z",
  "url": "http://brettmorgan-test-blawg.blogspot.com/p/static-content.html",
  "selfLink": "https://www.googleapis.com/blogger/v3/blogs/4967929378133675647/pages/273541696466681878",
  "title": "Static Content",
  "content": "elided for readability",
  "author": {
    "id": "901569848744",
    "displayName": "brett",
    "url": "http://www.blogger.com/profile/16258312240222542576",
    "image": {
      "url": "https://resources.blogblog.com/img/b16-rounded.gif"
    }
  }
}

Mit Nutzern arbeiten

Nutzer abrufen

Sie können Nutzerinformationen abrufen, indem Sie eine HTTP-GET-Anfrage an den Ressourcen-URI des Nutzers senden:

https://www.googleapis.com/blogger/v3/users/userId

Anfragen

GET https://www.googleapis.com/blogger/v3/users/self
Authorization: /* OAuth 2.0 token here */

Hinweis: Der Nutzer muss authentifiziert sein, um seine eigenen Informationen aufzulisten. Deshalb müssen Sie in der GET-Anfrage den HTTP-Header Authorization angeben.

Antwort

Wenn die Anfrage erfolgreich ist, antwortet der Server mit dem HTTP-Statuscode 200 OK und einem Link zu einer Liste der Blogs des Nutzers:

{
  "kind": "blogger#user",
  "id": "901569848744",
  "selfLink": "https://www.googleapis.com/blogger/v3/users/901569848744",
  "blogs": {
    "selfLink": "https://www.googleapis.com/blogger/v3/users/901569848744/blogs"
  }
}

Standardabfrageparameter

Die folgenden Abfrageparameter können mit allen Methoden und Ressourcen in den Blogger-APIs verwendet werden.

Abfrageparameter, die für alle Blogger API-Vorgänge gelten, sind unter Systemparameter dokumentiert.