Ta strona została przetłumaczona przez Cloud Translation API.

Przewodnik dla programistów: protokół

Ważne: to jest starsza wersja tej strony. Aby pobrać najnowszą wersję, użyj linków w pasku nawigacyjnym po lewej stronie.

Interfejs Blogger Data API umożliwia aplikacjom klienckim wyświetlanie i aktualizowanie treści Bloggera w postaci plików danych Google Data API.

Za pomocą interfejsu Blogger Data API aplikacja klienta może tworzyć nowe posty na blogu, edytować i usuwać istniejące posty oraz wysyłać zapytania o posty spełniające określone kryteria.

Ten dokument zawiera informacje o możliwościach interfejsu Data API w Bloggerze oraz przykłady podstawowych interakcji z interfejsem Data API za pomocą nieprzetworzonego kodu XML i protokołu HTTP. Po przeczytaniu tego dokumentu możesz dowiedzieć się więcej o interakcjach z interfejsem API za pomocą naszych bibliotek klienta. Wystarczy, że przeczytasz sekcje dotyczące języka programowania w tym przewodniku dla programistów.

Spis treści

Odbiorcy

Ten dokument jest przeznaczony dla programistów, którzy chcą pisać aplikacje klienckie, które mogą wchodzić w interakcje z Bloggerem za pomocą XML i HTTP.

W tym dokumencie zakładamy, że rozumiesz ogólne założenia protokołu interfejsów Google Data API.

Jeśli używasz systemu UNIX i chcesz wypróbować przykłady z tego dokumentu bez pisania kodu, przydatne mogą być narzędzia wiersza poleceń UNIX curl lub wget. Więcej informacji znajdziesz w instrukcji obsługi tych narzędzi.

Informacje referencyjne interfejsu Blogger Data API znajdziesz w przewodniku po protokole.

Pierwsze kroki

Tworzenie konta w Bloggerze

Możesz założyć konto Blogger na potrzeby testowania. Blogger korzysta z kont Google, więc jeśli masz już konto Google, nie musisz nic więcej robić.

Uwierzytelnianie w usłudze Blogger

Za pomocą interfejsu Blogger Data API możesz uzyskać dostęp do plików danych publicznych i prywatnych. Publiczne kanały nie wymagają uwierzytelniania, ale są tylko do odczytu. Jeśli chcesz zmodyfikować blogi, Twój klient musi się uwierzytelnić, zanim poprosi o pliki danych prywatnych. Może on uwierzytelniać się na 2 sposoby: za pomocą uwierzytelniania proxy AuthSub lub uwierzytelniania nazwą użytkownika i hasłem ClientLogin.

Więcej informacji o uwierzytelnianiu za pomocą interfejsów Google Data API znajdziesz w dokumentacji dotyczącej uwierzytelniania.

Większość przykładów w kolejnych sekcjach tego dokumentu zakłada, że podajesz odpowiednie uwierzytelnianie.

Uwierzytelnianie proxy AuthSub

Uwierzytelnianie proxy AuthSub jest używane przez aplikacje internetowe, które muszą uwierzytelniać użytkowników na kontach Google. Operator witryny i kod klienta nie mają dostępu do nazwy użytkownika ani hasła użytkownika Bloggera. Zamiast tego klient uzyskuje specjalne tokeny AuthSub, które umożliwiają mu działanie w imieniu konkretnego użytkownika. Więcej szczegółowych informacji znajdziesz w dokumentacji AuthSub.

Gdy użytkownik po raz pierwszy odwiedza Twoją aplikację, nie został jeszcze uwierzytelniony. W takim przypadku musisz wyświetlić pewne informacje i link, który przekieruje użytkownika na stronę Google, gdzie będzie mógł uwierzytelnić Twoje żądanie dostępu do blogów.

Adres URL AuthSubRequest zawiera te parametry zapytania:

dalej: Adres URL strony, na którą Google powinno przekierować użytkownika po uwierzytelnieniu.
zakres: Wskazuje, że aplikacja prosi o token dostępu do kanałów Bloggera. Użyj ciągu zakresu http://www.blogger.com/feeds/ (oczywiście zakodowanego w formacie URL).
Bezpieczny: Wskazuje, czy klient prosi o token zabezpieczony.
sesja: Wskazuje, czy zwrócony token można zamienić na token wielokrotnego użytku (sesji).

