Guide du développeur: Protocole

Important : Il s'agit de l'ancienne version de cette page. Pour obtenir la dernière version, utilisez les liens de la barre de navigation de gauche.

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

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 correspondant à des critères particuliers.

En plus de vous fournir des informations de base sur les fonctionnalités de l'API Data de Blogger, ce document fournit des exemples d'interactions de base de l'API Data avec les formats XML et HTTP bruts. Après avoir lu ce document, vous souhaiterez peut-être en savoir plus sur l'interaction avec l'API à l'aide de nos bibliothèques clientes en consultant les sections spécifiques au langage de programmation de ce guide du développeur.

Contenus

Audience

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

Dans ce document, nous partons du principe que vous comprenez les principes généraux du protocole Google Data APIs.

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

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

Commencer

Créer un compte Blogger

Vous pouvez créer un compte Blogger à des fins de test. Blogger utilise les comptes Google. Si vous en avez déjà un, vous n'avez rien à faire.

S'authentifier sur le service Blogger

Vous pouvez accéder aux flux publics et privés à l'aide de l'API Blogger Data. Les flux publics ne requièrent aucune authentification, mais ils sont en lecture seule. Si vous souhaitez modifier des blogs, votre client doit s'authentifier avant de demander des flux privés. Il peut s'authentifier de deux manières: l'authentification par proxy AuthSub ou l'authentification par nom d'utilisateur/mot de passe ClientLogin.

Pour en savoir plus sur l'authentification auprès des API Google Data en général, consultez la documentation sur l'authentification.

La plupart des exemples des sections suivantes de ce document supposent que vous fournissez l'authentification appropriée.

Authentification du proxy AuthSub

L'authentification de proxy AuthSub est utilisée par les applications Web qui doivent authentifier leurs utilisateurs auprès de comptes Google. L'opérateur du site Web et le code client n'ont pas accès au nom d'utilisateur ni au mot de passe de l'utilisateur Blogger. À la place, le client obtient des jetons AuthSub spéciaux qui lui permettent d'agir pour le compte d'un utilisateur particulier. Pour en savoir plus, consultez la documentation AuthSub.

Lorsqu'un utilisateur visite votre application pour la première fois, il n'a pas encore été authentifié. Dans ce cas, vous devez afficher des informations et un lien redirigeant l'utilisateur vers une page Google afin d'authentifier votre demande d'accès à ses blogs.

Les paramètres de requête suivants sont inclus dans l'URL AuthSubRequest:

suivant
URL de la page vers laquelle Google doit rediriger l'utilisateur après l'authentification.
champ d'application
Indique que l'application demande un jeton pour accéder aux flux Blogger. La chaîne du champ d'application à utiliser est http://www.blogger.com/feeds/ (encodé en URL, évidemment).
sécurisé
Indique si le client demande un jeton sécurisé.
session
Indique si le jeton renvoyé peut être échangé contre un jeton à usages multiples (session).

L'URL AuthSubRequest peut se présenter comme suit:

https://www.google.com/accounts/AuthSubRequest?scope=http%3A%2F%2Fwww.blogger.com%2Ffeeds%2F&session=1&secure=0&next=http%3A%2F%2Fwww.example.com%2Fwelcome.html

L'utilisateur suit le lien vers le site de Google et s'authentifie sur son compte Google.

Une fois l'authentification de l'utilisateur effectuée, le système AuthSub le redirige vers l'URL que vous avez spécifiée dans le paramètre de requête next de l'URL AuthSubRequest. Le système AuthSub ajoute un jeton d'authentification à cette URL, en tant que valeur du paramètre de requête token. Exemple :

http://www.example.com/welcome.html?token=yourAuthToken

Cette valeur de jeton représente un jeton AuthSub à usage unique. Dans cet exemple, étant donné que session=1 a été spécifié, ce jeton peut être échangé contre un jeton de session AuthSub en appelant le service AuthSubSessionToken avec le jeton à usage unique dans un en-tête Authorization, comme suit:

GET /accounts/AuthSubSessionToken HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Authorization: AuthSub token="yourAuthToken"
User-Agent: Java/1.5.0_06
Host: www.google.com
Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2
Connection: keep-alive

La réponse du service AuthSubSessionToken comprend un en-tête Token contenant le jeton de session et un en-tête Expiration indiquant la durée de validité du jeton.

Votre application peut ensuite utiliser la valeur du jeton de session dans l'en-tête Authorization des interactions ultérieures avec Blogger.

