Panduan Developer: Protokol

Penting: Ini adalah versi lama halaman ini. Untuk versi terbaru, gunakan link di menu navigasi sebelah kiri.

Blogger Data API memungkinkan aplikasi klien melihat dan memperbarui konten Blogger dalam bentuk feed Google Data API.

Aplikasi klien Anda dapat menggunakan Blogger Data API untuk membuat blog baru postingan, edit atau hapus postingan blog yang ada, dan kueri postingan blog yang cocok kriteria tertentu.

Selain memberikan beberapa latar belakang tentang kemampuan Blogger Data API, dokumen ini memberikan contoh interaksi Data API dasar menggunakan XML mentah dan HTTP. Setelah membaca dokumen ini, Anda dapat mempelajari lebih lanjut cara berinteraksi dengan API menggunakan library klien kami dengan membaca bagian khusus bahasa pemrograman dalam panduan developer ini.

Daftar Isi

  1. Penonton
  2. Memulai
    1. Membuat akun Blogger
  3. Mengautentikasi ke layanan Blogger
    1. Autentikasi proxy AuthSub
    2. Autentikasi nama pengguna/sandi ClientLogin
  4. Mengambil daftar blog
  5. Membuat postingan
    1. Memublikasikan postingan blog
    2. Membuat draf postingan blog
  6. Mengambil postingan
    1. Mengambil semua postingan blog
    2. Mengambil postingan menggunakan parameter kueri
  7. Memperbarui postingan
  8. Menghapus postingan
  9. Komentar
    1. Membuat komentar
    2. Mengambil komentar
    3. Menghapus komentar
  10. Format ekspor

Audiens

Dokumen ini ditujukan untuk programmer yang ingin menulis aplikasi klien yang dapat berinteraksi dengan Blogger menggunakan XML dan HTTP.

Dokumen ini mengasumsikan bahwa Anda memahami ide umum di balik Google Data API protokol standar.

Jika Anda menggunakan sistem UNIX dan ingin mencoba contoh dalam dokumen ini tanpa menulis kode apa pun, Anda mungkin akan menemukan utilitas command line UNIX curl atau wget yang berguna; untuk informasi selengkapnya, lihat halaman manual untuk utilitas tersebut.

Untuk informasi referensi Blogger Data API, lihat Panduan referensi protokol.

Memulai

Membuat akun Blogger

Anda mungkin ingin mendaftar untuk Akun Blogger untuk tujuan pengujian. Blogger menggunakan Akun Google, jadi jika Anda sudah memiliki akun Google, Anda sudah siap.

Mengautentikasi ke layanan Blogger

Anda dapat mengakses feed publik dan pribadi menggunakan Blogger Data API. Feed publik tidak memerlukan otentikasi, tetapi bersifat hanya baca. Jika Anda ingin memodifikasi blog, maka klien Anda perlu melakukan otentikasi sebelum meminta feed pribadi. Layanan ini dapat mengautentikasi menggunakan salah satu dari dua pendekatan: autentikasi proxy AuthSub atau autentikasi nama pengguna/sandi ClientLogin.

Untuk informasi selengkapnya tentang autentikasi dengan Google Data API secara umum, lihat dokumen autentikasi dokumentasi tambahan.

Sebagian besar contoh di bagian selanjutnya dari dokumen ini mengasumsikan bahwa Anda menyediakan otentikasi yang sesuai.

Autentikasi proxy AuthSub

Autentikasi proxy AuthSub digunakan oleh aplikasi web yang perlu mengautentikasi penggunanya ke Akun Google. Operator situs dan klien kode tidak memiliki akses ke nama pengguna dan sandi untuk pengguna Blogger; sebagai gantinya, klien memperoleh token AuthSub khusus yang memungkinkan klien untuk bertindak atas nama pengguna tertentu. Untuk mengetahui informasi yang lebih mendetail, lihat dokumentasi AuthSub.

Ketika pengguna pertama kali mengunjungi aplikasi Anda, mereka belum telah diotentikasi. Dalam hal ini, Anda perlu menampilkan beberapa informasi dan tautan mengarahkan pengguna ke halaman Google untuk mengautentikasi permintaan akses Anda ke blog mereka.

