Esta página foi traduzida pela API Cloud Translation.

Guia do desenvolvedor: protocolo

Importante: vamos descontinuar o suporte à API Google Data v2.0 em 30 de setembro de 2024. Para garantir a funcionalidade contínua, atualize os aplicativos que dependem da API Google Data v2.0 para a versão mais recente. Para a versão mais recente, use os links na barra de navegação à esquerda. Observação: algumas solicitações GET (como postagens de fichas de empresas) continuarão sendo compatíveis como URLs de feed, mas há pequenas diferenças no comportamento. Para informações detalhadas, consulte a documentação da Ajuda do Blogger.

Com a API de dados do Blogger, os aplicativos clientes podem visualizar e atualizar o conteúdo do Blogger na forma de feeds da API Google Data.

Seu aplicativo cliente pode usar a API Blogger Data para criar novas postagens de blog, editar ou excluir postagens de blog existentes e consultar publicações que correspondam a critérios específicos.

Além de apresentar algumas informações sobre os recursos da API Blogger Data, este documento apresenta exemplos de interações básicas da API Data usando XML e HTTPS brutos. Depois de ler este documento, convém saber mais sobre como interagir com a API usando nossas bibliotecas de cliente. Para isso, leia as seções específicas de linguagem de programação deste Guia para desenvolvedores.

Conteúdo

Público-alvo

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

Neste documento, presumimos que você entenda as ideias gerais por trás do protocolo de 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 da API de dados do Blogger, 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 realizar um teste. O Blogger usa as Contas do Google. Portanto, se você já tem uma Conta do Google, não precisa fazer mais nada.

Como autorizar solicitações

Quando seu aplicativo solicita dados não públicos do usuário, ele precisa incluir um token de autorização. O token também identifica o aplicativo para o Google.

Sobre os protocolos de autorização

Recomendamos o uso do OAuth 2.0 para autorizar solicitações.

A API de GData do Blogger também oferece suporte a opções de autorização mais antigas, como OAuth 1.0, AuthSub ou ClientLogin. No entanto, na maioria dos casos, não recomendamos o uso dessas outras opções. Se seu aplicativo já usa essas opções, recomendamos migrar para o OAuth 2.0, se possível.

Se o aplicativo tiver determinados requisitos de autorização incomuns, como fazer login e solicitar acesso aos dados ao mesmo tempo (híbrido) ou delegação de autoridade em todo o domínio (2LO), não será possível usar tokens do OAuth 2.0 no momento. Nesses casos, é necessário usar tokens OAuth 1.0.

Autorização de solicitações com o OAuth 2.0

As solicitações para a API Blogger GData relacionadas a dados do usuário não públicos precisam ser autorizadas por um usuário autenticado.

Os detalhes do processo de autorização, ou "fluxo", para o OAuth 2.0 variam um pouco, dependendo do tipo de aplicativo que você está criando. O processo geral a seguir se aplica a todos os tipos de aplicativo:

Ao criar seu aplicativo, você o registra no Google. Em seguida, o Google fornece as informações que serão necessárias mais tarde, como um ID e uma chave secreta do cliente.
Quando seu aplicativo precisa de acesso aos dados do usuário, ele pede ao Google um escopo específico de acesso.
O Google exibe uma caixa de diálogo OAuth para o usuário, pedindo que ele autorize seu aplicativo a solicitar alguns dos dados dele.
Se o usuário aprovar, o Google fornecerá ao aplicativo um token de acesso de curta duração.
Seu aplicativo solicita dados do usuário, anexando o token de acesso à solicitação.
Se o Google determinar que sua solicitação e o token são válidos, ele retornará os dados solicitados.

Alguns fluxos incluem outras etapas, como usar tokens de atualização para adquirir novos tokens de acesso. Para informações detalhadas sobre fluxos para vários tipos de aplicativos, consulte a documentação do OAuth 2.0 do Google.

Veja as informações de escopo do OAuth 2.0 para a API GData do Blogger:

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

Para solicitar acesso usando o OAuth 2.0, seu aplicativo precisa das informações do escopo, bem como das informações fornecidas pelo Google durante o registro do aplicativo (como o ID e/ou a chave secreta do cliente).

Dica: as bibliotecas de cliente das APIs do Google cuidam de parte do processo de autorização para você. Elas estão disponíveis para uma série de linguagens de programação. Consulte a página Bibliotecas e exemplos para mais detalhes.

Especificar uma versão

Todas as solicitações enviadas usando a API Blogger Data precisam especificar a versão 2 da API.

Para especificar um número de versão, use o cabeçalho HTTP GData-Version:

GData-Version: 2

Como alternativa, se não for possível definir cabeçalhos HTTP, especifique v=2 como um parâmetro de consulta no URL. Mas o cabeçalho HTTP é preferível sempre que possível.

Observação: as bibliotecas de cliente fornecem automaticamente cabeçalhos de versão apropriados. Portanto, não use o parâmetro de consulta v=2 quando estiver usando uma biblioteca de cliente.

Como recuperar uma lista de blogs

A API Blogger Data 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:

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

Em que o ID do perfil é o número no URL da página de perfil do usuário.

Observação: também é possível 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 esta aparência:

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

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

Se a solicitação falhar por algum motivo, o Blogger pode 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.

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

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

