Esta página foi traduzida pela API Cloud Translation.

Guia do desenvolvedor: protocolo

Importante: esta é uma versão antiga da página. Para a versão mais recente, use os links na barra de navegação do lado esquerdo.

A API de dados do Blogger permite que aplicativos clientes visualizem e atualizem o conteúdo do Blogger na forma de feeds da API de dados do Google.

Seu aplicativo cliente pode usar a API de dados do Blogger para criar novas postagens, editar ou excluir postagens existentes e consultar as postagens que correspondam a critérios específicos.

Além de fornecer algumas informações sobre os recursos da API de dados do Blogger, este documento traz exemplos de interações básicas dessa API usando XML e HTTP brutos. Depois de ler este documento, convém saber mais sobre como interagir com a API usando nossas bibliotecas de cliente lendo as seções específicas de linguagem de programação deste Guia para desenvolvedores.

Conteúdo

Público

Este documento é destinado a programadores que querem criar aplicativos clientes que possam interagir com o Blogger usando XML e HTTP.

Este documento pressupõe que você compreende as ideias gerais por trás do protocolo das APIs de dados do Google.

Se você estiver usando um sistema UNIX e quiser testar os exemplos deste documento sem escrever nenhum código, os utilitários de linha de comando do UNIX curl ou wget podem ser úteis. Para mais informações, consulte as páginas manuais desses utilitários.

Para informações de referência sobre a API Blogger Data, consulte o Guia de referência de protocolo.

Como começar

Como criar uma conta do Blogger

Recomendamos que você se inscreva em uma conta do Blogger para fins de teste. O Blogger usa Contas do Google. Portanto, se você já tem uma, não precisa fazer mais nada.

Como autenticar no serviço do Blogger

Você pode acessar feeds públicos e privados usando a API de dados do Blogger. Os feeds públicos não exigem autenticação, mas são somente leitura. Se você quiser modificar blogs, seu cliente precisará se autenticar antes de solicitar feeds particulares. A autenticação pode ser feita usando uma destas duas abordagens: autenticação de proxy AuthSub ou a autenticação de nome de usuário/senha do ClientLogin.

Para mais informações sobre autenticação com as APIs de dados do Google em geral, consulte a documentação de autenticação.

A maioria dos exemplos nas seções subsequentes deste documento presume que você está fornecendo a autenticação apropriada.

Autenticação via proxy do AuthSub

A autenticação por proxy BYOL é usada por aplicativos da Web que precisam autenticar os usuários nas Contas do Google. O operador do site e o código do cliente não têm acesso ao nome de usuário e à senha do usuário do Blogger. Em vez disso, o cliente recebe tokens MRAID especiais que permitem que ele atue em nome de um usuário específico. Para informações mais detalhadas, consulte a documentação do MRAID (em inglês).

Quando um usuário acessa seu aplicativo pela primeira vez, ele ainda não foi autenticado. Nesse caso, você precisa exibir algumas informações e um link que direciona o usuário a uma página do Google para autenticar sua solicitação de acesso aos blogs dele.

Os seguintes parâmetros de consulta estão incluídos no URL de StatefulSetRequest:

próxima: O URL da página para onde o Google deve redirecionar o usuário após a autenticação.
escopo: Indica que o aplicativo está solicitando um token para acessar os feeds do Blogger. A string de escopo a ser usada é http://www.blogger.com/feeds/ (codificado em URL, obviamente).
seguro: Indica se o cliente está solicitando um token seguro.
seção: Indica se o token retornado pode ser trocado por um token multiuso (sessão).

O URL de noindexRequest pode ter esta aparência:

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

O usuário segue o link para o site do Google e faz a autenticação na Conta do Google.

Após a autenticação do usuário, o sistema StatefulSet redireciona o usuário para o URL especificado no parâmetro de consulta next desse URL. O sistema NGINX anexa um token de autenticação a esse URL, como o valor do parâmetro de consulta token. Exemplo:

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

Esse valor de token representa um token AuthSub de um único uso. Neste exemplo, como session=1 foi especificado, esse token pode ser trocado por um token de sessão do AOSP chamando o serviço AuthSubSessionToken com o token de uso único em um cabeçalho de autorização, da seguinte maneira:

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

A resposta do serviço BYOLSession inclui um cabeçalho Token que contém o token de sessão e um cabeçalho Expiration que indica por quanto tempo o token vai continuar válido.

Assim, seu aplicativo poderá usar o valor do token de sessão no cabeçalho Authorization das interações subsequentes com o Blogger.