Parameter kueri berikut disertakan dalam URL AuthSubRequest:

berikutnya
URL halaman tujuan pengalihan pengguna oleh Google setelah autentikasi.
cakupan
Menunjukkan bahwa aplikasi meminta token untuk mengakses feed Blogger. String cakupan yang akan digunakan adalah http://www.blogger.com/feeds/ (tentunya berenkode URL).
aman
Menunjukkan apakah klien meminta token aman.
sesi
Menunjukkan apakah token yang ditampilkan dapat ditukarkan dengan token multiguna (sesi).

URL AuthSubRequest mungkin terlihat seperti ini:

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

Pengguna mengikuti link ke situs Google dan melakukan autentikasi ke URL menggunakan Akun Layanan Anda.

Setelah pengguna melakukan autentikasi, sistem AuthSub akan mengalihkan mereka ke URL yang Anda tentukan dalam parameter kueri next dari URL AuthSubRequest. Sistem AuthSub menambahkan token otentikasi ke URL tersebut, sebagai parameter kueri token. Contoh:

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

Nilai token ini mewakili token AuthSub sekali pakai. Dalam contoh ini, karena session=1 ditentukan, token ini dapat ditukar dengan token sesi AuthSub dengan memanggil layanan AuthSubSessionToken dengan token sekali pakai di header Otorisasi, sebagai berikut:

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

Respons layanan AuthSubSessionToken menyertakan header Token yang berisi token sesi dan header Expiration yang menunjukkan berapa lama token akan tetap valid.

Aplikasi Anda kemudian bisa menggunakan nilai token sesi di Header Authorization dari interaksi berikutnya dengan Blogger.

Berikut adalah contoh permintaan HTTP, yang berisi token tidak aman, yang mungkin dikirim ke 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

Autentikasi nama pengguna/sandi ClientLogin

Gunakan autentikasi ClientLogin jika klien Anda adalah klien mandiri dan satu pengguna yang "diinstal" (seperti aplikasi desktop). Untuk meminta token autentikasi menggunakan mekanisme ClientLogin, kirim permintaan POST ke URL berikut:

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

Isi POST harus berisi kumpulan parameter kueri yang terlihat seperti parameter yang diteruskan oleh formulir HTML, menggunakan jenis konten application/x-www-form-urlencoded. Semua parameter ini adalah:

Email
Alamat email pengguna.
Sandi
Sandi pengguna.
layanan
Nama layanan Blogger adalah blogger. (Untuk layanan lainnya nama, lihat daftar nama layanan.)
accountType
Nilai ini harus selalu disetel ke GOOGLE saat menggunakan Blogger API. Jika parameter ini tidak ditetapkan, pengguna yang juga memiliki akun G Suite tidak akan dapat mengaksesnya.
source
Mengidentifikasi aplikasi klien Anda. Harus dalam format companyName-applicationName-versionID. Contohnya menggunakan nama exampleCo-exampleApp-1.

Untuk mengetahui informasi selengkapnya tentang parameter, lihat dokumen Autentikasi untuk Aplikasi Terinstal.

Jika permintaan otentikasi gagal, maka server akan mengembalikan HTTP Kode status 403 Forbidden.

Jika berhasil, server akan menampilkan kode status HTTP 200 OK, ditambah tiga kode alfanumerik panjang dalam isi respons: SID, LSID, dan Auth. Nilai Auth adalah token otorisasi yang akan Anda kirim ke Blogger dengan setiap permintaan berikutnya, jadi simpan salinan nilai tersebut. Anda dapat mengabaikan nilai SID dan LSID.

Karena semua permintaan ke feed pribadi memerlukan otentikasi, Anda harus mengatur header Otorisasi dalam semua interaksi berikutnya dengan Blogger, menggunakan format berikut:

Authorization: GoogleLogin auth=yourAuthToken

Dengan yourAuthToken adalah string Auth yang ditampilkan oleh Permintaan ClientLogin.

Untuk mengetahui informasi selengkapnya tentang autentikasi ClientLogin, termasuk contoh permintaan dan respons, lihat dokumentasi Autentikasi untuk Aplikasi yang Diinstal.

