API Blogger: Utilisation de l'API

L'API Blogger vous permet d'intégrer du contenu Blogger dans votre application à l'aide des API REST. Avant de commencer, vous devez configurer les autorisations.

Introduction

Ce document est destiné aux développeurs qui souhaitent créer des applications pouvant interagir avec l'API Blogger. Blogger est un outil de création de sites Web permettant aux internautes de publier leurs idées de façon continue.

Si vous ne connaissez pas les concepts de Blogger, nous vous recommandons de lire la section Premiers pas avant de commencer à coder.

Autoriser les requêtes et identifier votre application

Chaque requête envoyée par votre application aux API Blogger doit permettre à Google d'identifier votre application. Pour cela, vous pouvez procéder de deux manières : à l'aide d'un jeton OAuth 2.0 (qui autorise également la requête) et/ou à l'aide de la clé API de l'application. Voici comment déterminer l'option à utiliser :

• Si la requête nécessite une autorisation (par exemple, une demande de données privées d'un individu), l'application doit fournir un jeton OAuth 2.0 avec la requête. L'application peut également fournir la clé API, mais ce n'est pas obligatoire.
• Si la demande ne nécessite pas d'autorisation (par exemple, s'il s'agit d'une demande de données publiques), l'application doit fournir soit la clé API, soit un jeton OAuth 2.0, soit les deux, selon ce qui vous convient le mieux.

À propos des protocoles d'autorisation

Votre application doit autoriser les requêtes via le protocole OAuth 2.0. Les autres protocoles d'autorisation ne sont pas acceptés. Si votre application utilise la fonctionnalité Se connecter avec Google, certains aspects de l'autorisation sont traités pour vous.

Autoriser des requêtes avec OAuth 2.0

Les requêtes adressées aux API Blogger concernant des données utilisateur non publiques doivent être autorisées par un utilisateur authentifié.

Ce processus est facilité par l'utilisation d'un ID client OAuth.

Obtenir un ID client OAuth

Vous pouvez également en créer un sur la page Identifiants.

Les détails de la procédure d'autorisation (ou "flux") concernant OAuth 2.0 varient légèrement selon le type d'application que vous développez. La procédure générale suivante s'applique à tous les types d'applications :

1. Lorsque votre application requiert l'accès aux données utilisateur, elle demande à Google un champ d'application particulier.
2. Google affiche alors un écran d'autorisation, dans lequel l'utilisateur est invité à autoriser votre application à demander certaines de ses données.
3. Si l'utilisateur accepte, Google attribue à votre application un jeton d'accès temporaire.
4. Votre application demande des données utilisateur en joignant le jeton d'accès à la requête.
5. Dès lors que Google valide la requête et le jeton, les données demandées sont renvoyées.

Certains flux comportent d'autres étapes, comme l'utilisation de jetons d'actualisation afin d'obtenir de nouveaux jetons d'accès. Pour en savoir plus sur les flux concernant divers types d'applications, consultez la documentation OAuth 2.0 de Google.

Voici les informations concernant le champ d'application OAuth 2.0 pour les API Blogger:

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

