Esta página foi traduzida pela API Cloud Translation.

Guia do desenvolvedor: protocolo

Importante: vamos encerrar o suporte à API Google Data v2.0 em 30 de setembro de 2024. Para continuar funcionando, atualize os aplicativos que usam a API Google Data v2.0 para a versão mais recente. Para usar a versão mais recente, use os links na barra de navegação à esquerda. Observação: embora algumas solicitações GET (como postagens de listagem) continuem sendo aceitas como URLs de feed, há pequenas diferenças no comportamento delas. Para mais informações, consulte a documentação Blogger Help.

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

O aplicativo cliente pode usar a API Blogger Data para criar novas postagens do blog, editar ou excluir postagens existentes e consultar postagens que correspondem a critérios específicos.

Além de fornecer alguns antecedentes sobre os recursos da API Data do Blogger, este documento apresenta exemplos de interações básicas da API Data usando XML bruto e HTTPS. Depois de ler este documento, talvez você queira saber mais sobre como interagir com a API usando nossas bibliotecas de cliente. Para isso, leia as seções específicas da 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.

Este documento pressupõe que você entenda as ideias gerais por trás do protocolo das APIs Data 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 UNIX curl ou wget podem ser úteis. Para mais informações, consulte as páginas de manual desses utilitários.

Para informações de referência da API Data do Blogger, consulte o guia de referência do protocolo.

Primeiros passos

Como criar uma conta do Blogger

Talvez seja melhor criar uma conta do Blogger para fins de teste. O Blogger usa Contas do Google. Se você já tem uma, está tudo pronto.

Como autorizar solicitações

Quando o 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 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 o app já usa essas opções, recomendamos migrar para o OAuth 2.0, se possível.

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

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

As solicitações para a API GData do Blogger relacionadas a dados de usuários 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 um aplicativo, você o registra no Google. Em seguida, o Google fornece informações que serão usadas mais tarde, como um ID e uma chave secreta do cliente.
Quando seu aplicativo precisa de acesso aos dados do usuário, ele solicita ao Google um escopo de acesso específico.
O Google exibe uma caixa de diálogo do OAuth para o usuário, pedindo que ele autorize o aplicativo a solicitar alguns dos dados dele.
Se o usuário aprovar, o Google vai fornecer ao seu app um token de acesso de curta duração.
O aplicativo solicita dados do usuário, anexando o token de acesso à solicitação.
Se o Google determinar que a solicitação e o token são válidos, ele vai retornar os dados solicitados.

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

Confira 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 de escopo, bem como das informações que o Google fornece durante o registro do aplicativo, como o ID e a chave secreta do cliente.

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

Como especificar uma versão

Cada solicitação enviada usando a API Data do Blogger precisa 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. No entanto, o cabeçalho HTTP é preferível sempre que possível.

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

Como extrair uma lista de blogs

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

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, o que instrui o Blogger a retornar a lista de blogs do usuário que tem as credenciais que 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 saber 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 poderá retornar um código de status diferente. Mais informações sobre os 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

A API Data do Blogger permite criar e publicar novas entradas de blog, além de criar rascunhos de entradas.

Publicar uma postagem do blog

Depois de fazer a autenticação, você poderá publicar novas entradas no 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 ser parecido com este:

<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 vão aparecer 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, 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 do elemento, que está neste formato:

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

Observação: esse URL é o mesmo que o URL na tag <link rel="service.post"> que aparece na seção <head> da versão legível por humanos 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 um elemento <id>.

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

Criar um rascunho de postagem do blog

As postagens de rascunho são criadas da mesma forma que as postagens públicas, mas com um elemento <app:control> adicionado à entrada indicando que a postagem ainda não pode 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 um rascunho de postagem do blog em uma postagem publicada, recupere o rascunho, defina os dados do elemento <app:draft> como a string no e atualize a postagem. A recuperação e a atualização de posts são abordadas nas próximas duas seções.

Observação: para mais informações sobre o protocolo de publicação do Atom, incluindo os namespaces <app:control> e <app:draft>, consulte o RFC 5023.

Como recuperar postagens

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

É possível consultar um feed público do Blogger sem autenticação. Portanto, não é necessário definir o parâmetro de autorização ao extrair postagens de um blog público.

Recuperação de todas as postagens do blog

Para recuperar as postagens do usuário, envie uma solicitação HTTP GET para o URL do feed do blog. O Blogger retorna um feed contendo as entradas de blog adequadas. Por exemplo, para receber 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 https://www.blogger.com/feeds/blogID/posts/default

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

Confira a seguir um exemplo de feed de um blog com apenas uma postagem. Perceba que editamos um pouco esse exemplo para que ele fique um pouco mais legível para humanos. 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 você quiser recuperar uma postagem que já foi recuperada, melhore a eficiência instruindo o Blogger a enviar a postagem somente se ela tiver sido alterada desde a última vez que foi recuperada.

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 especificada. Se as ETags corresponderem, a entrada não terá sido alterada, e o Blogger vai retornar um código de status HTTP 304 Not Modified.

Se as ETags não corresponderem, isso significa que a entrada foi modificada desde a última vez que você a solicitou, e o Blogger vai retornar a entrada.

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

A API Blogger Data permite solicitar um conjunto de entradas que correspondem 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 receber 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 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 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 do blog 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 Data do Blogger é compatível com os 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, 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.
published-min, published-max: Os limites das datas de publicação da entrada.
start-index: O índice com base em 1 do primeiro resultado a ser recuperado (para paginação).
updated-min, updated-max: Os limites nas datas de atualização da entrada. Esses parâmetros de consulta são ignorados, a menos que o parâmetro 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 que você pesquise postagens em um blog que correspondam a uma consulta.

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

Como atualizar postagens

Para atualizar uma postagem de 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 de <id> na entrada PUT corresponde exatamente ao <id> da entrada existente.

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 futura, ao PUT uma entrada atualizada, preserve todos os XMLs que estavam presentes quando você extraiu a entrada do Blogger. Caso contrário, quando implementarmos novos recursos e incluirmos elementos <new-awesome-feature> no feed, o cliente não os retornará e os usuários não vão conseguir aproveitar. As bibliotecas de cliente da API Data do Google lidam com isso corretamente. Se você estiver usando uma delas, está tudo certo.

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 esse problema, 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.

Como excluir postagens

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

Dica de solução de problemas: alguns firewalls bloqueiam mensagens DELETE HTTP. Para contornar esse problema, inclua 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 Data do Blogger permite criar, recuperar e excluir comentários. Não é possível atualizar comentários nem usar esse recurso na interface da Web.

Como criar comentários

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

  <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 do Blogger apropriado:

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

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

Ou você pode receber 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 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 comentários de um blog. O formato do arquivo exportado é exatamente o mesmo formato Atom descrito nas seções sobre como recuperar postagens e comentários. Esse arquivo de exportação vai conter o conteúdo do feed de postagens 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 https://www.blogger.com/feeds/blogID/archive

Para importar o arquivo exportado, crie uma solicitação POST para o URL abaixo com o conteúdo do arquivo exportado como dados de 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 oferece suporte a parâmetros de consulta. Ambas as solicitações também precisam conter informações de autenticação, e apenas os administradores do 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á uma restrição em relação à ordem das entradas de postagens e comentários. O arquivo de exportação do Blogger vai listar todas as postagens primeiro e depois todos os comentários. É permitido intercalar postagens e comentários, desde que a entrada do comentário seja posterior à 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