Catatan: Gunakan token yang sama untuk semua permintaan dalam sesi tertentu; tidak memperoleh token baru untuk setiap permintaan Blogger.

Catatan: Seperti yang dijelaskan dalam dokumentasi ClientLogin, permintaan autentikasi dapat gagal dan meminta tantangan CAPTCHA. Jika Anda ingin Google mengeluarkan dan menangani tantangan CAPTCHA, kirim pengguna ke https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger (bukan URL penanganan CAPTCHA yang diberikan di ClientLogin dokumentasi).

Mengambil daftar blog

Blogger Data API menyediakan feed yang mencantumkan blog untuk user; feed tersebut dikenal sebagai "metafeed."

Kirim GET HTTP ke URL berikut untuk mengambil daftar blog:

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

Catatan: Anda juga dapat mengganti default dengan ID pengguna, yang memberi tahu Blogger untuk menampilkan daftar blog bagi pengguna yang kredensialnya menyertai permintaan.

Entri dalam metafeed mungkin terlihat seperti ini:

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

Untuk mengetahui informasi tentang arti setiap elemen tersebut, lihat dokumen Referensi Protokol Google Data API atau spesifikasi Atom 1.0.

Jika permintaan Anda gagal karena alasan tertentu, Blogger dapat menampilkan status yang berbeda pada kode sumber. Informasi selengkapnya tentang kode status HTTP juga tersedia di Data Google Referensi Protokol API Anda.

Membuat postingan

Blogger Data API memungkinkan Anda membuat dan memublikasikan entri blog baru, sebagai serta membuat draf entri.

Memublikasikan postingan blog

Setelah mengautentikasi, Anda dapat memublikasikan entri blog baru.

Pertama, buat representasi XML postingan yang akan dipublikasikan. XML ini harus berbentuk elemen <entry> Atom, yang mungkin terlihat seperti ini:

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

Catatan: Menetapkan penulis kustom untuk postingan saat ini tidak didukung. Semua postingan baru akan muncul seolah-olah dibuat oleh pengguna yang saat ini diotentikasi.

Untuk memublikasikan entri ini, kirimkan ke URL postingan blog sebagai berikut. Pertama, letakkan elemen <entry> Atom Anda di isi yang baru Permintaan POST, menggunakan konten application/atom+xml . Kemudian, temukan URL postingan blog di metafeed dengan menemukan elemen <link> tempat atribut rel diakhiri dengan #post. URL postingan blog diberikan sebagai href dari elemen ini, yang ada dalam format:

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

Catatan: URL ini sama dengan URL dalam tag <link rel="service.post"> yang muncul di bagian <head> pada versi blog yang dapat dibaca manusia.

Blogger membuat postingan blog menggunakan entri yang Anda kirim, lalu menampilkan respons HTTP kode status 201 CREATED, beserta salinan postingan baru di berupa elemen <entry>. Entri yang dikembalikan sama yang Anda kirim, namun juga berisi berbagai elemen yang ditambahkan oleh Blogger, seperti Elemen <id>.

Jika permintaan Anda gagal karena alasan tertentu, Blogger dapat menampilkan status yang berbeda pada kode sumber. Untuk mendapatkan informasi tentang kode status, lihat Data Google Dokumen referensi protokol API.

Membuat draf postingan blog

Postingan draf dibuat dengan cara yang sama seperti postingan publik, tetapi dengan Elemen <app:control> ditambahkan ke entri yang menunjukkan bahwa postingan tidak boleh (belum) dipublikasikan.

Elemen <app:control> ini harus berisi satu Elemen <app:draft> sebagai turunan:

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

Data yang terdapat dalam elemen <app:draft> harus berupa string yes agar postingan dapat dikenali sebagai draf.

Anda dapat mengubah draf postingan blog yang ada menjadi postingan yang dipublikasikan dengan mengambil postingan draf, menyetel data elemen <app:draft> ke string no, lalu memperbarui postingan. Mengambil dan memperbarui postingan dibahas dalam dua bagian berikutnya.