Veja um exemplo de solicitação HTTP, contendo um token não seguro, que você pode enviar ao 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

Autenticação por nome de usuário/senha do ClientLogin

Use a autenticação GroupByKey se seu cliente for um cliente "instalado" independente e de usuário único (como um aplicativo de área de trabalho). Para solicitar um token de autenticação usando o mecanismo ConstraintLayout, envie uma solicitação POST para o seguinte URL:

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

O corpo POST precisa conter um conjunto de parâmetros de consulta que se parecem com parâmetros transmitidos por um formulário HTML usando o tipo de conteúdo application/x-www-form-urlencoded. Esses parâmetros são:

E-mail: O endereço de e-mail do usuário.
Passwd: A senha do usuário.
externo: O nome do serviço do Blogger é blogger. Para outros nomes de serviço, consulte a lista de nomes de serviço.
accountType: Ele sempre precisa ser definido como GOOGLE ao usar a API Blogger. Se esse parâmetro não for definido, os usuários que também têm uma conta do G Suite não poderão acessá-lo.
source: Identifica seu aplicativo cliente. Precisa estar no formato companyName-applicationName-versionID. Os exemplos usam o nome exampleCo-exampleApp-1.

Para mais informações sobre os parâmetros, consulte o documento Autenticação de aplicativos instalados.

Se a solicitação de autenticação falhar, o servidor retornará um código de status HTTP 403 Forbidden.

Se for bem-sucedida, o servidor retornará um código de status HTTP 200 OK, além de três códigos alfanuméricos longos no corpo da resposta: SID, LSID e Auth. O valor Auth é o token de autorização que você vai enviar ao Blogger com cada uma das suas solicitações subsequentes, portanto, guarde uma cópia desse valor. Ignore os valores SID e LSID.

Como todas as solicitações de feeds particulares exigem autenticação, você precisa definir o cabeçalho de autorização em todas as interações subsequentes com o Blogger usando o seguinte formato:

Authorization: GoogleLogin auth=yourAuthToken

Em que yourAuthToken é a string Auth retornada pela solicitação do GCLID.

Para mais informações sobre a autenticação do ConstraintLayout, incluindo exemplos de solicitações e respostas, consulte a documentação Autenticação para aplicativos instalados.

Observação: use o mesmo token para todas as solicitações em uma determinada sessão. Não adquira um novo token para cada solicitação do Blogger.

Observação: conforme descrito na documentação do ConstraintLayout, a solicitação de autenticação pode falhar e solicitar um desafio de CAPTCHA. Se você quiser que o Google emita e lide com o desafio CAPTCHA, encaminhe o usuário para https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger (e não para o URL de processamento de CAPTCHA fornecido na documentação do Systrace).

Como recuperar uma lista de blogs

A API de dados do Blogger fornece um feed que lista os blogs de um usuário específico. Esse feed é conhecido como "metafeed".

Envie um GET HTTP para o seguinte URL para recuperar a lista de blogs:

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

Observação: você também pode substituir default pelo ID do usuário, que instrui o Blogger a retornar a lista de blogs do usuário com credenciais que acompanham a solicitação.

Uma entrada no metafeed pode ter a seguinte aparência:

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

Para mais informações sobre o que cada um desses elementos significa, consulte o documento Referência do protocolo de APIs de dados do Google ou a especificação Atom 1.0 (em inglês).

Se a solicitação falhar por algum motivo, o Blogger poderá retornar um código de status diferente. Mais informações sobre códigos de status HTTP também estão disponíveis no documento Referência de protocolo das APIs de dados do Google.

Como criar postagens

Com a API Blogger Data, você pode criar e publicar novas entradas de blog, além de criar rascunhos de entradas.

Publicar uma postagem do blog

Depois da autenticação, você poderá publicar novas entradas do blog.

Primeiro, crie uma representação XML da postagem a ser publicada. Esse XML precisa estar na forma de um elemento <entry> do Atom, que pode ter a seguinte aparência:

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

Observação: no momento, não é possível definir um autor personalizado para as postagens. Todas as novas postagens serão exibidas como se tivessem sido criadas pelo usuário autenticado no momento.

Para publicar essa entrada, envie-a para o URL da postagem do blog da seguinte maneira. Primeiro, coloque o elemento <entry> do Atom no corpo de uma nova solicitação POST, usando o tipo de conteúdo application/atom+xml. Em seguida, localize o URL da postagem do blog no metafeed localizando o elemento <link> onde o atributo rel termina com #post. O URL da postagem do blog é fornecido como o atributo href desse elemento, que está neste formato:

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

