What Is Fetch API in JavaScript? How to Use It (with Examples)

Danielle Ellis
Danielle Ellis



Have you ever wished your computer could do the heavy lifting for you? Like downloading a whole website's worth of data so you can work on it offline. Sure, your web browser comes with its download feature, but that only grabs one page at a time - leaving out any hyperlinks pointing to other pages within the site itself. That means restarting the entire process all over again and again. Wouldn't it be great if there was an easier way?

Developer learning how to use fetch api

Download Now: An Introduction to JavaScript  [Free Guide]

Luckily, there's an easier way. With the Fetch API in JavaScript, you can tell your computer to get whatever website or file you need and bring it back to you. In this article, we'll show you how to use the Fetch API in several ways. We'll also give some examples of when it might come in handy.

Let's get started!

What is the JavaScript Fetch API?

The Fetch API is a feature that allows you to make HTTP requests (such as GET, POST, PUT, or DELETE) to a web server. It's built into modern browsers, so you don't need additional libraries or packages to use it.

Simply put, the Fetch API makes it easy to get information from a website and do something with that data in your browser (or whatever environment you're using). For example, you can use the Fetch API to request an HTML document from a website and then parse it to get certain elements out.

The Fetch API is incredibly straightforward and offers an unmatched level of flexibility through the use of JavaScript Promises for making requests from web browsers. A single global fetch() method can be used to direct your browser to send out any desired request for a specified URL.

(Note: Promises are objects that represent the eventual completion (or failure) of an asynchronous operation and its resulting value. In the case of Fetch API, it returns a Promise that resolves the response of the request.)

The Fetch API is a game-changer for developers, giving them unparalleled flexibility through the use of JavaScript Promises. It also simplifies web browser requests with its global fetch() method - allowing you to easily and quickly make URL requests from your browser. Whether you're new to coding or have been doing it for years, this powerful tool can help streamline your workflow in no time.

History of Fetch API and AJAX

The Fetch API is a relatively new web browser feature but builds on older technologies such as AJAX.

AJAX stands for Asynchronous JavaScript and XML. It was the first widely adopted technology to allow websites to send requests without needing to reload the entire page. Before AJAX, if you wanted to update something on your web page, you would need to reload the entire page - which was clunky and inefficient.

AJAX allowed developers to make HTTP requests without needing a full-page refresh. This technology revolutionized web development, but it had its limitations. AJAX requests were limited to retrieving data from the same origin (domain/subdomain) as the page requested.

Enter the Fetch API. Brought about by newer web browsers, this technology had all of the power of AJAX but with no cross-origin security issues and added support for more HTTP methods like PUT and DELETE.

How to use Fetch API in JavaScript?

Now that you know about the Fetch API let's look at how to use it.

Fetch API Syntax

Using the Fetch API is relatively straightforward. All you need is the URL of the resource you want to fetch, plus some code that tells your browser what to do with the response from the server.

The syntax of the Fetch API is as follows:

fetch(url) .then(response => { // Do something with the response here });

It's a two-step process. First, you send a request to the desired URL using the fetch() method. Next, you handle the response with the .then() method. In this case, we're not doing anything with the code yet, but you could use this same code to parse HTML documents, send data over POST requests, and more.

Let's walk through an example to make this clearer.

Sending a Request

The simplest way to make a request is with the global fetch() method. This method takes two parameters - the URL of the resource you want to retrieve and an optional configuration object.

For example, if you wanted to get an HTML document from a website, you could use the following code:

fetch('www.example.com/document.html') .then(response => response.text()) // Read the response as text .then(html => alert(html)); // Alert the retrieved HTML content

This code will send a GET request to the URL specified and then alert the response (in this case, an HTML document). It's important to note that if the request fails, the .then() method will return an error. It is your job as a developer to handle these errors gracefully.

Let's look at a more complex example.

Making POST Requests

You can also use the Fetch API to make POST requests. This is useful if you need to send data to a web server, such as when submitting forms or uploading files.

To make a POST request, you need to add the configuration object to the fetch() method. This object should include the HTTP method (in this case, POST) and any data you want to send in the body of the request.

For example, if you wanted to submit an HTML form with two fields - name and email - your code might look like this:

fetch('www.example.com/submit-form', { method: 'POST', // Specify the HTTP method body: new FormData(document.querySelector('form')) // Collect form data }) .then(response => response.text()) // Read response as text .then(data => alert(data)) // Alert the response

This code will collect data from an HTML form and submit it via a POST request. Again, if the request fails, you'll want to use some error-handling logic to handle the situation gracefully.

The Fetch API is incredibly powerful and can do much more than these two examples. With enough creativity and knowledge of HTTP methods, you can use this technology to build highly dynamic web applications.

Error Handling

No matter what you're trying to accomplish with the Fetch API, it's essential to have a good error-handling strategy. This is especially true for POST requests, which often require sensitive data.

The simplest way to handle errors is with a try/catch block. You can wrap your code in this block and then use the catch() method to alert an error if something goes wrong.

For example, if you were making a POST request, your code could look like this:

try { fetch('www.example.com/submit-form', { method: 'POST', // Specify the HTTP method body: new FormData(document.querySelector('form')) // Collect form data }) .then(response => response.text()) // Read response as text .then(data => alert(data)) // Alert the response } catch (error) { alert('An error occurred!'); }

This code will alert an error if anything goes wrong. It's a simple but effective way to handle errors gracefully.

Final Thoughts of JavaScript Fetch API 

As you can see, the Fetch API in JavaScript can be a potent tool for automating web requests. With just a few lines of code, you can make HTTP requests and process responses without needing extra libraries or packages.

Also, with the JavaScript global fetch() method, you can easily retrieve data from any URL without cross-origin security issues or complicated AJAX requests. Plus, with its support for Promises, you can ensure your code runs as efficiently as possible without unnecessary waiting times. Get started today and see how much simpler web browser work can be.

New Call-to-action

Topics: Javascript

Related Articles

We're committed to your privacy. HubSpot uses the information you provide to us to contact you about our relevant content, products, and services. You may unsubscribe from these communications at any time. For more information, check out our Privacy Policy.

Learn more about one of the world's most popular programming languages.