diff --git a/5-network/05-fetch-crossorigin/1-do-we-need-origin/solution.md b/5-network/05-fetch-crossorigin/1-do-we-need-origin/solution.md
index d44494e18..6a9e1ff61 100644
--- a/5-network/05-fetch-crossorigin/1-do-we-need-origin/solution.md
+++ b/5-network/05-fetch-crossorigin/1-do-we-need-origin/solution.md
@@ -1,9 +1,9 @@
-We need `Origin`, because sometimes `Referer` is absent. For instance, when we `fetch` HTTP-page from HTTPS (access less secure from more secure), then there's no `Referer`.
+Kita membutuhkan *`Origin`*, karena terkadang *`Referer`* tidak digunakan. Misalnya, saat kita *`fetch`* halaman HTTP dari HTTPS(mengakses yang kurang aman dari yang aman), maka tidak memakai *`Referer`*.
 
-The [Content Security Policy](http://en.wikipedia.org/wiki/Content_Security_Policy) may forbid sending a `Referer`.
+[Kebijakan keamanan konten](http://en.wikipedia.org/wiki/Content_Security_Policy) mungkin akan melarang untuk pengiriman *`Referer`*.
 
-As we'll see, `fetch` has options that prevent sending the `Referer` and even allow to change it (within the same site).
+Seperti yang kita lihat, *`fetch`* memiliki opsi untuk mencegah mengirim `Referer`, dan mengizinkan untuk mengubahnya ( di situs yang sama).
 
-By specification, `Referer` is an optional HTTP-header.
+Dari Spesifikasi, *`Referer`* adalah header HTTP opsional.
 
-Exactly because `Referer` is unreliable, `Origin` was invented. The browser guarantees correct `Origin` for cross-origin requests.
+Tepatnya karena *`Referer`* tidak dapat diandalkan, dibuat lah `Origin`. Browser menjamin *`Origin` *yang benar untuk *request* *cross-origin*.
\ No newline at end of file
diff --git a/5-network/05-fetch-crossorigin/1-do-we-need-origin/task.md b/5-network/05-fetch-crossorigin/1-do-we-need-origin/task.md
index fb8142a3b..c72a5c739 100644
--- a/5-network/05-fetch-crossorigin/1-do-we-need-origin/task.md
+++ b/5-network/05-fetch-crossorigin/1-do-we-need-origin/task.md
@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# Why do we need Origin?
+# Kenapa kita membutuhkan Origin?
 
-As you probably know, there's HTTP-header `Referer`, that usually contains an url of the page which initiated a network request.
+Seperti yang kamu ketahui, Ada pembaca *header* HTTP *`Referer`*, yang biasanya berisi *url* dari halaman yang dimulai dari *request* jaringan.
 
-For instance, when fetching `http://google.com` from `http://javascript.info/some/url`, the headers look like this:
+Misalnya, saat pengambilan `http://google.com` dari `http://javacript.info/some/url`, *header* terlihat seperti ini:
 
 ```
 Accept: */*
@@ -20,9 +20,9 @@ Referer: http://javascript.info/some/url
 */!*
 ```
 
-As you can see, both `Referer` and `Origin` are present.
+Seperti yang kamu lihat, baik *`Referer`* dan *`Origin`* ada.
 
-The questions:
+Pertanyaan:
 
-1. Why `Origin` is needed, if `Referer` has even more information?
-2. Is it possible that there's no `Referer` or `Origin`, or is it incorrect?
+1. Kenapa *`Origin`* dibutuhkan, jika *`Referer`* memiliki lebih banyak informasi?
+2. Apakah mungkin jika *`fetch`* tidak memakai *`Referer`* atau *`Origin`*, atau apakah *`fetch`* itu salah?
diff --git a/5-network/05-fetch-crossorigin/article.md b/5-network/05-fetch-crossorigin/article.md
index 0c1429697..9d58bae7f 100644
--- a/5-network/05-fetch-crossorigin/article.md
+++ b/5-network/05-fetch-crossorigin/article.md
@@ -1,42 +1,43 @@
-# Fetch: Cross-Origin Requests
+# Fetch: *request Cross-Origin*
 
-If we send a `fetch` request to another web-site, it will probably fail.
+Jika kita mengirim *request* *`fetch`* dari situs web lain, itu mungkin akan gagal.
 
-For instance, let's try fetching `http://example.com`:
+Misalnya, mari coba *fetch* dari `http://example.com`:
 
 ```js run async
 try {
   await fetch('http://example.com');
 } catch(err) {
-  alert(err); // Failed to fetch
+  alert(err); // Failed to fetch (Gagal untuk *fetch*)
 }
 ```
 
-Fetch fails, as expected.
+*Fetch* akan gagal, seperti yang diperkirakan.
 
-The core concept here is *origin* -- a domain/port/protocol triplet.
+Konsep dasarnya dari *origin* -- tiga serangkai *domain*/port/protokol.
 
-Cross-origin requests -- those sent to another domain (even a subdomain) or protocol or port -- require special headers from the remote side.
+*request cross-origin* --  yang dikirimkan ke *domain* lain (atau sob*domain*) atau protokol atau *port* -- membutuhkan *header* khusus dari sisi *remote*.
 
-That policy is called "CORS": Cross-Origin Resource Sharing.
+Kebijakan yang disebut *"CORS"*: *Cross-Origin Resource Sharing*.
 
-## Why is CORS needed? A brief history
+## Kenapa *CORS* dibutuhkan? sejarah singkat
 
-CORS exists to protect the internet from evil hackers.
+*CORS* ada untuk melindungi internet dari *hacker* jahat.
 
 Seriously. Let's make a very brief historical digression.
+Serius, Mari kita membuat sejarah yang singkat. 
 
-**For many years a script from one site could not access the content of another site.**
+**Untuk bertahun-tahun skrip dari satu situs tidak bisa mengakses konten dari situs lainnya**
 
-That simple, yet powerful rule was a foundation of the internet security. E.g. an evil script from website `hacker.com` could not access user's mailbox at website `gmail.com`. People felt safe.
+Aturan simpel yang kuat tersebut adalah dasar dari keamanan internet. Contoh skrip jahat dari situs web `hacker.com` tidak bisa mengakses pesan dari pengguna di situs web `gmail.com`. Orang-orang merasa aman.
 
-JavaScript also did not have any special methods to perform network requests at that time. It was a toy language to decorate a web page.
+Javascript juga tidak memiliki metode khusus untuk menampilkan *request* jaringan pada saat itu. Ini adalah bahasa mainan untuk menghias halaman web.
 
-But web developers demanded more power. A variety of tricks were invented to work around the limitation and make requests to other websites.
+Tetapi pengembang web menuntut lebih banyak kuasa. Bebagai trik dibuat untuk mengatasi batasan dan membuat *request* kepada situs web lainnya.
 
-### Using forms
+### Menggunakan Form
 
-One way to communicate with another server was to submit a `<form>` there. People submitted it into `<iframe>`, just to stay on the current page, like this:
+Satu cara untuk berkomunikasi dengan *server* lain adalah dengan mengirimkan `<form>`. Orang-orang mengirimkannya pada `<iframe>`, hanya untuk tetap di halaman saat ini, seperti ini:
 
 ```html
 <!-- form target -->
@@ -44,7 +45,7 @@ One way to communicate with another server was to submit a `<form>` there. Peopl
 <iframe name="iframe"></iframe>
 */!*
 
-<!-- a form could be dynamically generated and submited by JavaScript -->
+<!-- form bisa dihasilkan secara dinamis dan dikirikan oleh Javascript -->
 *!*
 <form target="iframe" method="POST" action="http://another.com/…">
 */!*
@@ -52,91 +53,94 @@ One way to communicate with another server was to submit a `<form>` there. Peopl
 </form>
 ```
 
-So, it was possible to make a GET/POST request to another site, even without networking methods, as forms can send data anywhere. But as it's forbidden to access the content of an `<iframe>` from another site, it wasn't possible to read the response.
+Jadi, ada kemungkinan untuk membuat *request* GET/POST dari situs lain, meski tanpa metode jaringan, karena form bisa mengirimkan data dari mana saja. Tetapi dilarang untuk mengakses konten `<iframe>` dari situs lainnya, tidak ada kemungkinan untuk membaca responnya.
 
-To be precise, there were actually tricks for that, they required special scripts at both the iframe and the page. So the communication with the iframe was technically possible. Right now there's no point to go into details, let these dinosaurs rest in peace.
+Tepatnya, sebenarnya ada trik untuk melakukannya, mereka membutuhkan skrip khusus dari *iframe* dan halaman. Jadi komunikasi dengan *iframe* secara teknis mungkin. Saat ini tidak ada gunanya untuk membahas lebih detail, biarkan dinosaurus ini istirahat dengan tenang.  
 
-### Using scripts
+### Menggunakan Skrip
 
-Another trick was to use a `script` tag. A script could have any `src`, with any domain, like `<script src="http://another.com/…">`. It's possible to execute a script from any website.
+Trik lainnya adalah menggunakan *tag* `script`. Skrip bisa memiliki `src`, dengan **domain** apapun, contoh `<script src="http://another.com/…">`. Ada kemungkinan untuk menjalankan skrip dari situs web apa saja. 
 
-If a website, e.g. `another.com` intended to expose data for this kind of access, then a so-called "JSONP (JSON with padding)" protocol was used.
+Jika sebuah situs web, contoh `another.com` berniat untuk membuka data untuk akses seperti ini, kemudian protokol yang disebut "JSONP (JSON with padding)" akan digunakan.
 
-Here's how it worked.
+Begini cara kerjanya.
 
-Let's say we, at our site, need to get the data from `http://another.com`, such as the weather:
+Mari kita katakan jika, di sisi kita, perlu untuk mengambil data dari `http://another.com`, seperti cuaca:
 
-1. First, in advance, we declare a global function to accept the data, e.g. `gotWeather`.
+1. Pertama, terlebih dahulu, kita mendeklarasikan fungsi global untuk menerima data, contoh `gotWeather`.
 
     ```js
-    // 1. Declare the function to process the weather data
+    // 1. Deklarasikan fungsi untuk memproses data cuaca
     function gotWeather({ temperature, humidity }) {
       alert(`temperature: ${temperature}, humidity: ${humidity}`);
     }
     ```
-2. Then we make a `<script>` tag with `src="http://another.com/weather.json?callback=gotWeather"`, using the name of our function as the `callback` URL-parameter.
+2. Selanjutnya kita membuat *tag* `<script>` dengan `src="http://another.com/weather.json?callback=gotWeather"`, menggunakan nama fungsi sebagai parameter *URL* *`callback`*.
 
     ```js
     let script = document.createElement('script');
     script.src = `http://another.com/weather.json?callback=gotWeather`;
-    document.body.append(script);
+    document.*body*.append(script);
     ```
-3. The remote server `another.com` dynamically generates a script that calls `gotWeather(...)` with the data it wants us to receive.
+3. *server* *remote* `another.com` menghasilkan skrip dinamis yang memanggil `gotWeather(...)` dengan data yang ingin kita terima.
+
     ```js
-    // The expected answer from the server looks like this:
+    // Jawaban dari *server* yang diharapkan seperti ini:
     gotWeather({
       temperature: 25,
       humidity: 78
     });
     ```
 4. When the remote script loads and executes, `gotWeather` runs, and, as it's our function, we have the data.
+4. Jika skrip *remote* memuat dan dijalankan, `gotWeather` dijalankan di fungsi kita, kita memiliki data.
 
-That works, and doesn't violate security, because both sides agreed to pass the data this way. And, when both sides agree, it's definitely not a hack. There are still services that provide such access, as it works even for very old browsers.
+Itu berhasil, dan tidak melanggar keamanan, karena kedua sisi setuju untuk meluluskan data dengan cara ini. Dan jika kedua sisi setuju, ini bukanlah peretasan. Masih ada servis yang menyediakan akses seperti ini, karena cara ini bisa berfungsi bahkan untuk browser lama. 
 
-After a while, networking methods appeared in browser JavaScript.
+Kemudian, metode jaringan muncul di browser Javascript.
 
-At first, cross-origin requests were forbidden. But as a result of long discussions, cross-origin requests were allowed, but with any new capabilities requiring an explicit allowance by the server, expressed in special headers.
+Mulanya, *request cross-orogin* itu dilarang. Tetapi dari hasil diskusi yang panjang, *request cross-origin* diizinkan, tetapi dengan kemampuan baru yang memerlukan izin tegas dari *server*, diekpresikan di *header* khusus.
 
-## Simple requests
+## Request yang simpel
 
-There are two types of cross-origin requests:
+Ada dua tipe dari *request cross-origin*:
 
-1. Simple requests.
-2. All the others.
+1. **request** yang simpel.
+2. lain lainnya.
 
-Simple Requests are, well, simpler to make, so let's start with them.
+*request* yang simpel itu mudah dibuat, jadi mari kita mulai dengan ini.
 
-A [simple request](http://www.w3.org/TR/cors/#terminology) is a request that satisfies two conditions:
+A [*request* yang simpel](http://www.w3.org/TR/cors/#terminology) adalah *request* yang memenuhi dua kondisi:
 
-1. [Simple method](http://www.w3.org/TR/cors/#simple-method): GET, POST or HEAD
-2. [Simple headers](http://www.w3.org/TR/cors/#simple-header) -- the only allowed custom headers are:
+1. [Metode yang simpel](http://www.w3.org/TR/cors/#simple-method): GET, POST atau HEAD.
+2. [*Header* yang simpel](http://www.w3.org/TR/cors/#simple-*header*) -- *header* khusus yang diizinkan adalah:
     - `Accept`,
     - `Accept-Language`,
     - `Content-Language`,
-    - `Content-Type` with the value `application/x-www-form-urlencoded`, `multipart/form-data` or `text/plain`.
+    - `Content-Type` dengan nilai `application/x-www-form-urlencoded`, `multipart/form-data` atau `text/plain`.
+
+*request* lainnya akan dipertimbangkan "tidak simpel". Misalnya, *request* dengan metode `PUT` atau dengan `API-key` *header* HTTP tidak sesuai batasannya.
 
-Any other request is considered "non-simple". For instance, a request with `PUT` method or with an `API-Key` HTTP-header does not fit the limitations.
+**Perbedaan yang mendasar adalah "*request* yang simpel" bisa dibuat menggunakan `<form>` atau `<script>`, tanpa menggunakan metode khusus apa saja.**
 
-**The essential difference is that a "simple request" can be made with a `<form>` or a `<script>`, without any special methods.**
+Jadi, meski *server* sudah lama tetap bisa menerima *request* yang simpel.
 
-So, even a very old server should be ready to accept a simple request.
+Bertentangan dengan itu, *request* dengan *header* tidak standar. contoh metode `DELETE` tidak bisa dibuat seperti ini. Jadi *server* lama mungkin berasumsi bahwa *request* ini berasal dari sumber istimewa, "karena situs web tidak bisa mengirimkan *request*".
 
-Contrary to that, requests with non-standard headers or e.g. method `DELETE` can't be created this way. For a long time JavaScript was unable to do such requests. So an old server may assume that such requests come from a privileged source, "because a webpage is unable to send them".
+Saat kita mencoba untuk membuat *request* tidak simpel, browser mengirimkan *request* khusus *"preflight"* yang menanyakan *server* -- apakah bisa untuk menerima *request cross-origin* atau tidak?
 
-When we try to make a non-simple request, the browser sends a special "preflight" request that asks the server -- does it agree to accept such cross-origin requests, or not?
+Dan, kecuali *server* secara eksplisit mengonfirmasi hal itu dengan *header*, maka *request* tidak simpel tidak akan dikirimkan.
 
-And, unless the server explicitly confirms that with headers, a non-simple request is not sent.
+Sekarang kita akan membahasnya lebih lanjut.
 
-Now we'll go into details.
+## *CORS* untuk *request* yang simpel
 
-## CORS for simple requests
+Jika *request* adalah *request cross-origin*, maka browser akan selalu menambahkan *header* `Origin` di dalam *request*. 
 
-If a request is cross-origin, the browser always adds `Origin` header to it.
 
-For instance, if we request `https://anywhere.com/request` from `https://javascript.info/page`, the headers will be like:
+Misalnya, jika kita *request* `https://anywhere.com/*request*` dari `https://javascript.info/page`, *header* akan seperti ini:
 
 ```http
-GET /request
+GET /*request*
 Host: anywhere.com
 *!*
 Origin: https://javascript.info
@@ -144,17 +148,17 @@ Origin: https://javascript.info
 ...
 ```
 
-As you can see, `Origin` header contains exactly the origin (domain/protocol/port), without a path.
+Seperti yang kamu lihat, *header* `Origin` berisi persis seperti asal (*domain*/protocol/port), tanpa *path*.
 
-The server can inspect the `Origin` and, if it agrees to accept such a request, adds a special header `Access-Control-Allow-Origin` to the response. That header should contain the allowed origin (in our case `https://javascript.info`), or a star `*`. Then the response is successful, otherwise an error.
+*Server* bisa memeriksa `Origin` dan jika setuju untuk menerima **request** tersebut, tambahkan *header* khusus `Access-Control-Allow-Origin` di responnya. *header* tersebut harus berisi asal yang diizinkan (di kasus kita `https://javascript.info`), atau bintang `*` . Maka responnya sukses, atau mungkin saja error.
 
-The browser plays the role of a trusted mediator here:
-1. It ensures that the correct `Origin` is sent with a cross-origin request.
-2. It checks for permitting `Access-Control-Allow-Origin` in the response, if it exists, then JavaScript is allowed to access the response, otherwise it fails with an error.
+Browser memainkan peran sebagai penengah terpercaya disini:
+1. Browser memastikan `Origin` yang benar dikirimkan dengan *request* cross-origin.
+2. Browser memeriksa untuk perizinan di responnya, jika ada maka Javascript akan diizinkan untuk mengakses respon, jika tidak maka akan gagal dengan error.
 
-![](xhr-another-domain.svg)
+![](xhr-another-*domain*.svg)
 
-Here's an example of a permissive server response:
+Disini ada contoh dari respon *server* permisif:
 ```http
 200 OK
 Content-Type:text/html; charset=UTF-8
@@ -163,28 +167,28 @@ Access-Control-Allow-Origin: https://javascript.info
 */!*
 ```
 
-## Response headers
+## *Header* respon
 
-For cross-origin request, by default JavaScript may only access so-called "simple" response headers:
+Untuk **request** cross-origin, secara default Javascript hanya dapat mengakses file yang disebut *header* respon simpel:
 
-- `Cache-Control`
+- `*cache*-Control`
 - `Content-Language`
 - `Content-Type`
 - `Expires`
 - `Last-Modified`
 - `Pragma`
 
-Accessing any other response header causes an error.
+Mengakses *header* respon lainnya akan menghasilkan error.
 
 ```smart
-There's no `Content-Length` header in the list!
+Tidak ada *header* `Content-Length` di daftar!
 
-This header contains the full response length. So, if we're downloading something and would like to track the percentage of progress, then an additional permission is required to access that header (see below).
+*Header* ini berisi panjang respon lengkap. Jadi, jika mengunduh sesuatu dan ingin melacak persentase progres, maka diperlukan izin tambahan untuk mengakses *header* tersebut (lihat di bawah).
 ```
 
-To grant JavaScript access to any other response header, the server must send  `Access-Control-Expose-Headers` header. It contains a comma-separated list of non-simple header names that should be made accessible.
+Untuk memberikan Javascript akses ke *header* respon lainnya, *server* harus mengirimkan *header*  `Access-Control-Expose-*header*s`. Ini berisi daftar yang dipisahkan dengan koma dari nama *header* tidak simpel yang seharusnya dibuat untuk bisa di akses. 
 
-For example:
+Contoh:
 
 ```http
 200 OK
@@ -193,100 +197,99 @@ Content-Length: 12345
 API-Key: 2c9de507f2c54aa1
 Access-Control-Allow-Origin: https://javascript.info
 *!*
-Access-Control-Expose-Headers: Content-Length,API-Key
+Access-Control-Expose-*header*s: Content-Length,API-Key
 */!*
 ```
 
-With such `Access-Control-Expose-Headers` header, the script is allowed to read `Content-Length` and `API-Key` headers of the response.
+Dengan *header* `Access-Control-Expose-headers`, skrip diizinkan untuk membaca *header* `Content-Length` dan `API-Key` dari respon. 
 
-## "Non-simple" requests
+## *Request* tidak simpel
 
-We can use any HTTP-method: not just `GET/POST`, but also `PATCH`, `DELETE` and others.
+Kita bisa menggunakan metode HTTP apa saja: bukan hanya `GET/POST`, tetapi juga `PATCH`, `DELETE` dan lainnya.
 
-Some time ago no one could even imagine that a webpage could make such requests. So there may still exist webservices that treat a non-standard method as a signal: "That's not a browser". They can take it into account when checking access rights.
+Beberapa waktu yang lalu tidak ada orang yang membayangkan bahwa halaman web bisa membuat *request* seperti ini. Jadi masih ada servis web yang memperlakukan metode tidak standar sebagai sinyal: "Itu bukan browser". Mereka dapat memperhitungkannya saat memeriksa hak akses.
 
-So, to avoid misunderstandings, any "non-simple" request -- that couldn't be done in the old times, the browser does not make such requests right away. Before it sends a preliminary, so-called "preflight" request, asking for permission.
+Jadi untuk menghindari kesalah pahaman, *request* tidak simpel -- yang tidak bisa diselesaikan di waktu yang lama, browser tidak akan membuat *request* tersebut secara langsung. Sebelum dikirimkan ke pendahuluan yang disebut *request* "preflight", meminta izin.
 
-A preflight request uses method `OPTIONS`, no body and two headers:
+*Request* preflight menggunakan metode `OPTIONS`, tidak ada *body* dan dua *header*:
 
-- `Access-Control-Request-Method` header has the method of the non-simple request.
-- `Access-Control-Request-Headers` header provides a comma-separated list of its non-simple HTTP-headers.
+- *Header* `Access-Control-request-Method` memiliki metode *request* tidak simpel.
+- *Header* `Access-Control-request-headers` menyediakan daftar yang dipisahkan dengan koma dari *header* HTTP tidak simpel.
 
-If the server agrees to serve the requests, then it should respond with empty body, status 200 and headers:
+Jika *server* setuju untuk melayani *request*, maka akan merespon dengan *body* kosong, status 200 dan *header*:
 
-- `Access-Control-Allow-Origin` must be either `*` or the requesting origin, such as `https://javascript.info`, to allow it.
-- `Access-Control-Allow-Methods` must have the allowed method.
-- `Access-Control-Allow-Headers` must have a list of allowed headers.
-- Additionally, the header `Access-Control-Max-Age` may specify a number of seconds to cache the permissions. So the browser won't have to send a preflight for subsequent requests that satisfy given permissions.
+-`Access-Control-Allow-Origin` harus dari `*` atau dari *request* asal, misalnya `https://javascript.info`, untuk mengizinkannya.
+- `Access-Control-Allow-Methods` harus memiliki metode yang diizinkan.
+- `Access-Control-Allow-*header*s` harus berisi daftar *header* yang diizinkan.
+- Sebagai tambahan, *header* `Access-Control-Max-Age` dapat menentukan jumlah detik untuk menyimpan izin ke *cache*. Jadi browser tidak perlu mengirim preflight untuk  *request* selanjutnya yang memenuhi izin yang diberikan.
 
 ![](xhr-preflight.svg)
 
-Let's see how it works step-by-step on example, for a cross-origin `PATCH` request (this method is often used to update data):
+Mari kita lihat bagaimana cara kerjanya langkah demi langkah di sebuah contoh, untuk *request* cross-origin `PATCH` (metode ini sering digunakan untuk memperbarui data):
 
 ```js
 let response = await fetch('https://site.com/service.json', {
   method: 'PATCH',
-  headers: {
+  *header*s: {
     'Content-Type': 'application/json',
     'API-Key': 'secret'
   }
 });
 ```
 
-There are three reasons why the request is not simple (one is enough):
-- Method `PATCH`
-- `Content-Type` is not one of: `application/x-www-form-urlencoded`, `multipart/form-data`, `text/plain`.
-- "Non-simple" `API-Key` header.
+Ada tiga alasan kenapa *request* bisa menjadi tidak simpel( cukup pilih satu) :
+- Metode `PATCH`.
+- `Content-Type` bukan salah satu dari: *header* `application/x-www-form-*URL*encoded`, `multipart/form-data`, `text/plain`.
+- `API-key` "tidak simpel".
 
-### Step 1 (preflight request)
+### Langkah 1 (*request preflight*)
 
-Prior to sending such request, the browser, on its own, sends a preflight request that looks like this:
+Sebelum mengirim permintaan tersebut, browser, dengan sendirinya akan mengirimkan *request preflight* seperti ini:
 
 ```http
 OPTIONS /service.json
 Host: site.com
 Origin: https://javascript.info
-Access-Control-Request-Method: PATCH
-Access-Control-Request-Headers: Content-Type,API-Key
+Access-Control-*request*-Method: PATCH
+Access-Control-*request*-*header*s: Content-Type,API-Key
 ```
 
-- Method: `OPTIONS`.
-- The path -- exactly the same as the main request: `/service.json`.
-- Cross-origin special headers:
-    - `Origin` -- the source origin.
-    - `Access-Control-Request-Method` -- requested method.
-    - `Access-Control-Request-Headers` -- a comma-separated list of "non-simple" headers.
+- Metode: `OPTIONS`.
+- Path -- Sama persis dengan *request* utama: `/service.json`.
+- *header* khusus *cross-origin*:
+    - `Origin` -- asal sumber.
+    - `Access-Control-*request*-Method` -- metode *request*.
+    - `Access-Control-*request*-*header*s` -- daftar yang dipisahkan dengan koma dari *header* tidak simpel.
 
-### Step 2 (preflight response)
-
-The server should respond with status 200 and headers:
+### Langkah 2 (respon *preflight*)
+*Server* harus merespon dengan status 200 dan *header*:
 - `Access-Control-Allow-Origin: https://javascript.info`
 - `Access-Control-Allow-Methods: PATCH`
-- `Access-Control-Allow-Headers: Content-Type,API-Key`.
+- `Access-Control-Allow-*header*s: Content-Type,API-Key`.
 
-That allows future communication, otherwise an error is triggered.
+Itu memungkinkan komunikasi di masa depan, jika tidak, maka akan di picu error.
 
-If the server expects other methods and headers in the future, it makes sense to allow them in advance by adding to the list.
+Jika *server* mengharapkan metode dan *header* lain di masa depan, akan masuk akal jika mengizinkan terlebih dahulu dengan menambahkannya di daftar.
 
-For example, this response also allows `PUT`, `DELETE` and additional headers:
+Misalnya, respon ini mengizinkan *header* `PUT`, `DELETE` dan tambahan.
 
 ```http
 200 OK
 Access-Control-Allow-Origin: https://javascript.info
 Access-Control-Allow-Methods: PUT,PATCH,DELETE
-Access-Control-Allow-Headers: API-Key,Content-Type,If-Modified-Since,Cache-Control
+Access-Control-Allow-*header*s: API-Key,Content-Type,If-Modified-Since,*cache*-Control
 Access-Control-Max-Age: 86400
 ```
 
-Now the browser can see that `PATCH` is in `Access-Control-Allow-Methods` and `Content-Type,API-Key` are in the list `Access-Control-Allow-Headers`, so it sends out the main request.
+Sekarang browser bisa melihat `PATCH` di dalam `Access-Control-Allow-Methods` dan `Content-Type,API-Key` di dalam daftar `Access-Control-Allow-headers`, sehingga akan mengirimkan permintaan utama.
 
-If there's header `Access-Control-Max-Age` with a number of seconds, then the preflight permissions are cached for the given time. The response above will be cached for 86400 seconds (one day). Within this timeframe, subsequent requests will not cause a preflight. Assuming that they fit the cached allowances, they will be sent directly.
+Jika ada *header* `Access-Control-Max-Age` dengan jumlah detik, maka izin *preflight* akan di simpan dalam *cache* untuk waktu tertentu. Respon diatas akan di simpan di *cache* selama 86400 detik (satu hari). Dengan jangka waktu ini, permintaan selanjutnya tidak akan menyebabkan *preflight*. Dengan asumsi bahwa mereka sesuai dengan *cache* yang diizinkan, mereka akan dikirim langsung.
 
-### Step 3 (actual request)
+### Langkah 3 (*request* sebenarnya)
 
-When the preflight is successful, the browser now makes the main request. The algorithm here is the same as for simple requests.
+Saat *preflight* berhasil, browser akan membuat *request* utama. Algoritmanya sama dengan *request* yang simpel.
 
-The main request has `Origin` header (because it's cross-origin):
+*request* yang utama memiliki *header* `Origin` (karena *request* ini memang *cross-origin*)
 
 ```http
 PATCH /service.json
@@ -296,37 +299,37 @@ API-Key: secret
 Origin: https://javascript.info
 ```
 
-### Step 4 (actual response)
+### Langkah 4 (Respon sebenarnya)
 
-The server should not forget to add `Access-Control-Allow-Origin` to the main response. A successful preflight does not relieve from that:
+*Server* tidak boleh lupa untuk menambahkan `Access-Control-Allow-Origin` pada respon utamanya. *preflight* yang berhasil tidak membebaskan dari itu:
 
 ```http
 Access-Control-Allow-Origin: https://javascript.info
 ```
 
-Then JavaScript is able to read the main server response.
+Maka Javascript bisa membaca respon dari *server* utama. 
 
 ```smart
-Preflight request occurs "behind the scenes", it's invisible to JavaScript.
+*Request preflight* terjadi "dibelakang layar", hal ini tidak terlihat oleh Javascript.
 
-JavaScript only gets the response to the main request or an error if there's no server permission.
+Javascript hanya mendapatkan respon dari *request* utama atau error jika tidak mendapatkan izin dari *server*.
 ```
 
-## Credentials
+## Kredensial
 
-A cross-origin request initiated by JavaScript code by default does not bring any credentials (cookies or HTTP authentication).
+*Request cross-origin* yang dimulai oleh kode Javascript secara default, tidak membawa kredensial apapun ( *cookie* atau autentikasi HTTP).
 
-That's uncommon for HTTP-requests. Usually, a request to `http://site.com` is accompanied by all cookies from that domain. But cross-origin requests made by JavaScript methods are an exception.
+Itu tidak biasa untuk *request* HTTP. Biasanya, *request* pada `htttp://site.com` didampingi oleh semua *cookie* dari *domain* tersebut. Tetapi *request cross-origin* yang dibuat dengan metode Javascript memiliki pengecualian. 
 
-For example, `fetch('http://another.com')` does not send any cookies, even those  (!) that belong to `another.com` domain.
+Contoh, `fetch('http://another.com')` tidak mengirim *cookie* apapun bahkan yang (!) memiliki *domain* `another.com`. 
 
-Why?
+Kenapa?
 
-That's because a request with credentials is much more powerful than without them. If allowed, it grants JavaScript the full power to act on behalf of the user and access sensitive information using their credentials.
+Karena *request* dengan kredensial lebih kuat daripada tanpa kredensial. Jika diizinkan, kredensial bisa memberikan Javascript kekuatan penuh untuk bertindak atas nama pengguna dan mengakses informasi sensitif menggunakan kredensial mereka.
 
-Does the server really trust the script that much? Then it must explicitly allow requests with credentials with an additional header.
+Apakah *server* benar-benar mempercayai skrip itu? maka harus secara eksplisit mengizinkan *request* dengan kredensial dengan *header* tambahan.
 
-To send credentials in `fetch`, we need to add the option `credentials: "include"`, like this:
+Untuk mengirim kredensial di `fetch`, kita perlu menambahkan opsi `credentials: "include"`, seperti ini:
 
 ```js
 fetch('http://another.com', {
@@ -334,11 +337,11 @@ fetch('http://another.com', {
 });
 ```
 
-Now `fetch` sends cookies originating from `another.com` with request to that site.
+Sekarang `fetch` mengirimkan *cookie* yang berasal dari `another.com` dengan *request* dari situs tersebut.
 
-If the server agrees to accept the request *with credentials*, it should add a header `Access-Control-Allow-Credentials: true` to the response, in addition to `Access-Control-Allow-Origin`.
+Jika *server* setuju untuk menerima *request dengan credentials*, harus ditambahkan *header* `Access-Control-Allow-Credentials: true` pada responnya, sebagai tambahan dari `Access-Control-Allow-Origin`.
 
-For example:
+Contoh:
 
 ```http
 200 OK
@@ -346,42 +349,43 @@ Access-Control-Allow-Origin: https://javascript.info
 Access-Control-Allow-Credentials: true
 ```
 
-Please note: `Access-Control-Allow-Origin` is prohibited from using a star `*` for requests with credentials. Like shown above, it must provide the exact origin there. That's an additional safety measure, to ensure that the server really knows who it trusts to make such requests.
+Perlu dicatat: `Access-Control-Allow-Origin` dilarang untuk menggunakan bintang `*` untuk *request* dengan kredensial. Seperti yang ditunjukkan diatas, harus menyediakan asal yang tepat. Itu adalah salah satu ukuran keamanan tambahan, untuk memastikan bahwa *server* benar-benar mengetahui siapa yang dipercayai untuk membuat *request* tersebut.
 
-## Summary
+## Ringkasan
 
-From the browser point of view, there are two kinds of cross-origin requests: "simple" and all the others.
+Dari sudut pandang browser, ada dua jenis *request cross-origin*: simpel dan lain lainnya.
 
-[Simple requests](http://www.w3.org/TR/cors/#terminology) must satisfy the following conditions:
-- Method: GET, POST or HEAD.
-- Headers -- we can set only:
+[*Request* yang simpel](http://www.w3.org/TR/cors/#terminology) harus memenuhi kondisi dibawah:
+- Metode: GET, POST atau HEAD.
+- *header* -- bisa kita atur jika:
     - `Accept`
     - `Accept-Language`
     - `Content-Language`
-    - `Content-Type` to the value `application/x-www-form-urlencoded`, `multipart/form-data` or `text/plain`.
+    - `Content-Type` to the value `application/x-www-form-*URL*encoded`, `multipart/form-data` atau `text/plain`.
+
+Perbedaan mendasar dari *request* simpel bisa dilakukan sejak zaman kuno menggunakan *tag* `<form>` atau `<script>`, sedangkan yang tidak simpel tidak mungkin dijalankan oleh browser untuk waktu yang lama.
 
-The essential difference is that simple requests were doable since ancient times using `<form>` or `<script>` tags, while non-simple were impossible for browsers for a long time.
+Jadi, Perbedaan praktis dari *request* yang simpel di kirimkan segera, dengan *header* `Origin`, sedangkan untuk yang lainnya browser membuat awalan *request "preflight"* , untuk meminta izin.
 
-So, the practical difference is that simple requests are sent right away, with `Origin` header, while for the other ones the browser makes a preliminary "preflight" request, asking for permission.
+**Untuk *request* yang simpel**
 
-**For simple requests:**
+- → Browser mengirimkan *header* `Origin` dengan asalnya.
+- ← Untuk *request* tanpa kredensial (tidak terkirim secara default), *server* harus diatur: 
+    - `Access-Control-Allow-Origin` menjadi `*` atau nilai yang sama dengan `Origin`
+- ← Untuk *request* dengan kredensial, *server* harus diatur:
+    - `Access-Control-Allow-Origin` menjadi nilai yang sama dengan `Origin`
+    - `Access-Control-Allow-Credentials` menjadi `true`
 
-- → The browser sends `Origin` header with the origin.
-- ← For requests without credentials (not sent default), the server should set:
-    - `Access-Control-Allow-Origin` to `*` or same value as `Origin`
-- ← For requests with credentials, the server should set:
-    - `Access-Control-Allow-Origin` to same value as `Origin`
-    - `Access-Control-Allow-Credentials` to `true`
+Sebagai tambahan, untuk memberikan Javascript akses kepada *header* respon apapun kecuali `*cache*-Control`,  `Content-Language`, `Content-Type`, `Expires`, `Last-Modified` or `Pragma`, *server* harus mendaftarkan *header* yang diizinkan di *header* `Access-Control-Expose-headers`.
 
-Additionally, to grant JavaScript access to any response headers except `Cache-Control`,  `Content-Language`, `Content-Type`, `Expires`, `Last-Modified` or `Pragma`, the server should list the allowed ones in `Access-Control-Expose-Headers` header.
+**Untuk *request* tidak simpel, awalan *request "preflight"* diberikan sebelum *request* yang diminta:**
 
-**For non-simple requests, a preliminary "preflight" request is issued before the requested one:**
+- → Browser mengirimkan *request* `OPTIONS` di *URL* yang sama, dengan *header*:
+    - `Access-Control-request-Method` memiliki metode *request*.
+    - `Access-Control-request-headers` mendaftarkan *header request* yang tidak simpel.
+- ← *Server* harus merespon dengan status 200 dan *header*:
+    - `Access-Control-Allow-Methods` dengan daftar metode yang diizinkan,
+     - `Access-Control-Allow-headers` dengan daftar *header* yang diizinkan,
+     - `Access-Control-Max-Age` dengan jumlah detik untuk izin menyimpan di *cache*.
 
-- → The browser sends `OPTIONS` request to the same URL, with headers:
-    - `Access-Control-Request-Method` has requested method.
-    - `Access-Control-Request-Headers` lists non-simple requested headers.
-- ← The server should respond with status 200 and headers:
-    - `Access-Control-Allow-Methods` with a list of allowed methods,
-    - `Access-Control-Allow-Headers` with a list of allowed headers,
-    - `Access-Control-Max-Age` with a number of seconds to cache permissions.
-- Then the actual request is sent, the previous "simple" scheme is applied.
+- Lalu *request* yang sebenarnya di kirimkan, skema yang "simpel" sebelumnya akan diterapkan.