Voici un exemple de requête HTTP contenant un jeton non sécurisé, que vous pouvez envoyer à Blogger:

GET /feeds/blogID/blogs/posts/defaults HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Authorization: AuthSub token="yourSessionToken"
User-Agent: Java/1.5.0_06
Host: www.blogger.com
Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2
Connection: keep-alive

Authentification du nom d'utilisateur/mot de passe ClientLogin

Utilisez ClientLogin si votre client est un client autonome à installation unique (application de bureau, par exemple). Pour demander un jeton d'authentification à l'aide du mécanisme ClientLogin, envoyez une requête POST à l'URL suivante:

https://www.google.com/accounts/ClientLogin

Le corps POST doit contenir un ensemble de paramètres de requête semblables à ceux transmis par un formulaire HTML, avec le type de contenu application/x-www-form-urlencoded. Ces paramètres sont les suivants:

E-mail
Adresse e-mail de l'utilisateur.
Passwd
Mot de passe de l'utilisateur.
service
Le nom du service Blogger est blogger. (Pour les autres noms de service, consultez la liste des noms de service.)
typedecompte
Il doit toujours être défini sur GOOGLE lorsque vous utilisez l'API Blogger. Si ce paramètre n'est pas défini, les utilisateurs disposant d'un compte G Suite ne pourront plus y accéder.
source
Identifie votre application cliente. Doit être au format companyName-applicationName-versionID. Les exemples utilisent le nom exampleCo-exampleApp-1.

Pour en savoir plus sur les paramètres, consultez le document Authentification pour les applications installées.

Si la requête d'authentification échoue, le serveur renvoie un code d'état HTTP 403 Forbidden.

Si l'opération réussit, le serveur renvoie un code d'état HTTP 200 OK, ainsi que trois longs codes alphanumériques dans le corps de la réponse: SID, LSID et Auth. La valeur Auth est le jeton d'autorisation que vous allez envoyer à Blogger pour chacune de vos requêtes ultérieures. Vous devez donc conserver une copie de cette valeur. Vous pouvez ignorer les valeurs SID et LSID.

Étant donné que toutes les requêtes adressées à des flux privés nécessitent une authentification, vous devez définir l'en-tête Authorization dans toutes les interactions ultérieures avec Blogger, au format suivant:

Authorization: GoogleLogin auth=yourAuthToken

yourAuthToken est la chaîne d'authentification renvoyée par la requête ClientLogin.

Pour plus d'informations sur l'authentification ClientLogin, y compris des exemples de requêtes et de réponses, consultez la documentation Authentification pour les applications installées.

Remarque : Utilisez le même jeton pour toutes les requêtes d'une session donnée. N'acquérez pas de nouveau jeton pour chaque requête Blogger.

