Guia do desenvolvedor: protocolo

Importante: esta é uma versão antiga desta 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 cliente vejam e atualizem o conteúdo do Blogger na forma de feeds da API Google Data.

Seu aplicativo cliente pode usar a API de dados do Blogger para criar novas postagens de blog, editar ou excluir postagens de blog existentes e consultar postagens de blog 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 apresenta exemplos de interações básicas da API de dados usando XML e HTTP brutos. Depois de ler este documento, recomendamos saber mais sobre como interagir com a API usando nossas bibliotecas de cliente lendo as seções específicas da linguagem de programação deste guia do desenvolvedor.

Índice

Público-alvo

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

Neste documento, presumimos que você entenda as ideias gerais por trás do protocolo das APIs de dados do Google.

Se você está usando um sistema UNIX e quer testar os exemplos neste documento sem escrever nenhum código, os utilitários da linha de comando 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 da API Blogger Data, consulte o Guia de referência de protocolos.

Primeiros passos

Criar uma conta do Blogger

Inscreva-se em uma conta do Blogger para fins de teste. O Blogger usa as Contas do Google. Portanto, se você já tem uma Conta do Google, está tudo pronto.

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 privados. Ele pode se autenticar usando uma das duas abordagens: autenticação de proxy SMTP ou 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 das amostras nas seções seguintes deste documento pressupõe que você está fornecendo a autenticação apropriada.

Autenticação via proxy do AuthSub

A autenticação de proxy dSYM é 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 dSYM especiais que permitem ao cliente agir em nome de um usuário específico. Para informações mais detalhadas, consulte a documentação do SWF.

Quando um usuário visita seu aplicativo pela primeira vez, ele ainda não foi autenticado. Nesse caso, é necessário exibir algumas informações e um link que direcione o usuário para uma página do Google para autenticar sua solicitação de acesso aos blogs.

Os seguintes parâmetros de consulta são incluídos no URL dSYMRequest:

próxima
O URL da página a que o Google deve redirecionar o usuário após a autenticação.
escopo
Indica que o aplicativo está solicitando um token para acessar feeds do Blogger. A string do escopo a ser usada é http://www.blogger.com/feeds/ (codificada para URL, é claro).
proteger
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 dSYMRequest pode ser assim:

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.

Depois que o usuário faz a autenticação, o sistema dSYM os redireciona para o URL especificado no parâmetro de consulta next do URL de dSYMRequest. O sistema dSYM 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 GeoJSON 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 dSYMSessionToken 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 permanecerá válido.

O aplicativo pode usar o valor do token da sessão no cabeçalho Authorization das interações subsequentes com o Blogger.

Veja um exemplo de uma solicitação HTTP com 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 ClientLogin se o cliente for um cliente independente"instalado"(como um aplicativo de desktop). Para solicitar um token de autenticação usando o mecanismo ClientLogin, 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 pareçam com os 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.
serviço
O nome do serviço do Blogger é blogger. Para outros nomes de serviços, consulte a lista de nomes de serviço.
accountType
Sempre definir como GOOGLE ao usar a API do Blogger. Se esse parâmetro não for definido, o acesso dos usuários que também têm uma conta do G Suite será bloqueado.
source
Identifica seu aplicativo cliente. O formato precisa ser companyName-applicationName-versionID. Os exemplos usam o nome exampleCo-exampleApp-1.

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

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

Se for bem-sucedido, 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 de autenticação é o token de autorização que você enviará ao Blogger a cada uma das suas solicitações subsequentes. Portanto, mantenha uma cópia desse valor. Você pode ignorar os valores de 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 de autenticação retornada pela solicitação de ClientLogin.

Para mais informações sobre a autenticação do ClientLogin, incluindo solicitações e respostas de amostra, consulte a documentação de Autenticação em 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 ClientLogin, a solicitação de autenticação pode falhar e solicitar um desafio CAPTCHA. Se você quiser que o Google emita e processe o desafio CAPTCHA, envie o usuário para https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger, em vez do URL de gerenciamento do CAPTCHA fornecido na documentação do ClientLogin.

Recuperar uma lista de blogs

A API de dados do Blogger fornece um feed que lista os blogs para 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 cujas credenciais 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 saber mais sobre o que cada um desses elementos significa, consulte o documento Referência de protocolo das APIs de dados do Google ou a Especificação Atom 1.0 (em inglês).