Catatan: Untuk mengetahui informasi selengkapnya tentang Atom Protokol Publikasi, yang mencakup <app:control> dan Namespace <app:draft>, lihat RFC 5023.

Mengambil postingan

Bagian berikut menjelaskan cara mengambil daftar posting blog, dengan dan tanpa parameter kueri.

Anda dapat melakukan kueri feed publik Blogger tanpa autentikasi. Oleh karena itu, Anda tidak perlu menetapkan parameter Otorisasi saat mengambil postingan blog dari blog publik.

Mengambil semua postingan blog

Untuk mengambil postingan pengguna, kirim permintaan GET HTTP ke URL feed blog. Blogger kemudian menampilkan feed yang berisi entri blog yang sesuai. Misalnya, untuk mendapatkan daftar postingan blog untuk lisa@gmail.com, kirim permintaan HTTP berikut ke Blogger (dengan nilai yang sesuai sebagai pengganti blogID, tentu saja):

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

Blogger kemudian menampilkan kode status HTTP 200 OK dan Feed Atom 1.0 yang berisi postingan blog.

Berikut contoh feed untuk blog yang hanya memiliki satu postingan. Pemberitahuan bahwa kita telah sedikit mengedit contoh ini agar lebih mudah dibaca oleh manusia. Secara khusus, feed Blogger asli berisi ID dan URL yang sebenarnya.

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

Mengambil postingan menggunakan parameter kueri

Blogger Data API memungkinkan Anda meminta sekumpulan entri yang cocok dengan yang ditentukan kriteria, seperti meminta postingan blog yang dipublikasikan atau diperbarui pada tanggal tertentu {i>range<i}.

Misalnya, untuk mengirim kueri rentang tanggal, tambahkan parameter published-min dan published-max ke URL permintaan. Untuk mendapatkan semua entri blog yang dibuat antara 16 Maret 2008 sampai 24 Maret 2008, mengirim tautan request ke URL feed blog:

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

Saat Anda mengirim permintaan GET tersebut, Blogger akan menampilkan HTTP Kode status 200 OK dan feed yang berisi postingan blog yang yang dibuat dalam rentang tanggal yang ditentukan.

Parameter updated-min dan updated-max juga dapat digunakan untuk mendapatkan semua entri blog yang diperbarui dalam rentang tertentu. Namun, perhatikan bahwa parameter ini diabaikan kecuali jika parameter orderby juga ditetapkan ke updated.

Blogger Data API mendukung parameter kueri berikut:

alt
Jenis feed yang akan ditampilkan, seperti atom (default) atau rss.
/category
Menentukan kategori (juga disebut sebagai label) untuk memfilter hasil feed. Misalnya, http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie menampilkan entri dengan label Fritz dan Laurie.
hasil maksimal
Jumlah maksimum entri yang akan ditampilkan.
urutan
Urutan untuk menampilkan entri, seperti lastmodified (default), starttime, atau updated.
dipublikasikan-min, dipublikasikan-maks
Batas pada tanggal publikasi entri.
start-index
Indeks berbasis 1 dari hasil pertama yang akan diambil (untuk paging).
diupdate-min, diupdate-maks
Batas pada tanggal pembaruan entri. Parameter kueri ini diabaikan kecuali jika parameter orderby ditetapkan ke updated.

Untuk informasi selengkapnya tentang parameter kueri, lihat Referensi Blogger Data API Guide dan Google Panduan Referensi Data API.

Memperbarui postingan

Untuk memperbarui postingan blog yang ada, pertama-tama ambil entri yang ingin Anda mengupdate, lalu mengubahnya, lalu mengirim permintaan PUT, dengan entri yang diperbarui dalam isi pesan, ke URL edit postingan. Pastikan bahwa Nilai <id> di entri yang Anda PUT sama persis dengan <id> dari entri yang ada.

URL edit ditandai dalam entri berikut:

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

PENTING: Untuk memastikan kompatibilitas dengan versi baru, pastikan bahwa saat Anda PUT entri yang diperbarui, Anda mempertahankan semua XML yang ada saat Anda mengambil entri dari Blogger. Jika tidak, saat menerapkan hal baru dan menyertakan <new-awesome-feature> di feed, klien Anda tidak akan menampilkannya dan pengguna akan posisi-posisi ini. Kebijakan Google Semua library klien Data API menangani hal ini dengan benar, jadi jika Anda menggunakan salah satu perpustakaan yang sudah siap Anda.