Adres URL AuthSubRequest może wyglądać tak:

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

Użytkownik klika link do witryny Google i uwierzytelnia swoje konto Google.

Po uwierzytelnieniu użytkownika system AuthSub przekieruje go na adres URL określony w parametrze zapytania next adresu URL AuthSubRequest. System AuthSub dołącza do tego adresu URL token uwierzytelniający jako wartość parametru zapytania token. Na przykład:

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

Ta wartość tokena reprezentuje token AuthSub jednorazowego użytku. W tym przykładzie, gdy podano session=1, ten token można zamienić na token sesji AuthSub, wywołując usługę AuthSubSessionToken za pomocą tokena jednorazowego w nagłówku Authorization w ten sposób:

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

Odpowiedź usługi AuthSubSessionToken zawiera nagłówek Token z tokenem sesji oraz nagłówek Expiration z czasem ważności tokena.

Następnie aplikacja może używać wartości tokena sesji w nagłówku Authorization podczas kolejnych interakcji z Bloggerem.

Oto przykład żądania HTTP zawierającego niezabezpieczony token, które możesz wysłać do Bloggera:

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

uwierzytelnianie za pomocą nazwy użytkownika i hasła ClientLogin

Użyj uwierzytelniania ClientLogin, jeśli Twój klient jest samodzielnym, jednoużytkownikowym klientem „zainstalowanym” (np. aplikacją na komputer). Aby poprosić o token uwierzytelniający za pomocą mechanizmu ClientLogin, wyślij POSTżądanie pod tym adresem URL:

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

Treść elementu POST powinna zawierać zestaw parametrów zapytania, które wyglądają jak parametry przekazywane przez formularz HTML za pomocą typu treści application/x-www-form-urlencoded. Te parametry:

E-mail: Adres e-mail użytkownika.
Passwd: Hasło użytkownika.
usługa: Nazwa usługi Blogger to blogger. (inne nazwy usług znajdziesz na liście nazw usług).
accountType: W przypadku korzystania z interfejsu Blogger API wartość tego pola powinna zawsze wynosić GOOGLE. Nieustawienie tego parametru uniemożliwi dostęp użytkownikom, którzy mają też konto G Suite.
źródło: Identyfikuje Twoją aplikację kliencką. Musi mieć format companyName-applicationName-versionID. W przykladach użyto nazwy exampleCo-exampleApp-1.

Więcej informacji o parametrach znajdziesz w dokumentacji Uwierzytelnianie w zainstalowanych aplikacjach.

Jeśli żądanie uwierzytelniania zakończy się niepowodzeniem, serwer zwróci kod stanu HTTP403 Forbidden.

Jeśli się powiedzie, serwer zwraca kod stanu HTTP 200 OK oraz 3 długie kody alfanumeryczne w treści odpowiedzi: SID, LSID i Auth. Wartość Auth to token autoryzacji, który będziesz wysyłać do Bloggera w przypadku każdej kolejnej prośby, dlatego zachowaj kopię tej wartości. Wartości SID i LSID możesz zignorować.

Ponieważ wszystkie żądania dotyczące prywatnych kanałów wymagają uwierzytelnienia, musisz ustawić nagłówek Authorization we wszystkich kolejnych interakcjach z Bloggerem, używając tego formatu:

Authorization: GoogleLogin auth=yourAuthToken

Gdzie yourAuthToken to ciąg znaków autoryzacji zwrócony przez żądanie ClientLogin.

Więcej informacji o uwierzytelnianiu za pomocą ClientLogin, w tym przykładowe żądania i odpowiedzi, znajdziesz w dokumentacji Uwierzytelnianie w zainstalowanych aplikacjach.

Uwaga: używaj tego samego tokena do wszystkich żądań w danej sesji. Nie pobieraj nowego tokena dla każdego żądania Bloggera.