Observação: esse URL é o mesmo da tag <link rel="service.post"> que aparece na seção <head> da versão legível do blog.

O Blogger cria uma postagem usando a entrada que você enviou e retorna um código de status HTTP 201 CREATED, junto com uma cópia da nova postagem na forma de um elemento <entry>. A entrada retornada é a mesma que você enviou, mas também contém vários elementos adicionados pelo Blogger, como <id>.

Se a solicitação falhar por algum motivo, o Blogger poderá retornar um código de status diferente. Para mais informações sobre os códigos de status, consulte o documento de referência do protocolo da API Google Data.

Como criar o rascunho de uma postagem do blog

Os rascunhos de postagens são criados da mesma forma que as públicas, mas com um elemento <app:control> adicionado à entrada indicando que a postagem (ainda) não deve ser publicada.

Esse elemento <app:control> precisa conter um único elemento <app:draft> como filho:

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

Os dados contidos no elemento <app:draft> precisam ser a string yes para que a postagem seja reconhecida como rascunho.

Para transformar um rascunho de postagem do blog em uma publicada, basta recuperar o rascunho, definir os dados do elemento <app:draft> como a string no e atualizar a postagem. A recuperação e a atualização de postagens são abordadas nas próximas duas seções.

Observação: para mais informações sobre o Atom Publishing Protocol, incluindo os namespaces <app:control> e <app:draft>, consulte RFC 5023 (em inglês).

Recuperando postagens

As seções a seguir descrevem como recuperar uma lista de postagens do blog, com e sem parâmetros de consulta.

Você pode consultar um feed público do Blogger sem autenticação. Portanto, você não precisa definir o parâmetro de autorização ao recuperar postagens de um blog público.

Recuperando todas as postagens do blog

Para recuperar as postagens do usuário, envie uma solicitação GET HTTP para o URL do feed do blog. Em seguida, o Blogger retorna um feed que contém as entradas de blog apropriadas. Por exemplo, para ver uma lista de postagens do blog de liz@gmail.com, envie a seguinte solicitação HTTP para o Blogger (com o valor adequado no lugar de blogID, obviamente):

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

O Blogger retornará um código de status HTTP 200 OK e um feed padrão Atom 1.0 contendo as postagens do blog.

Veja a seguir um exemplo de feed para um blog com apenas uma postagem. Observe que fizemos uma pequena edição neste exemplo para torná-lo um pouco mais legível para humanos. Especificamente, um feed real do Blogger contém IDs e URLs reais.

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

Como recuperar postagens usando parâmetros de consulta

Com a API Blogger Data, você pode solicitar um conjunto de entradas que correspondam a critérios especificados, como solicitar postagens do blog publicadas ou atualizadas em um determinado período.

Por exemplo, para enviar uma consulta de período, adicione os parâmetros published-min e published-max ao URL da solicitação. Para obter todas as entradas de blog criadas entre 16 de março de 2008 e 24 de março de 2008, envie uma solicitação HTTP para o URL do feed do blog:

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

Quando você envia essa solicitação GET, o Blogger retorna um código de status HTTP 200 OK e um feed com todas as postagens do blog criadas no período especificado.

Os parâmetros updated-min e updated-max também podem ser usados para receber todas as entradas do blog atualizadas em um determinado intervalo. No entanto, esses parâmetros são ignorados, a menos que o parâmetro orderby também seja definido como updated.

A API de dados do Blogger oferece suporte aos seguintes parâmetros de consulta:

alt: O tipo de feed a ser retornado, como atom (padrão) ou rss.
/category: Especifica categorias (também conhecidas como rótulos) para filtrar os resultados do feed. Por exemplo, http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie retorna entradas com os rótulos Fritz e Laurie.
max-results: O número máximo de entradas a serem retornadas.
orderby: A ordem em que as entradas são retornadas, como lastmodified (padrão), starttime ou updated.
min-publicado, máx.-publicado: Os limites para as datas de publicação das inscrições.
start-index: O índice baseado em 1 do primeiro resultado a ser recuperado (para paginação).
min-atualizado, máx. atualizado: Os limites para as datas de atualização das entradas. Esses parâmetros de consulta serão ignorados, a menos que o parâmetro orderby seja definido como updated.

Para mais informações sobre parâmetros de consulta, consulte o Guia de referência da API Blogger Data e o Guia de referência das APIs Google Data.