Catatan: Mengubah data penulis yang terkait dengan postingan saat ini tidak didukung.

Tips Pemecahan Masalah: Beberapa firewall memblokir pesan PUT HTTP. Untuk menyiasatinya, Anda dapat menyertakan Header X-HTTP-Method-Override: PUT dalam permintaan POST. Untuk mengetahui detailnya, lihat Google Data API dokumen dasar protokol.

Menghapus postingan

Untuk menghapus postingan, kirim permintaan DELETE ke URL edit postingan. Ini adalah URL yang sama dengan yang digunakan untuk mengupdate postingan.

Tips Pemecahan Masalah: Beberapa firewall memblokir pesan DELETE HTTP. Untuk menyiasatinya, Anda dapat menyertakan Header X-HTTP-Method-Override: DELETE di POST permintaan. Untuk mengetahui detailnya, lihat dokumen dasar-dasar protokol Google Data API.

Komentar

Blogger Data API memungkinkan pembuatan, pengambilan, dan penghapusan komentar. Memperbarui komentar tidak didukung (dan tidak tersedia di antarmuka web).

Membuat komentar

Untuk memposting komentar, buat elemen <entry> Atom seperti berikut ini:

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

Untuk memublikasikan komentar ini, tempatkan elemen <entry> Atom di isi permintaan POST baru, menggunakan jenis konten application/atom+xml. Lalu kirim POST permintaan ke URL Blogger yang sesuai:

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

Catatan: Saat ini, Anda hanya dapat memposting komentar ke blog yang dimiliki oleh pengguna terautentikasi.

Catatan: Menetapkan penulis kustom untuk komentar saat ini tidak didukung. Semua komentar baru akan muncul seolah-olah dibuat oleh pengguna yang saat ini diotentikasi.

Mengambil komentar

Anda dapat mengambil komentar untuk postingan tertentu dengan mengirimkan GET ke URL feed komentar postingan ini:

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

Atau, Anda bisa mendapatkan komentar dari semua postingan menggunakan URL feed komentar blog:

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

Permintaan ini menampilkan feed komentar yang terlihat seperti ini:

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

Menghapus komentar

Untuk menghapus komentar, kirim permintaan DELETE ke URL pengeditan komentar. URL ini ditandai di feed komentar di atas.

Format ekspor

Blogger memungkinkan pengguna mengekspor dan mengimpor blog mereka menggunakan file ekspor Blogger. File ekspor ini berisi semua postingan dan komentar untuk satu blog. Format untuk file ekspor adalah format Atom yang sama persis dengan yang dijelaskan di bagian pengambilan postingan dan komentar. File ekspor ini akan berisi gabungan konten feed postingan dan konten feed komentar menjadi satu dokumen.

Untuk mengekspor atau mengimpor data blog menggunakan format ekspor, Anda dapat mengunjungi Halaman Setelan untuk blog. Untuk mengambil file ekspor untuk blog menggunakan Data API, gunakan URL berikut:

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

Untuk mengimpor file ekspor, buat permintaan POST ke URL berikut dengan isi file ekspor sebagai data permintaan dan application/atom+xml sebagai jenis konten:

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

Tidak satu pun URL di atas yang mendukung parameter kueri. Kedua permintaan harus juga berisi informasi autentikasi dan hanya administrator blog akan dapat mengimpor/mengekspor blog menggunakan feed ini URL.

Catatan: Jika Anda membuat Blogger sendiri ekspor file, saat ini ada satu batasan terkait urutan postingan dan entri komentar. File ekspor Blogger akan mencantumkan semua postingan terlebih dahulu, lalu semua komentar. Penyisipan entri postingan dan komentar diizinkan asalkan entri komentar muncul setelah postingan yang dikomentari.

Untuk mengetahui informasi selengkapnya mengenai cara Blogger menggunakan format Atom dalam ekspor lihat file Protokol panduan referensi kami.

Kembali ke atas