Pour demander l'accès via OAuth 2.0, vous avez besoin du champ d'application ainsi que des informations fournies par Google lors de l'enregistrement de l'application (l'ID client et le code secret du client, par exemple).

Conseil : Les bibliothèques clientes des API Google peuvent gérer une partie de la procédure d'autorisation à votre place. Elles sont proposées pour une grande variété de langages de programmation. Pour en savoir plus, explorez les bibliothèques clientes et les exemples de code présentés sur la page Installer les bibliothèques clientes.

Obtenir et utiliser une clé API

Les requêtes adressées aux API Blogger portant sur des données publiques doivent être accompagnées d'un identifiant, qui peut être une clé API ou un jeton d'accès.

Obtenir une clé

Vous pouvez également en créer un sur la page Identifiants.

Une fois la clé API obtenue, votre application peut ajouter le paramètre de requête key=yourAPIKey à toutes les URL de requête.

La clé API peut s'intégrer aux URL en toute sécurité et ne nécessite pas d'encodage.

Travailler avec des blogs

Récupérer un blog

Vous pouvez récupérer des informations concernant un blog particulier en envoyant une requête HTTP GET à l'URI du blog. L'URI d'un blog a le format suivant:

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

Requête

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

Un utilisateur n'a pas besoin d'être authentifié pour récupérer un blog public. L'application n'a pas besoin d'inclure l'en-tête HTTP Authorization pour une requête de blog public. Toutefois, vous devez fournir la clé API.

Blogger dispose également de blogs privés nécessitant une authentification.

Réponse

Si la requête aboutit, le serveur répond avec un code d'état HTTP 200 OK et les données du blog:

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

Récupérer un blog à l'aide de son URL

Vous pouvez récupérer un blog à l'aide de son URL en envoyant une requête HTTP GET à l'URI suivant avec un paramètre url:

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

Requête

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

Réponse

Si la requête aboutit, le serveur répond avec un code d'état HTTP 200 OK et la représentation complète du blog identifié:

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

Récupérer les blogs d'un utilisateur

Vous pouvez récupérer la liste des blogs d'un utilisateur en envoyant une requête HTTP GET à l'URI de la collection de blogs:

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

Requête

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

Remarque: L'utilisateur doit être authentifié pour répertorier ses propres blogs. Vous devez donc fournir l'en-tête HTTP Authorization avec la requête GET.

Réponse

Si la requête aboutit, le serveur répond avec un code d'état HTTP 200 OK et la représentation complète de la liste des blogs de l'utilisateur:

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

Gérer les posts

Récupérer des articles d'un blog

Vous pouvez récupérer la liste des articles d'un blog donné en envoyant une requête GET à l'URI de la collection d'articles. L'URI d'une collection de posts a le format suivant:

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

Requête

Voici un exemple :

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

Un utilisateur n'a pas besoin d'être authentifié pour récupérer un blog public. L'application n'a pas besoin d'inclure l'en-tête HTTP Authorization pour une requête de blog public. Toutefois, vous devez fournir la clé API.

Blogger dispose également de blogs privés nécessitant une authentification.

Réponse

Si la requête aboutit, le serveur répond avec un code d'état HTTP 200 OK et la liste des 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
    }
  ]
}

Récupérer un post spécifique

Vous pouvez récupérer un article spécifique d'un blog en envoyant une requête GET à l'URI de la ressource "Posts". L'URI d'une ressource Posts a le format suivant:

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

Requête

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

Un utilisateur n'a pas besoin d'être authentifié pour récupérer un blog public. L'application n'a pas besoin d'inclure l'en-tête HTTP Authorization pour une requête de blog public. Toutefois, vous devez fournir la clé API.

Blogger dispose également de blogs privés nécessitant une authentification.

Réponse

Si la requête aboutit, le serveur répond avec un code d'état HTTP 200 OK et le contenu du post:

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

Recherche d'un post

Vous pouvez rechercher des articles d'un blog en envoyant une requête GET à l'URI de recherche d'articles avec le paramètre de requête de recherche q:

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

Requête

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

Un utilisateur n'a pas besoin d'être authentifié pour récupérer un blog public. L'application n'a pas besoin d'inclure l'en-tête HTTP Authorization pour une requête de blog public. Toutefois, vous devez fournir la clé API.

Blogger dispose également de blogs privés nécessitant une authentification.

Réponse

Si la requête aboutit, le serveur répond avec un code d'état HTTP 200 OK et le contenu du post:

{
  "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"
    }
  },
  ...
  ]
}

Ajout d'un post

Vous pouvez ajouter un article pour un blog en envoyant une requête POST à l'URI de la collection d'articles avec un corps JSON d'article:

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

Requête

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

Vous devez être authentifié pour pouvoir créer un post.

Réponse

Si la requête aboutit, le serveur répond avec un code d'état HTTP 200 OK et le contenu du post:

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

Supprimer un post

Vous pouvez supprimer un article de blog en envoyant une requête DELETE à l'URI de la ressource d'article:

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

Requête

Voici un exemple :

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

Vous devez être authentifié pour supprimer un post.

Réponse

Si la requête aboutit, le serveur répond avec un code d'état HTTP 200 OK.

Récupérer un post par son chemin d'accès

Vous pouvez récupérer un article d'un blog en envoyant une requête GET à l'URI du chemin d'accès des articles avec un paramètre path. L'URI d'une requête "posts par chemin d'accès" a le format suivant:

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

Requête

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

Un utilisateur n'a pas besoin d'être authentifié pour récupérer un blog public. L'application n'a pas besoin d'inclure l'en-tête HTTP Authorization pour une requête de blog public. Toutefois, vous devez fournir la clé API.

