Cette page a été traduite par l'API Cloud Translation.

Guide du développeur: Protocole

Important : La version 2.0 de l'API Google Data ne sera plus prise en charge à partir du 30 septembre 2024. Pour assurer un fonctionnement continu, mettez à jour vos applications qui dépendent de la version 2.0 de l'API Google Data vers la dernière version de l'API. Pour accéder à la version la plus récente, utilisez les liens de la barre de navigation de gauche. Remarque: Bien que certaines requêtes GET (telles que les posts de fiches) continuent d'être acceptées en tant qu'URL de flux, il existe de légères différences au niveau de leur comportement. Pour en savoir plus, consultez la documentation de l'aide Blogger.

L'API Blogger Data permet aux applications clientes d'afficher et de mettre à jour du contenu Blogger sous la forme de flux Google Data API.

Votre application cliente peut utiliser l'API Blogger Data pour créer des articles de blog, modifier ou supprimer des articles de blog existants, et rechercher des articles de blog répondant à des critères particuliers.

En plus de présenter les fonctionnalités de l'API Data de Blogger, ce document fournit des exemples d'interactions de base de cette API à l'aide de fichiers XML et HTTPS bruts. Après avoir lu ce document, vous pouvez consulter les sections spécifiques au langage de programmation de ce guide du développeur pour en savoir plus sur l'interaction avec l'API à l'aide de nos bibliothèques clientes.

Sommaire

Audience

Ce document est destiné aux programmeurs qui souhaitent écrire des applications clientes pouvant interagir avec Blogger à l'aide de XML et HTTPS.

Dans ce document, nous partons du principe que vous avez compris les idées générales sur le protocole Google Data APIs.

Si vous utilisez un système UNIX et que vous souhaitez tester les exemples de ce document sans écrire de code, les utilitaires de ligne de commande UNIX curl ou wget vous seront peut-être utiles. Pour en savoir plus, consultez les pages de manuel de ces utilitaires.

Pour obtenir des informations de référence sur l'API Data de Blogger, consultez le Guide de référence du protocole.

Premiers pas

Créer un compte Blogger

Vous pouvez créer un compte Blogger à des fins de test. Blogger utilise des comptes Google. Par conséquent, si vous en possédez déjà un, vous n'avez rien d'autre à faire.

Autoriser les requêtes

Lorsque votre application demande des données utilisateur non publiques, elle doit inclure un jeton d'autorisation. Celui-ci permet également d'identifier votre application auprès de Google.

À propos des protocoles d'autorisation

Nous vous recommandons d'utiliser OAuth 2.0 pour autoriser les requêtes.

L'API GData de Blogger est également compatible avec d'anciennes options d'autorisation, telles que OAuth 1.0, AuthSub ou ClientLogin. Toutefois, dans la plupart des cas, nous vous déconseillons d'utiliser ces autres options. Si votre application utilise déjà ces options, nous vous recommandons, si possible, de migrer vers OAuth 2.0.

Si votre application présente certaines exigences d'autorisation inhabituelles, telles que la connexion en même temps qu'une demande d'accès aux données (hybride) ou la délégation d'autorité au niveau du domaine (2LO), vous ne pouvez pas utiliser de jetons OAuth 2.0 pour le moment. Dans ce cas, vous devez utiliser des jetons OAuth 1.0 à la place.

Autoriser des requêtes avec OAuth 2.0

Les requêtes adressées à l'API GData de Blogger portant sur des données utilisateur non publiques doivent être autorisées par un utilisateur authentifié.

Les détails de la procédure d'autorisation (ou "flux") pour 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:

Lorsque vous créez votre application, vous l'enregistrez auprès de Google. Google fournit ensuite des informations dont vous aurez besoin ultérieurement, dont un ID et un code secret de client.
Lorsque votre application doit accéder à des données utilisateur, elle demande à Google un niveau d'accès particulier.
Google affiche alors une boîte de dialogue OAuth invitant l'utilisateur à autoriser votre application à demander certaines de ses données.
Si l'utilisateur accepte, Google attribue à votre application un jeton d'accès de courte durée.
Votre application demande des données utilisateur en associant le jeton d'accès à la requête.
Si Google valide la requête et le jeton, les données demandées sont renvoyées.

Certains flux comportent des étapes supplémentaires, telles que l'utilisation de jetons d'actualisation pour obtenir de nouveaux jetons d'accès. Pour en savoir plus sur les flux pour différents types d'applications, consultez la documentation OAuth 2.0 de Google.

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

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

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

Conseil:Les bibliothèques clientes des API Google peuvent gérer une partie du processus d'autorisation à votre place. Elles sont disponibles pour de nombreux langages de programmation. Pour en savoir plus, consultez la page Exemples de code et bibliothèques.