Uwaga: jak opisano w dokumentacji ClientLogin, żądanie uwierzytelnienia może zakończyć się niepowodzeniem i wymagać rozwiązania captcha. Jeśli chcesz, aby Google wyświetlał i obsługiwał test CAPTCHA, prześlij użytkownika do https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger(zamiast do adresu URL obsługiwanego przez CAPTCHA podanego w dokumentacji ClientLogin).

Pobieranie listy blogów

Interfejs Blogger Data API udostępnia plik danych, który zawiera listę blogów danego użytkownika. Taki plik danych jest nazywany „metaplikiem danych”.

Aby pobrać listę blogów, wyślij żądanie HTTP GET na ten adres URL:

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

Uwaga: możesz też użyć wartości default zamiast identyfikatora użytkownika, aby Blogger zwrócił listę blogów dla użytkownika, którego poświadczenia tożsamości towarzyszą żądaniu.

Wpis w metapliku może wyglądać tak:

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

Informacje o znaczeniu poszczególnych elementów znajdziesz w dokumentacji Google Data APIs Protocol Reference lub w specyfikacji Atom 1.0.

Jeśli z jakiegoś powodu nie uda się zrealizować żądania, Blogger może zwrócić inny kod stanu. Więcej informacji o kodach stanu HTTP znajdziesz też w dokumentacji [Google Data API] Reference (w języku angielskim).

Tworzenie postów

Interfejs Blogger Data API umożliwia tworzenie i publikowanie nowych wpisów na blogu, a także tworzenie ich wersji roboczych.

Publikowanie posta na blogu

Po uwierzytelnieniu możesz publikować nowe wpisy w blogu.

Najpierw utwórz post w formacie XML, który chcesz opublikować. Plik XML musi mieć postać elementu Atom <entry>, który może wyglądać tak:

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

Uwaga: nie można obecnie ustawić niestandardowego autora postów. Wszystkie nowe posty będą wyglądać tak, jakby zostały utworzone przez aktualnie uwierzytelnionego użytkownika.

Aby opublikować ten wpis, prześlij go pod adresem URL posta na blogu w ten sposób: Najpierw umieść element Atom <entry> w treści nowej prośby POST, używając typu treści application/atom+xml. Następnie znajdź w metadanych adres URL wpisu na blogu, szukając elementu <link>, w którym atrybut rel kończy się na #post. Adres URL posta na blogu jest podawany jako atrybut href tego elementu w takim formacie:

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

Uwaga: ten adres URL jest taki sam jak adres URL w tagu <link rel="service.post">, który znajduje się w sekcji <head> w wersji bloga przeznaczonej do odczytu przez człowieka.

Blogger tworzy post na blogu, korzystając z przesłanego wpisu, a następnie zwraca kod stanu HTTP 201 CREATED oraz kopię nowego posta w postaci elementu <entry>. Zwrócony wpis jest taki sam jak wysłany, ale zawiera też różne elementy dodane przez Bloggera, takie jak element <id>.

Jeśli z jakiegoś powodu nie uda się zrealizować żądania, Blogger może zwrócić inny kod stanu. Informacje o kodach stanu znajdziesz w dokumentacji interfejsu Google Data API.

Tworzenie wersji roboczej posta na blogu

Posty w postaci szkicu są tworzone w taki sam sposób jak posty publiczne, ale z dodatkowym elementem <app:control>, który wskazuje, że post nie powinien (jeszcze) zostać opublikowany.

Ten element <app:control> powinien zawierać jako element podrzędny tylko jeden element <app:draft>:

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

Aby wpis był rozpoznawany jako wersja robocza, dane zawarte w elemencie <app:draft> muszą być ciągiem znaków yes.

Aby zmienić istniejący opublikowany post na wersję roboczą, pobierz post, ustaw dane elementu <app:draft> na ciąg znaków no, a następnie zaktualizuj post. W następnych dwóch sekcjach omawiamy pobieranie i aktualizowanie postów.

Uwaga: więcej informacji o protokole Atom Publishing Protocol, w tym o przestrzeniach nazw <app:control> i <app:draft>, znajdziesz w dokumencie RFC 5023.

Pobieranie postów

W sekcjach poniżej znajdziesz instrukcje pobierania listy wpisów na blogu z parametrami zapytania i bez nich.