Blogger dispose également de blogs privés nécessitant une authentification.

Réponse

Si la requête aboutit, le serveur répond avec un code d'état HTTP 200 OK et le contenu du post:

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

Mise à jour d'un post...

Vous pouvez mettre à jour un article de blog en envoyant une requête PUT à l'URI de la ressource d'article avec un corps JSON d'article:

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

Requête

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

Vous devez être authentifié pour mettre à jour un post.

Réponse

Si la requête aboutit, le serveur répond avec un code d'état HTTP 200 OK et le contenu du post:

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

Mettre à jour une publication avec la sémantique patch

Vous pouvez mettre à jour un article avec la sémantique "patch" en envoyant une requête PATCH à l'URI de la ressource d'article avec un corps JSON d'article:

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

Requête

Voici un exemple :

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

Vous devez être authentifié pour mettre à jour un post.

Réponse

Si la requête aboutit, le serveur répond avec un code d'état HTTP 200 OK et le contenu du post:

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

Utiliser les commentaires

Récupérer des commentaires sur un post

Pour récupérer la liste des commentaires d'un article, envoyez une requête GET à l'URI de la collection de commentaires. L'URI d'une collection de commentaires a le format suivant:

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

Requête

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

"Un utilisateur n'a pas besoin d'être authentifié pour récupérer un blog public. L'application n'a pas besoin d'inclure l'en-tête HTTP Authorization pour une requête de blog public. Toutefois, vous devez fournir la clé API.

Blogger dispose également de blogs privés nécessitant une authentification.

Réponse

Si la requête aboutit, le serveur répond avec un code d'état HTTP 200 OK et la liste de commentaires:

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

Récupérer un commentaire spécifique

Vous pouvez récupérer un commentaire spécifique d'un article en envoyant une requête GET à l'URI de la ressource de commentaires. L'URI d'une ressource de commentaires a le format suivant:

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

Requête

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

"Un utilisateur n'a pas besoin d'être authentifié pour récupérer un blog public. L'application n'a pas besoin d'inclure l'en-tête HTTP Authorization pour une requête de blog public. Toutefois, vous devez fournir la clé API.

Blogger dispose également de blogs privés nécessitant une authentification.

Réponse

Si la requête aboutit, le serveur répond avec un code d'état HTTP 200 OK et les données de commentaire:

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

Travailler avec des pages

Récupérer les pages d'un blog

Vous pouvez récupérer la liste des pages d'un blog en envoyant une requête GET à l'URI de la collection de pages. L'URI d'une collection de pages a le format suivant:

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

Requête

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

"Un utilisateur n'a pas besoin d'être authentifié pour récupérer un blog public. L'application n'a pas besoin d'inclure l'en-tête HTTP Authorization pour une requête de blog public. Toutefois, vous devez fournir la clé API.

Blogger dispose également de blogs privés nécessitant une authentification.

Réponse

Si la requête aboutit, le serveur répond avec un code d'état HTTP 200 OK et la liste des pages:

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

Récupérer une page spécifique

Vous pouvez récupérer une page spécifique d'un blog en envoyant une requête GET à l'URI de la ressource de pages. L'URI d'une ressource "Pages" a le format suivant:

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

Requête

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

"Un utilisateur n'a pas besoin d'être authentifié pour récupérer un blog public. L'application n'a pas besoin d'inclure l'en-tête HTTP Authorization pour une requête de blog public. Toutefois, vous devez fournir la clé API.

Blogger dispose également de blogs privés nécessitant une authentification.

Réponse

Si la requête aboutit, le serveur répond avec un code d'état HTTP 200 OK et les données de page:

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

Travailler avec des utilisateurs

Récupérer un utilisateur

Vous pouvez récupérer les informations d'un utilisateur en envoyant une requête HTTP GET à l'URI de la ressource utilisateur:

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

Requête

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

Remarque: L'utilisateur doit être authentifié pour répertorier ses propres informations. Vous devez donc fournir l'en-tête HTTP Authorization avec la requête GET.

Réponse

Si la requête aboutit, le serveur répond avec un code d'état HTTP 200 OK et un lien vers une liste des blogs de l'utilisateur:

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

Paramètres de requête standards

Les paramètres de requête suivants peuvent être utilisés avec toutes les méthodes et toutes les ressources des API Blogger.

Les paramètres de requête qui s'appliquent à toutes les opérations des API Blogger sont décrits sur la page Paramètres système.