Atualizando postagens

Para atualizar uma postagem do blog, primeiro recupere a entrada que quer atualizar. Em seguida, modifique-a e envie uma solicitação PUT, com a entrada atualizada no corpo da mensagem, para o URL de edição da postagem. Verifique se o valor <id> na entrada PUT corresponde exatamente ao <id> da entrada atual.

O URL de edição está destacado na seguinte entrada:

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

IMPORTANTE: para garantir a compatibilidade futura, ao PUT uma entrada atualizada, você preserva todo o XML que estava presente quando você recuperou a entrada do Blogger. Caso contrário, quando implementarmos novos itens e incluirmos elementos <new-awesome-feature> no feed, seu cliente não os retornará, e seus usuários não os retornarão. Todas as bibliotecas de cliente da API Google Data processam isso corretamente. Portanto, se você estiver usando uma das bibliotecas, estará tudo pronto.

Observação: no momento, não é possível modificar os dados do autor associados às postagens.

Dica de solução de problemas: alguns firewalls bloqueiam mensagens HTTP PUT. Para contornar isso, inclua um cabeçalho X-HTTP-Method-Override: PUT em uma solicitação POST. Para mais detalhes, consulte o documento Noções básicas do protocolo da API Google Data.

Excluindo postagens

Para excluir uma postagem, envie uma solicitação DELETE ao URL de edição dela. Esse é o mesmo URL usado para atualizar postagens.

Dica de solução de problemas: alguns firewalls bloqueiam mensagens HTTP DELETE. Para contornar isso, é possível incluir um cabeçalho X-HTTP-Method-Override: DELETE em uma solicitação POST. Para mais detalhes, consulte o documento Noções básicas do protocolo da API Google Data.

Comentários

A API de dados do Blogger permite criar, recuperar e excluir comentários. Não é possível atualizar comentários (nem disponível na interface da Web).

Como criar comentários

Para postar um comentário, crie um elemento <entry> do Atom como o seguinte:

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

Para publicar esse comentário, coloque o elemento <entry> do Atom no corpo de uma nova solicitação POST, usando o tipo de conteúdo application/atom+xml. Em seguida, envie a solicitação POST para o URL apropriado do Blogger:

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

Observação: no momento, só é possível postar comentários em um blog de propriedade do usuário autenticado.

Observação: no momento, não é possível definir um autor personalizado para comentários. Todos os novos comentários serão exibidos como se tivessem sido criados pelo usuário autenticado no momento.

Recuperando comentários

Para recuperar os comentários de uma postagem específica, envie um GET para o URL do feed de comentários da postagem em questão:

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

Ou você pode obter os comentários de todas as postagens usando o URL do feed de comentários do blog:

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

Essas solicitações retornam um feed de comentários como este:

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

Excluindo comentários

Para excluir um comentário, envie uma solicitação DELETE ao URL de edição do comentário. Esse URL está destacado no feed de comentários acima.

Formato de exportação

Com o Blogger, os usuários podem exportar e importar blogs usando um arquivo de exportação. Esse arquivo de exportação contém todas as postagens e comentários de um blog. O formato do arquivo de exportação é exatamente o mesmo do Atom descrito nas seções sobre como recuperar postagens e comentários. Esse arquivo de exportação terá o conteúdo do feed da postagem e do feed de comentários combinados em um documento.

Para exportar ou importar dados do blog usando o formato de exportação, acesse a página Configurações do blog. Para recuperar o arquivo de exportação de um blog usando a API Data, use o seguinte URL:

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

Para importar o arquivo de exportação, crie uma solicitação POST para o seguinte URL com o conteúdo do arquivo de exportação como os dados da solicitação e application/atom+xml como o tipo de conteúdo:

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

Nenhum dos URLs acima é compatível com parâmetros de consulta. As duas solicitações também precisam conter informações de autenticação, e somente os administradores do blog poderão importar/exportar o blog usando esses URLs do feed.

Observação: se você estiver criando seu próprio arquivo de exportação do Blogger, há uma restrição em relação à ordem das entradas de postagem e de comentários. O arquivo de exportação do Blogger listará todas as postagens primeiro, depois todos os comentários. É permitido intercalar entradas de postagens e comentários, desde que a entrada de comentário venha depois da postagem em questão.

Para mais informações sobre como o Blogger usa o formato Atom no arquivo de exportação, consulte o Guia de referência de protocolo.

Voltar ao início