Remarque : Comme décrit dans la documentation ClientLogin, la requête d'authentification peut échouer et entraîner un test CAPTCHA. Si vous souhaitez que Google émette et gère le test CAPTCHA, envoyez l'utilisateur vers https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger (plutôt que vers l'URL de traitement CAPTCHA fournie dans la documentation ClientLogin).

Récupérer une liste de blogs

L'API Blogger Data fournit un flux qui répertorie les blogs d'un utilisateur particulier. Ce flux est appelé "metafeed".

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

http://www.blogger.com/feeds/userID/blogs

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

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

<entry>
  <id>tag:blogger.com,1999:blog-blogID.post-postID</id>
  <published>2006-08-02T18:44:43.089-07:00</published>
  <updated>2006-11-08T18:10:23.020-08:00</updated>
  <title type='text'>Lizzy's Diary</title>
  <summary type='html'>Being the journal of Elizabeth Bennet</summary>
  <link rel='alternate' type='text/html'
    href='http://blogName.blogspot.com/'>
  </link>
  <link rel='http://schemas.google.com/g/2005#feed'
    type='application/atom+xml'
    href='http://blogName.blogspot.com/feeds/posts/default'>
  </link>
  <link rel='http://schemas.google.com/g/2005#post'
    type='application/atom+xml'
    href='http://www.blogger.com/feeds/blogID/posts/default'>
  </link>
  <link rel='self' type='application/atom+xml'
    href='http://www.blogger.com/feeds/userID/blogs/blogID'>
  </link>
  <link rel='edit' type='application/atom+xml'
      href='http://www.blogger.com/feeds/userID/blogs/blogID'>
  </link>
  <author>
    <name>Elizabeth Bennet</name>
    <email>noreply@blogger.com</email>
    <uri>http://www.blogger.com/profile/profileID</uri>
  </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 APIs Data ou la spécification Atom 1.0.

Si, pour une raison quelconque, votre demande n'aboutit pas, Blogger peut renvoyer un code d'état différent. Pour plus d'informations sur les codes d'état HTTP, consultez la documentation de référence de Google Data APIs Protocol.

Création de posts

L'API Blogger Data vous permet de créer et de publier de nouvelles entrées de blog, mais aussi de créer des brouillons d'entrées.

Publier un article de blog

Après l'authentification, vous pouvez publier de nouvelles entrées de blog.

Commencez par créer une représentation XML du post à 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 l'élément Atom <entry> dans le corps d'une nouvelle requête POST, en utilisant le type de contenu application/atom+xml. Recherchez ensuite l'URL de l'article dans le métaflux en localisant l'élément <link> où l'attribut rel se termine par #post. L'URL du post du blog est fournie en tant qu'attribut href de cet élément, au format suivant:

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

Remarque : Cette URL est identique à l'URL 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 à partir 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 identique à 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 demande n'aboutit pas, Blogger peut renvoyer un code d'état différent. Pour en savoir plus sur les codes d'état, consultez le document de référence sur le protocole Google Data API.

Créer un brouillon d'article de blog

Les brouillons 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> doit contenir un seul élément <app:draft> en tant qu'élément enfant:

<app:control xmlns:app='http://purl.org/atom/app#'>
  <app:draft>yes</app:draft>
</app:control>

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

Vous pouvez transformer un brouillon de blog en article publié en le récupérant, en définissant les données de l'élément <app:draft> sur la chaîne no, puis en mettant à jour le post. 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 la norme RFC 5023.

Récupération des posts

Les sections suivantes expliquent comment récupérer la liste des articles de blog, avec et sans paramètres de requête.

Vous pouvez interroger un flux public Blogger sans authentification. Par conséquent, vous n'avez pas besoin de définir le paramètre Authorization lorsque vous récupérez des articles de blog publics.

Récupération de 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 pour liz@gmail.com, envoyez la requête HTTP suivante à Blogger (avec la valeur appropriée à la place de blogID):

GET http://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 de 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 plus lisible par les humains. En particulier, un flux Blogger réel contient des ID et des URL réels.

<feed xmlns='http://www.w3.org/2005/Atom'>
  <id>tag:blogger.com,1999:blog-blogID</id>
  <updated>2006-11-08T18:10:23.020-08:00</updated>
  <title type='text'>Lizzy's Diary</title>
  <link rel='alternate' type='text/html'
    href='http://blogName.blogspot.com/index.html'>
  </link>
  <link rel='http://schemas.google.com/g/2005#feed'
    type='application/atom+xml'
    href='http://blogName.blogspot.com/feeds/posts/default'>
  </link>
  <link rel='self' type='application/atom+xml'
    href='http://blogName.blogspot.com/feeds/posts/default'>
  </link>
  <author>
    <name>Elizabeth Bennet</name>
    <email>noreply@blogger.com</email>
    <uri>http://www.blogger.com/profile/profileID</uri>
  </author>
  <generator version='7.00' uri='http://www2.blogger.com'>Blogger</generator>
  <entry>
    <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>
    <author>
      <name>Elizabeth Bennet</name>
      <email>noreply@blogger.com</email>
      <uri>http://www.blogger.com/profile/profileID</uri>
    </author>
  </entry>
</feed>

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

L'API Data de Blogger vous permet de demander un ensemble d'entrées correspondant aux critères spécifiés, par exemple des articles de blog publiés ou mis à jour dans une plage de dates 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 et le 24 mars 2008, envoyez une requête HTTP à l'URL du flux du blog:

GET http://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 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. Notez toutefois que ces paramètres sont ignorés, sauf si le paramètre orderby est également défini sur updated.

L'API Blogger Data accepte les paramètres de requête suivants:

alt
Type de flux à afficher, tel que atom (valeur 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, http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie renvoie les entrées contenant les libellés Fritz et Laurie.
résultats max
Nombre maximal d'entrées à renvoyer.
commander
Ordre dans lequel les entrées doivent être affichées, par exemple lastmodified (valeur par défaut), starttime ou updated.
publié-min, publié-max
Limites liées aux dates de publication des entrées.
index de départ
Index de base 1 du premier résultat à récupérer (pour la pagination).
mis à jour, mis à jour, max.
Limites liées 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.

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 récupérez d'abord l'entrée que vous souhaitez mettre à jour, vous la modifiez, puis vous envoyez une requête PUT, avec l'entrée mise à jour dans le corps du message, à l'URL de modification du post. Assurez-vous que la valeur <id> dans l'entrée PUT correspond exactement à <id> de l'entrée existante.

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

<entry>
  <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 garantir la compatibilité avec les données, assurez-vous que, lorsque vous PUTmettez à jour une entrée, vous conservez tout le code XML qui était présent lorsque vous avez récupéré l'entrée à partir de Blogger. Sinon, lorsque nous ajouterons de nouveaux éléments et que nous inclurons des éléments <new-awesome-feature> dans le flux, votre client ne les renverra pas et vos utilisateurs passeront à côté de quelque chose. Les bibliothèques clientes de l'API Google Data gèrent toutes ces opérations correctement. Par conséquent, si vous utilisez l'une des bibliothèques que vous avez déjà configurées,

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 en savoir plus, 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 en savoir plus, consultez le document Principes de base du protocole Google Data API.

Commentaires

L'API Blogger Data permet de créer, de récupérer et de supprimer des commentaires. Il n'est pas possible de mettre à jour les commentaires (ni dans l'interface Web).

Créer des 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 http://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ération des commentaires...

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

GET http://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 http://www.blogger.com/feeds/blogID/comments/default

Ces requêtes renvoient un flux de commentaires qui se présente comme suit:

<feed xmlns="http://www.w3.org/2005/Atom" xmlns:openSearch="http://a9.com/-/spec/opensearchrss/1.0/"
         xmlns:thr="http://purl.org/syndication/thread/1.0">
  <id>tag:blogger.com,1999:blog-blogID.post-postID.comment-commentID</id>
  <updated>2007-04-04T21:56:29.803-07:00</updated>
  <title type="text">My Blog : Time to relax</title>
  <link rel="alternate" type="text/html" href="http://blogName.blogspot.com/2007/04/first-post.html"/>
  <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://blogName.blogspot.com/feeds/postID/comments/default"/>
  <author>
    <name>Blog Author name</name>
  </author>
  <generator version="7.00" uri="http://www2.blogger.com">Blogger</generator>
  <openSearch:totalResults>1</openSearch:totalResults>
  <openSearch:startIndex>1</openSearch:startIndex>
  <entry>
    <id>tag:blogger.com,1999:blog-blogID.post-commentID</id>
    <published>2007-04-04T21:56:00.000-07:00</published>
    <updated>2007-04-04T21:56:29.803-07:00</updated>
    <title type="text">This is my first comment</title>
    <content type="html">This is my first comment</content>
    <link rel="alternate" type="text/html" href="http://blogName.blogspot.com/2007/04/first-post.html#commentID"/>
    <link rel="self" type="application/atom+xml" href="http://blogName.blogspot.com/feeds/postID/comments/default/commentID"/>
    <link rel="edit" type="application/atom+xml" href="http://www.blogger.com/feeds/blogID/postID/comments/default/commentID"/>
    <thr:in-reply-to href="http://blogName.blogspot.com/2007/04/first-post.html" 
                     ref="tag:blogger.com,1999:blog-blogID.post-postID" 
                     source="http://www.blogger.com/feeds/posts/default/blogID"
                     type="text/html"/>
    <author>
      <name>Blog Author name</name>
      <email>blog_author@gmail.com</email>
      <uri>http://www.blogger.com/profile/userID</uri>
    </author>
    <thr:in-reply-to xmlns:thr='http://purl.org/syndication/thread/1.0' 
         href='http://blogName.blogspot.com/2007/04/first-post.html' 
         ref='tag:blogger.com,1999:blog-blogID.post-postID' 
         source='http://blogName.blogspot.com/feeds/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 surbrillance 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 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 dans un seul document.

Pour exporter ou importer des données de blog à l'aide du 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 http://www.blogger.com/feeds/blogID/archive

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

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

Aucune des URL ci-dessus ne prend en charge les paramètres de requête. Les deux requêtes doivent également contenir des informations d'authentification. Seuls les administrateurs de 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 de post et de commentaire. Le fichier d'exportation Blogger liste d'abord tous les articles, puis tous les commentaires. L'entrelacement est autorisé tant que l'entrée apparaît après la publication du commentaire.

Pour en savoir plus 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