Możesz wysyłać zapytania do publicznego kanału Bloggera bez uwierzytelniania. Dlatego podczas pobierania postów z publicznego bloga nie musisz ustawiać parametru Authorization.

Pobieranie wszystkich wpisów na blogu

Aby pobrać wpisy użytkownika, wyślij żądanie HTTP GET do adresu URL kanału bloga. Blogger zwraca wtedy kanał zawierający odpowiednie wpisy na blogu. Aby na przykład uzyskać listę postów na blogu dla użytkownika liz@gmail.com, wyślij do Bloggera takie żądanie HTTP (z odpowiednią wartością zamiast blogID):

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

Następnie Blogger zwraca kod stanu HTTP 200 OK i standardowy kanał Atom 1.0 zawierający wpisy na blogu.

Poniżej znajdziesz przykład kanału dla bloga z jednym wpisem. Pamiętaj, że ten przykład został nieznacznie zmodyfikowany, aby był bardziej czytelny dla ludzi. Prawdziwy plik danych Bloggera zawiera m.in. rzeczywiste identyfikatory i adresy URL.

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

Pobieranie postów za pomocą parametrów zapytania

Interfejs Blogger Data API umożliwia żądanie zestawu wpisów, które odpowiadają określonym kryteriam, np. żądanie postów na blogu opublikowanych lub zaktualizowanych w określonym przedziale czasowym.

Aby na przykład wysłać zapytanie dotyczące zakresu dat, do adresu URL żądania dodaj parametry published-min i published-max. Aby pobrać wszystkie wpisy na blogu utworzone między 16 marca 2008 r. a 24 marca 2008 r., wyślij żądanie HTTP do adresu URL kanału bloga:

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

Gdy prześlesz żądanie GET, Blogger zwróci kod stanu HTTP 200 OK i kanał zawierający wszystkie wpisy na blogu utworzone w określonym zakresie dat.

Parametry updated-min i updated-max mogą też służyć do uzyskiwania wszystkich wpisów na blogu z danego zakresu. Pamiętaj jednak, że te parametry są ignorowane, chyba że parametr orderby ma wartość updated.

Interfejs Blogger Data API obsługuje te parametry zapytania:

alternatywnych: Typ pliku danych do zwrócenia, np. atom (domyślny) lub rss.
/category: Określa kategorie (zwane też etykietami) służące do filtrowania wyników w pliku danych. Na przykład http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie zwraca wpisy z etykietami Fritz i Laurie.
max-results: Maksymalna liczba wpisów do zwrócenia.
orderby: Kolejność zwracania wpisów, np. lastmodified (domyślnie), starttime lub updated.
published-min, published-max: Granice dat publikacji wpisów.
start-index: Indeks pierwszego wyniku, który ma zostać pobrany (dla pobierania stron).
updated-min, updated-max: Granice dat aktualizacji wpisów. Te parametry zapytania są ignorowane, chyba że parametr orderby ma wartość updated.

Więcej informacji o parametrach zapytań znajdziesz w przewodniku po interfejsie Blogger Data API oraz w przewodniku po interfejsach Google Data API.

Aktualizowanie postów

Aby zaktualizować istniejący wpis na blogu, najpierw pobierasz wpis, który chcesz zaktualizować, a potem go modyfikujesz. Następnie wysyłasz PUT z aktualizowanym wpisem w ciele wiadomości na adres URL edycji wpisu. Upewnij się, że wartość <id> w pliku PUT dokładnie odpowiada wartości <id> w dotychczasowym pliku.

Adres URL edycji jest wyróżniony na czerwono w tym wpisie:

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

WAŻNE: aby zapewnić zgodność wsteczną, pamiętaj, że podczas PUT zaktualizowanego wpisu zachowaj wszystkie elementy XML, które były obecne podczas pobierania wpisu z Bloggera. Jeśli nie, gdy wdrożymy nowe elementy i umieścimy w pliku danych <new-awesome-feature>, Twój klient nie zwróci tych elementów, a Twoi użytkownicy nie będą mogli z nich korzystać. Wszystkie biblioteki klienta interfejsu Google Data API obsługują to prawidłowo, więc jeśli używasz jednej z tych bibliotek, nie musisz nic więcej robić.