Spécifier une version

Chaque requête que vous envoyez à l'aide de l'API Blogger Data doit préciser la version 2 de l'API.

Pour spécifier un numéro de version, utilisez l'en-tête HTTP GData-Version:

GData-Version: 2

Si vous ne pouvez pas définir d'en-têtes HTTP, vous pouvez également spécifier v=2 comme paramètre de requête dans l'URL. Mais l’en-tête HTTP est préférable dans la mesure du possible.

Remarque: Les bibliothèques clientes fournissent automatiquement les en-têtes de version appropriés. Par conséquent, n'utilisez pas le paramètre de requête v=2 lorsque vous utilisez une bibliothèque cliente.

Récupérer une liste de blogs

L'API Blogger Data fournit un flux qui répertorie les blogs d'un utilisateur spécifique. Ce flux est appelé "métaflux".

Envoyez une requête HTTP GET à l'URL suivante pour récupérer la liste des blogs:

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

Où l'ID de profil correspond au numéro figurant dans l'URL de la page de profil de l'utilisateur.

Remarque: Vous pouvez également remplacer l'ID utilisateur par default, ce qui indique à Blogger de renvoyer la liste des blogs pour l'utilisateur dont les identifiants accompagnent la requête.

Voici à quoi peut ressembler une entrée dans le métaflux:

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

Pour en savoir plus sur la signification de chacun de ces éléments, consultez la documentation de référence du protocole Google Data APIs ou la spécification Atom 1.0.

Si, pour une raison quelconque, votre requête échoue, Blogger peut renvoyer un code d'état différent. Vous trouverez plus d'informations sur les codes d'état HTTP dans la documentation de référence du protocole Google Data APIs.

Créer des posts

L'API Blogger Data vous permet de créer et de publier des articles de blog, ainsi que des brouillons d'articles.

Publication d'un article de blog

Une fois authentifié, vous pouvez publier de nouveaux articles de blog.

Commencez par créer une représentation XML de l'article à publier. Ce fichier XML doit se présenter sous la forme d'un élément Atom <entry>, qui peut se présenter comme suit:

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

Remarque: Il n'est actuellement pas possible de définir un auteur personnalisé pour les posts. Tous les nouveaux posts apparaîtront comme s'ils avaient été créés par l'utilisateur actuellement authentifié.

Pour publier cette entrée, envoyez-la à l'URL de l'article du blog comme suit. Tout d'abord, placez votre élément Atom <entry> dans le corps d'une nouvelle requête POST, à l'aide du type de contenu application/atom+xml. Recherchez ensuite l'URL de l'article du blog dans le métaflux en recherchant l'élément <link> où l'attribut rel se termine par #post. L'URL de l'article du blog est indiquée en tant qu'attribut href de cet élément, qui est au format suivant:

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

Remarque: Cette URL est identique à celle de la balise <link rel="service.post"> qui apparaît dans la section <head> de la version lisible du blog.

Blogger crée un article de blog à l'aide de l'entrée que vous avez envoyée, puis renvoie un code d'état HTTP 201 CREATED, ainsi qu'une copie du nouvel article sous la forme d'un élément <entry>. L'entrée renvoyée est la même que celle que vous avez envoyée, mais elle contient également divers éléments ajoutés par Blogger, tels qu'un élément <id>.

Si, pour une raison quelconque, votre requête échoue, Blogger peut renvoyer un code d'état différent. Pour plus d'informations sur les codes d'état, consultez la documentation de référence du protocole Google Data API.

Création d'un brouillon d'article de blog

Les brouillons de posts sont créés de la même manière que les posts publics, mais avec un élément <app:control> ajouté à l'entrée indiquant que le post ne doit pas (encore) être publié.

Cet élément <app:control> ne doit contenir qu'un seul élément <app:draft> en tant qu'enfant:

<app:control xmlns:app='http://www.w3.org/2007/app'>
  <app:draft>yes</app:draft>
</app:control>

Les données contenues dans l'élément <app:draft> doivent correspondre à la chaîne yes pour que l'article soit reconnu en tant que brouillon.

Pour transformer un brouillon d'article de blog existant en article publié, récupérez-le, définissez les données de l'élément <app:draft> sur la chaîne no, puis mettez à jour l'article. La récupération et la mise à jour des posts sont abordées dans les deux sections suivantes.

Remarque: Pour en savoir plus sur le protocole de publication Atom, y compris sur les espaces de noms <app:control> et <app:draft>, consultez le document RFC 5023.

Récupérer des posts

Les sections suivantes décrivent comment récupérer une liste d'articles de blog, avec et sans paramètres de requête.