Se a sua solicitação falhar por algum motivo, o Blogger pode retornar um código de status diferente. Veja mais informações sobre códigos de status HTTP no documento Referência de protocolo das APIs de dados do Google.

Como criar postagens

A API de dados do Blogger permite criar e publicar novas entradas de blog, bem como criar rascunhos de entradas.

Publicar uma postagem do blog

Após a autenticação, você poderá publicar novas entradas de 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 esta 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 postagens. Todas as novas postagens aparecerão como se tivessem sido criadas pelo usuário autenticado no momento.

Para publicar essa entrada, envie-a ao 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 de application/atom+xml. Em seguida, localize o URL de postagem do blog no metafeed localizando o elemento <link> em que o atributo rel termina com #post. O URL de postagem do blog é fornecido como o atributo href deste elemento, que está neste formato:

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

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

O Blogger cria uma postagem de blog usando a entrada enviada e, em seguida, 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 um elemento <id>.

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

Criando um rascunho de postagem do blog

Os rascunhos de postagens são criados da mesma forma que as postagens públicas, mas com um elemento <app:control> adicionado à entrada, indicando que a postagem não pode (ainda) 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.

É possível transformar um rascunho de postagem do blog em uma postagem publicada recuperando-a, definindo os dados do elemento <app:draft> para a string no e, em seguida, atualizando a postagem. A recuperação e a atualização das postagens são abordadas nas próximas duas seções.

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

Recuperar postagens

As seções a seguir descrevem como recuperar uma lista de postagens de 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 do blog de um blog público.

Recuperar 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. O Blogger retorna um feed que contém as entradas de blog apropriadas. Por exemplo, para ver uma lista de postagens do blog para liz@gmail.com, envie a seguinte solicitação HTTP para o Blogger (com o valor apropriado no lugar de blogID, é claro):

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

Em seguida, o Blogger retorna um código de status HTTP 200 OK e um feed Atom 1.0 padrão contendo as postagens do blog.

Veja a seguir um exemplo de feed de um blog com apenas uma postagem. Observe que editamos um pouco este exemplo para torná-lo um pouco mais legível para humanos. Mais especificamente, um feed real do Blogger contém URLs e IDs 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 de dados do Blogger, você pode solicitar um conjunto de entradas que correspondam a critérios específicos, como a solicitação de 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 de solicitação. Para obter todas as entradas do 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 contendo todas as postagens do blog que foram criadas no período especificado.

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

A API de dados do Blogger aceita os seguintes parâmetros de consulta:

alt
O tipo de feed a ser retornado, como atom (o padrão) ou rss.
/category
Especifica as 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 serão retornadas, como lastmodified (padrão), starttime ou updated.
min-min, publicado-max
Os limites nas datas de publicação das entradas.
start-index
O índice baseado em 1 do primeiro resultado a ser recuperado (para paginação).
minutos de atualização, máximo de atualizações
Os limites nas datas de atualização de entrada. Esses parâmetros de consulta são ignorados a menos que o parâmetro orderby esteja definido como updated.

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

Atualizando postagens

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

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 com versões futuras, verifique se, ao PUT uma entrada atualizada, você preserva todo o XML que estava presente quando recuperou a entrada do Blogger. Caso contrário, quando implementarmos novos dados e incluirmos elementos <new-awesome-feature> no feed, eles não serão retornados pelo cliente, e os usuários perderão a participação. Todas as bibliotecas de cliente da API Google Data processam isso corretamente. Portanto, se você estiver usando uma das bibliotecas, está tudo pronto.

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

Dica de solução de problemas: alguns firewalls bloqueiam as mensagens PUT HTTP. Para contornar isso, é possível incluir 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.

Como excluir postagens

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

Dica de solução de problemas: alguns firewalls bloqueiam as mensagens DELETE HTTP. Para contornar isso, é possível incluir um cabeçalho X-HTTP-Method-Override: DELETE em uma solicitação de 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).

Criar comentários

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

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

Como recuperar comentários

Para recuperar os comentários de uma postagem específica, envie um GET ao URL do feed de comentários desta postagem:

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

Ou, para ver os comentários de todas as postagens, use 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>

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

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

Para exportar ou importar dados de blogs 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 sobre autenticação, e somente administradores de blog poderão importar/exportar o blog usando esses URLs de feed.

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

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

Voltar ao início