Uwaga: modyfikowanie danych autora powiązanych z postami nie jest obecnie obsługiwane.

Wskazówka dotycząca rozwiązywania problemów: niektóre zapory sieciowe blokują wiadomości HTTPPUT. Aby tego uniknąć, możesz dodać nagłówek X-HTTP-Method-Override: PUT do żądania POST. Szczegółowe informacje znajdziesz w dokumentacji interfejsu Google Data API dotyczącej podstaw protokołu.

Usuwanie postów

Aby usunąć post, wyślij DELETE do URL-a edycji posta. Jest to ten sam adres URL, który jest używany do aktualizowania postów.

Wskazówka dotycząca rozwiązywania problemów: niektóre zapory sieciowe blokują wiadomości HTTPDELETE. Aby tego uniknąć, możesz dodać nagłówek X-HTTP-Method-Override: DELETE do żądania POST. Szczegółowe informacje znajdziesz w dokumentacji interfejsu Google Data API dotyczącej podstaw protokołu.

Komentarze

Interfejs Blogger Data API umożliwia tworzenie, pobieranie i usuwanie komentarzy. Aktualizowanie komentarzy nie jest obsługiwane (nie jest też dostępne w interfejsie internetowym).

Tworzenie komentarzy

Aby opublikować komentarz, utwórz element Atom <entry>, na przykład:

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

Aby opublikować ten komentarz, umieść element Atom <entry> w treści nowej prośby POST, używając typu treści application/atom+xml. Następnie wyślij POSTprośbę do odpowiedniego adresu URL Bloggera:

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

Uwaga: obecnie możesz dodawać komentarze tylko do bloga należącego do uwierzytelnionego użytkownika.

Uwaga: nie można obecnie ustawić niestandardowego autora komentarzy. Wszystkie nowe komentarze będą wyglądać tak, jakby zostały utworzone przez aktualnie uwierzytelnionego użytkownika.

Pobieranie komentarzy

Komentarze do konkretnego posta możesz pobrać, wysyłając GET do adresu URL kanału komentarzy do tego posta:

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

Możesz też pobrać komentarze ze wszystkich postów, korzystając z kanału komentarzy do bloga. Adres URL:

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

Te żądania zwracają plik danych z komentarzami, który wygląda tak:

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

Usuwanie komentarzy

Aby usunąć komentarz, wyślij DELETE do adresu URL edycji komentarza. Ten adres URL jest wyróżniony w powyższym okienku komentarzy.

Format eksportu

Blogger umożliwia użytkownikom eksportowanie i importowanie blogów za pomocą pliku eksportu Bloggera. Ten plik eksportu zawiera wszystkie posty i komentarze z jednego bloga. Format pliku wyeksportowanego jest dokładnie taki sam jak format Atom opisany w sekcji dotyczących pobierania postów i komentarzy. Ten plik eksportu będzie zawierać połączone treści z kanału postów i kanału komentarzy w jednym dokumencie.

Aby wyeksportować lub zaimportować dane bloga w formacie eksportu, otwórz stronę Ustawienia bloga. Aby pobrać plik eksportu bloga za pomocą interfejsu Data API, użyj tego adresu URL:

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

Aby zaimportować plik wyeksportowany, utwórz żądanie POST do tego adresu URL, podając jako dane żądania zawartość pliku wyeksportowanego, a jako typ treści application/atom+xml:

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

Żaden z adresów URL nie obsługuje parametrów zapytania. Oba żądania muszą też zawierać informacje o uwierzytelnianiu. Tylko administratorzy bloga będą mogli importować i eksportować bloga za pomocą tych adresów URL.

Uwaga: jeśli tworzysz własny plik eksportu z Bloggera, obecnie obowiązuje jedno ograniczenie dotyczące kolejności wpisów w postach i komentarzach. Plik eksportu Bloggera zawiera najpierw listę wszystkich postów, a potem wszystkich komentarzy. Dopuszczamy przeplatanie wpisów z postami i komentarzami, o ile komentarz pojawia się po wpisie, do którego się odnosi.

Więcej informacji o tym, jak Blogger używa formatu Atom w pliku wyeksportowanym, znajdziesz w przewodniku po protokole.

Powrót do góry