Vous pouvez envoyer une requête à un flux public Blogger sans authentification. Par conséquent, vous n'avez pas besoin de définir le paramètre d'autorisation lorsque vous récupérez des articles de blog à partir d'un blog public.

Récupérer tous les articles de blog

Pour récupérer les articles de l'utilisateur, envoyez une requête HTTP GET à l'URL du flux du blog. Blogger renvoie ensuite un flux contenant les entrées de blog appropriées. Par exemple, pour obtenir la liste des articles de blog publiés pour liz@gmail.com, envoyez la requête HTTP suivante à Blogger (en remplaçant blogID, par la valeur appropriée):

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

Blogger renvoie ensuite un code d'état HTTP 200 OK et un flux Atom 1.0 standard contenant les articles du blog.

Voici un exemple de flux pour un blog avec un seul article. Notez que nous avons légèrement modifié cet exemple pour le rendre un peu plus lisible par les humains. Par exemple, un flux Blogger réel contient des ID et des URL réels.

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

Récupérer à nouveau un article de blog

Si vous souhaitez récupérer un article précédemment récupéré, vous pouvez améliorer l'efficacité en demandant à Blogger de n'envoyer l'article que s'il a été modifié depuis la dernière fois que vous l'avez récupéré.

Pour effectuer ce type de récupération conditionnelle, envoyez une requête HTTP GET incluant un en-tête HTTP If-None-Match. Dans l'en-tête, spécifiez l'ETag de l'entrée, que vous pouvez trouver dans l'attribut gd:etag de l'élément <entry>.

Exemple :

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

Lorsque Blogger reçoit cette demande, il vérifie si l'entrée demandée a le même ETag que celui que vous avez spécifié. Si les ETag correspondent, l'entrée n'a pas changé et Blogger renvoie un code d'état HTTP 304 Not Modified.

Si les ETag ne correspondent pas, l'entrée a été modifiée depuis la dernière fois que vous l'avez demandée et Blogger la renvoie.

Pour en savoir plus sur les ETags, consultez le guide de référence des API Google Data.

Récupérer des posts à l'aide de paramètres de requête

L'API Blogger Data vous permet de demander un ensemble d'entrées correspondant à des critères spécifiés, par exemple des articles de blog publiés ou mis à jour au cours d'une période donnée.

Par exemple, pour envoyer une requête de plage de dates, ajoutez les paramètres published-min et published-max à l'URL de la requête. Pour obtenir toutes les entrées de blog créées entre le 16 mars 2008 et le 24 mars 2008, envoyez une requête HTTP à l'URL du flux du blog:

GET https://www.blogger.com/feeds/blogID/posts/default?published-min=2008-03-16T00:00:00&published-max=2008-03-24T23:59:59

Lorsque vous envoyez cette requête GET, Blogger renvoie un code d'état HTTP 200 OK et un flux contenant tous les articles de blog créés au cours de la période spécifiée.

Les paramètres updated-min et updated-max peuvent également être utilisés pour mettre à jour toutes les entrées de blog dans une plage donnée. Toutefois, notez que ces paramètres sont ignorés, sauf si le paramètre orderby est également défini sur updated.

L'API Blogger Data prend en charge les paramètres de requête suivants:

alt: Type de flux à renvoyer, par exemple atom (par défaut) ou rss.
/category: Spécifie des catégories (également appelées libellés) pour filtrer les résultats du flux. Par exemple, https://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie renvoie des entrées avec les étiquettes Fritz et Laurie.
max-results: Nombre maximal d'entrées à renvoyer.
Trier par: Ordre dans lequel les entrées doivent être renvoyées, telles que lastmodified (valeur par défaut), starttime ou updated.
publié-min, publié-max: Limites applicables aux dates de publication des entrées.
start-index: Index de base 1 du premier résultat à récupérer (pour la pagination).
update-min, updated-max: Limites applicables aux dates de mise à jour des entrées. Ces paramètres de requête sont ignorés, sauf si le paramètre orderby est défini sur updated.
chemin d'accès: Chemin du lien permanent d'un post. Par exemple, pour un post dont l'URL est http://buzz.blogger.com/2011/08/bloggers-fresh-new-look.html, le chemin du lien permanent est /2011/08/bloggers-fresh-new-look.html.
q: Chaîne de requête en texte intégral. Cela vous permet de rechercher dans un blog les articles correspondant à une requête.

Pour en savoir plus sur les paramètres de requête, consultez le guide de référence de l'API Blogger Data et le guide de référence des API Google Data.

Mise à jour des posts...

Pour mettre à jour un article de blog existant, vous devez d'abord récupérer l'entrée à mettre à jour, la modifier, puis envoyer une requête PUT avec l'entrée mise à jour dans le corps du message à l'URL de modification de l'article. Assurez-vous que la valeur <id> de l'entrée PUT correspond exactement à la valeur <id> de l'entrée existante.