Primeiro, crie uma representação XML da postagem que será publicada. Esse XML precisa estar no formato 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 postagens. Todas as novas postagens vão aparecer como se tivessem sido criadas pelo usuário autenticado no momento.

Para publicar essa entrada, envie-a para o URL de postagem do blog, conforme mostrado a seguir. 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, encontre o URL da postagem do blog no metafeed localizando o elemento <link> em que o atributo rel termina com #post. O URL da postagem do blog é fornecido como o atributo href desse elemento, que tem este formato:

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

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

O Blogger cria uma postagem do blog usando a entrada que você enviou e retorna um código de status HTTP 201 CREATED 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 solicitação falhar por algum motivo, o Blogger pode 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.

Criar um rascunho de postagem do blog

As postagens de rascunho são criadas 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://www.w3.org/2007/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 o rascunho de uma postagem de blog em uma postagem publicada, recupere a postagem de rascunho, defina os dados do elemento <app:draft> como a string no e atualize 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 protocolo Atom Publishing, incluindo os namespaces <app:control> e <app:draft>, consulte RFC 5023 (link em inglês).

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

Como recuperar todas as postagens do blog

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

GET https://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 que contém as postagens.

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 as pessoas. Em especial, um feed real do Blogger contém IDs e URLs reais.

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

Como recuperar uma postagem do blog novamente

Se quiser recuperar uma postagem recuperada anteriormente, é possível melhorar a eficiência dizendo ao Blogger para enviar a postagem somente se ela tiver sido alterada desde a última vez que você a recuperou.

Para fazer esse tipo de recuperação condicional, envie uma solicitação HTTP GET que inclua um cabeçalho HTTP If-None-Match. No cabeçalho, especifique a ETag da entrada, que pode ser encontrada no atributo gd:etag do elemento <entry>.

Exemplo:

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

Quando o Blogger recebe essa solicitação, ele verifica se a entrada solicitada tem a mesma ETag que a especificada. Se elas forem correspondentes, a entrada não mudou e o Blogger retornará um código de status HTTP 304 Not Modified.

Se as ETags não corresponderem, significa que a entrada foi modificada desde a última solicitação, e o Blogger a retorna.

Para mais informações sobre ETags, consulte o Guia de referência das APIs de dados do Google.

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 a solicitação de postagens de 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 de feed do blog:

GET https://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 postagens de blog criadas no período especificado.

Os parâmetros updated-min e updated-max também podem ser usados para recuperar todas as entradas do blog atualizadas em um determinado intervalo. No entanto, esses parâmetros serão ignorados, a menos que o parâmetro orderby também esteja 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 as categorias (também conhecidas como rótulos) para filtrar os resultados do feed. Por exemplo, https://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.
mín. publicado, máx. publicado: Os limites para as datas de publicação da entrada.
start-index: O índice baseado em 1 do primeiro resultado a ser recuperado (para paginação).
mínimo atualizado, máximo atualizado: Os limites para as datas de atualização de entradas. Esses parâmetros de consulta são ignorados, a menos que orderby seja definido como updated.
caminho: O caminho do link permanente de uma postagem. Por exemplo, para uma postagem com o URL http://buzz.blogger.com/2011/08/bloggers-fresh-new-look.html, o caminho do link permanente é /2011/08/bloggers-fresh-new-look.html.
q: String de consulta de texto completo. Isso permite pesquisar em um blog postagens que correspondam a uma consulta.

Para mais informações sobre os 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 você quer atualizar, 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 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>

IMPORTANTE: para garantir a compatibilidade com versões futuras, ao usar PUT em uma entrada atualizada, preserve todo o XML que estava presente quando você recuperou a entrada do Blogger. Caso contrário, quando implementarmos novos recursos e incluirmos elementos <new-awesome-feature> no feed, seu cliente não os retornará e seus usuários não serão afetados. Todas as bibliotecas de cliente da API Google Data lidam com isso corretamente. Portanto, se você estiver usando uma das bibliotecas, não precisa fazer nada.

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

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

Excluindo postagens

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

Dica para solução de problemas: alguns firewalls bloqueiam mensagens DELETE HTTP. Para contornar isso, você pode incluir um cabeçalho X-HTTP-Method-Override: DELETE em uma solicitação POST. Para mais detalhes, consulte o documento Princípios básicos 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 estar 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 https://www.blogger.com/feeds/blogID/postID/comments/default

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

Observação: no momento, não é possível definir um autor personalizado para comentários. Todos os novos comentários vão aparecer 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 para o URL do feed de comentários desta postagem:

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

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

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

Excluir comentários

Para excluir um comentário, envie uma solicitação DELETE para o URL de edição dele. 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 dessa ferramenta. 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 formato Atom descrito nas seções sobre como recuperar postagens e comentários. Esse arquivo de exportação conterá o conteúdo do feed de postagem e do feed de comentários combinado em um documento.

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

GET https://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 https://www.blogger.com/feeds/blogID/archive/full

Nenhum dos URLs acima suporta 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, no momento há uma restrição quanto à ordem das entradas de postagens e comentários. O arquivo de exportação do Blogger listará todas as postagens primeiro e depois todos os comentários. A intercalação de entradas de postagens e comentários é permitida, desde que a entrada de comentário venha depois da postagem a que ele se refere.

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