Blogger API: API verwenden

Mit der Blogger API können Sie Blogger-Inhalte mithilfe der REST APIs in Ihre Anwendung einbinden. Bevor Sie beginnen, müssen Sie die Autorisierung einrichten.

Einführung

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 ihre Gedanken fortlaufend veröffentlichen können.

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

Anfragen autorisieren und Ihre Anwendung identifizieren

Alle Anfragen, die Ihre Anwendung an die Blogger APIs sendet, müssen 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. eine Anfrage nach privaten Daten einer Person), muss die Anwendung ein OAuth 2.0-Token mit der Anfrage bereitstellen. Die Anwendung kann auch den API-Schlüssel bereitstellen, muss dies jedoch nicht.
• 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 OAuth 2.0-Bereich 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 für öffentliche Daten müssen mit einer Kennung erfolgen. 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.

Mit Blogs arbeiten

Blog abrufen

Sie können Informationen für einen bestimmten Blog abrufen, indem Sie eine HTTP-GET-Anfrage an den URI des Blogs senden. Der URI für einen Blog hat das folgende 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 den Authorization-HTTP-Header für eine öffentliche Bloganfrage nicht angeben. Du musst jedoch den API-Schlüssel angeben.

Blogger hat auch private Blogs, die eine Authentifizierung erfordern.

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": ""
  }
}

Einen Blog über seine URL abrufen

Du kannst einen Blog über dessen URL abrufen, indem du eine HTTP-GET-Anfrage an den folgenden URI mit dem Parameter url 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 mit den Blogs eines Nutzers abrufen, indem Sie eine HTTP-GET-Anfrage an den Sammlungs-URI der Blogs senden:

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 auflisten zu können. Daher müssen Sie den HTTP-Header Authorization mit der Anfrage GET angeben.

Antwort

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

{
  "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 aus einem Blog abrufen

Wenn Sie eine Liste mit Posts eines bestimmten Blogs abrufen möchten, senden Sie eine GET-Anfrage an den URI für die Posts-Sammlung. Der URI für eine Posts-Sammlung hat das folgende 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 den Authorization-HTTP-Header für eine öffentliche Bloganfrage nicht angeben. Du musst jedoch den API-Schlüssel angeben.

Blogger hat auch private Blogs, die eine Authentifizierung erfordern.

Antwort

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

{
  "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 der 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 den Authorization-HTTP-Header für eine öffentliche Bloganfrage nicht angeben. Du musst jedoch den API-Schlüssel angeben.

Blogger hat auch private Blogs, die eine Authentifizierung erfordern.

Antwort

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

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

Du kannst nach Posts aus einem Blog suchen, indem du eine GET-Anfrage mit dem Suchparameter „q“ an den Postsuch-URI sendest:

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 den Authorization-HTTP-Header für eine öffentliche Bloganfrage nicht angeben. Du musst jedoch den API-Schlüssel angeben.

Blogger hat auch private Blogs, die eine Authentifizierung erfordern.

Antwort

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

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

Sie können einen Beitrag für einen Blog hinzufügen. Senden Sie dazu eine POST-Anfrage mit einem JSON-Textkörper an den Sammlungs-URI des Beitrags:

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

Sie müssen authentifiziert sein, um einen Beitrag zu erstellen.

Antwort

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

{
 "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"
 }
}

Beiträge löschen

Sie können einen Beitrag für einen Blog löschen, indem Sie eine DELETE-Anfrage an den Ressourcen-URI des Beitrags senden:

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

Sie müssen authentifiziert sein, um einen Beitrag zu löschen.

Antwort

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

Beitrag nach Pfad abrufen

Sie können einen Post aus einem Blog abrufen, indem Sie eine GET-Anfrage mit dem Parameter path an den URIs der Posts bypath senden. Der URI für eine Anfrage nach Beiträgen nach Pfad hat das folgende 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 den Authorization-HTTP-Header für eine öffentliche Bloganfrage nicht angeben. Du musst jedoch den API-Schlüssel angeben.

Blogger hat auch private Blogs, die eine Authentifizierung erfordern.

Antwort

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

{
  "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"
  }
}

Beitrag wird aktualisiert

Sie können einen Beitrag für einen Blog aktualisieren. Senden Sie dazu eine PUT-Anfrage mit einem JSON-Beitragstext an den Ressourcen-URI des Beitrags:

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

Sie müssen authentifiziert sein, um einen Beitrag zu aktualisieren.

Antwort

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

{
 "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 Patchsemantik aktualisieren

Sie können einen Beitrag mit Patch-Semantik aktualisieren. Senden Sie dazu eine PATCH-Anfrage mit einem JSON-Beitragstext an den Ressourcen-URI des Beitrags:

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

Sie müssen authentifiziert sein, um einen Beitrag zu aktualisieren.

Antwort

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

{
 "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"
 }
}

Mit Kommentaren arbeiten

Kommentare für einen Beitrag abrufen

Wenn du eine Liste mit Kommentaren für einen Beitrag abrufen möchtest, sende eine GET-Anfrage an den Sammlungs-URI für Kommentare. Der URI für eine Kommentarsammlung hat das folgende 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 den Authorization-HTTP-Header für eine öffentliche Bloganfrage nicht angeben. Du musst jedoch den API-Schlüssel angeben.

Blogger hat auch private Blogs, die eine Authentifizierung erfordern.

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 Ressourcen-URI für Kommentare senden. Der URI für eine Kommentarressource hat das folgende 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 den Authorization-HTTP-Header für eine öffentliche Bloganfrage nicht angeben. Du musst jedoch den API-Schlüssel angeben.

Blogger hat auch private Blogs, die eine Authentifizierung erfordern.

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 du eine Liste mit den Seiten eines Blogs abrufen möchtest, sende eine GET-Anfrage an den Sammlungs-URI der Seite. Der URI für eine Seitensammlung hat das folgende 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 den Authorization-HTTP-Header für eine öffentliche Bloganfrage nicht angeben. Du musst jedoch den API-Schlüssel angeben.

Blogger hat auch private Blogs, die eine Authentifizierung erfordern.

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"
        }
      }
    }
  ]
}

Eine bestimmte Seite abrufen

Wenn du eine bestimmte Seite aus einem Blog abrufen möchtest, sende eine GET-Anfrage an den Ressourcen-URI der Seite. Der URI für eine Seitenressource hat das folgende 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 den Authorization-HTTP-Header für eine öffentliche Bloganfrage nicht angeben. Du musst jedoch den API-Schlüssel angeben.

Blogger hat auch private Blogs, die eine Authentifizierung erfordern.

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 die Informationen eines Nutzers 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 auflisten zu können. Daher musst du den Authorization-HTTP-Header mit der GET-Anfrage 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 APIs-Vorgänge gelten, sind unter Systemparameter dokumentiert.