L'URL de modification est mise en surbrillance dans l'entrée suivante:

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

IMPORTANT: Pour assurer la compatibilité ascendante, assurez-vous que lorsque vous PUT une entrée mise à jour, vous conservez tout le code XML présent lors de la récupération de l'entrée depuis Blogger. Sinon, lorsque nous implémenterons de nouvelles choses et incluons les éléments <new-awesome-feature> dans le flux, votre client ne les renverra pas, et vos utilisateurs passeront à côté. Les bibliothèques clientes de l'API Google Data gèrent toutes cela correctement. Par conséquent, si vous utilisez l'une des bibliothèques, vous êtes prêt.

Remarque: Il n'est actuellement pas possible de modifier les données d'auteur associées aux posts.

Conseil de dépannage: Certains pare-feu bloquent les messages HTTP PUT. Pour contourner ce problème, vous pouvez inclure un en-tête X-HTTP-Method-Override: PUT dans une requête POST. Pour plus d'informations, consultez le document Principes de base du protocole Google Data API.

Suppression des posts...

Pour supprimer un post, envoyez une requête DELETE à l'URL de modification du post. Il s'agit de la même URL que celle utilisée pour mettre à jour les posts.

Conseil de dépannage: Certains pare-feu bloquent les messages HTTP DELETE. Pour contourner ce problème, vous pouvez inclure un en-tête X-HTTP-Method-Override: DELETE dans une requête POST. Pour plus d'informations, consultez le document Principes de base du protocole Google Data API.

Commentaires

L'API Blogger Data permet de créer, récupérer et supprimer des commentaires. La mise à jour des commentaires n'est pas prise en charge (elle n'est pas non plus disponible dans l'interface Web).

Création de commentaires

Pour publier un commentaire, créez un élément Atom <entry> comme suit:

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

Pour publier ce commentaire, placez votre élément Atom <entry> dans le corps d'une nouvelle requête POST, à l'aide du type de contenu application/atom+xml. Envoyez ensuite la requête POST à l'URL Blogger appropriée:

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

Remarque: Actuellement, vous ne pouvez publier des commentaires que sur un blog appartenant à l'utilisateur authentifié.

Remarque: Il n'est actuellement pas possible de définir un auteur personnalisé pour les commentaires. Tous les nouveaux commentaires apparaîtront comme s'ils avaient été créés par l'utilisateur actuellement authentifié.

Récupérer des commentaires

Vous pouvez récupérer les commentaires d'un article particulier en envoyant un GET à l'URL du flux de commentaires de cet article:

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

Vous pouvez également obtenir les commentaires de tous les articles en utilisant l'URL du flux de commentaires du blog:

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

Ces requêtes renvoient un flux de commentaires semblable à celui-ci:

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

Suppression des commentaires...

Pour supprimer un commentaire, envoyez une requête DELETE à l'URL de modification du commentaire. Cette URL est mise en évidence dans le flux de commentaires ci-dessus.

Format d'exportation

Blogger permet aux utilisateurs d'exporter et d'importer leurs blogs à l'aide d'un fichier d'exportation Blogger. Ce fichier d'exportation contient tous les articles et commentaires d'un blog. Le format du fichier d'exportation est exactement le même format Atom que celui décrit dans les sections sur la récupération des posts et des commentaires. Ce fichier d'exportation contiendra le contenu du flux d'articles et le contenu du flux de commentaires combinés en un seul document.

Pour exporter ou importer des données de blog au format d'exportation, consultez la page Paramètres du blog. Pour récupérer le fichier d'exportation d'un blog à l'aide de l'API Data, utilisez l'URL suivante:

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

Pour importer le fichier d'exportation, créez une requête POST vers l'URL suivante avec le contenu du fichier d'exportation en tant que données de requête et application/atom+xml comme type de contenu:

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

Aucune des URL ci-dessus n'est compatible avec les paramètres de requête. Ces deux requêtes doivent également contenir des informations d'authentification, et seuls les administrateurs du blog pourront importer/exporter le blog à l'aide de ces URL de flux.

Remarque: Si vous créez votre propre fichier d'exportation Blogger, il existe actuellement une restriction concernant l'ordre des entrées des articles et des commentaires. Le fichier d'exportation Blogger répertorie d'abord les articles, puis les commentaires. L'entrelacement de messages et de commentaires est autorisé tant que le commentaire est ajouté après la publication du commentaire.

Pour plus d'informations sur la manière dont Blogger utilise le format Atom dans le fichier d'exportation, consultez le Guide de référence du protocole.

Haut de page