How to fix: Unexpected token u in JSON at position 0 Error in JS

2 Solutions for Unexpected token “u” in JSON at position 0

JavaScript takes web development to a new level, providing users with dynamic and interactive experiences. As one of the three core technologies of the World Wide Web, along with HTML and CSS, JavaScript allows developers to add animation, respond immediately when users make changes or take actions on their websites, and update content without reloading pages.

The [Unexpected token u in JSON at position 0] error message happens when you see an undefined value to $.parseJSON or JSON.parse functions. To fix the problem, check the value you’re attempting to convert and ensure that the JSON is valid before converting it.

This error message explicitly mentions the “u” token and the position 0, which means that the first character in the string being parsed is the letter “u”. In most cases, this letter is the first character of the word “undefined”. When attempting to parse this as JSON, it will result in the error message because “undefined” is not a valid value in JSON.

What does “undefined” mean in Javascript?

In JavaScript, “undefined” is a special value that indicates that a variable has been declared but has not been assigned a value. When you declare a variable in JavaScript, the value “undefined” is automatically assigned until you assign it a different value.

For example:

let foo;
console.log(foo); // logs "undefined"

In this code, we declared the variable but did not assign it a value. When we log the value foo to the console, it outputs “undefined”.

It’s important to note that the value “undefined” is not the same as null, which is another special value in JavaScript that represents the intentional absence of a value. null is a value that is explicitly assigned to a variable, while “undefined” is the default value assigned to a variable that has not been assigned a value.

It’s also worth mentioning that accessing an undefined property of an object will also result in the value “undefined“. For example:

let obj = {};
console.log(obj.someProp); // logs "undefined"

In this code, we declared an object obj with no properties. When we access the property someProp of obj, it returns “undefined” because that property does not exist.

Error on Developer Tools

Let’s one example of how to reproduce the error, so you can understand how to fix it:

Uncaught SyntaxError: Unexpected                  
token u in JSON at position 0
      at JSON. parse (<anonymous>)
      at index.js:62


Unexpected token u in JSON at position 0

Debugging is essential to the software development process, and diagnosing and fixing issues in your JavaScript code is often necessary. Google Chrome provides a powerful debugging tool called the DevTools, which allows you to inspect and debug JavaScript code running in the browser.

Here’s how you can use the DevTools to debug JavaScript in Google Chrome:

Open the DevTools: You can do this by right-clicking on any element on the page and selecting “Inspect” or by pressing Ctrl + Shift + I (or Cmd + Shift + I on macOS).

Navigate to the “Sources” tab: This is where you can inspect and debug the JavaScript code for the page.

Set a breakpoint: You can set a breakpoint by clicking to the left of the line number in the JavaScript code. The code will stop executing at the breakpoint, allowing you to inspect the state of the page and variables.

Step through the code: You can use the buttons at the top of the DevTools to complete the code one line at a time. This allows you to see how the code is being executed and inspect variables’ values.

Watch variables: You can add variables to the “Watch” panel to monitor their values as the code is executed.

Debug console: You can also use the DevTools console to execute JavaScript code and inspect the results. This is useful for testing and troubleshooting code snippets.

Using these features of the DevTools, you can quickly and effectively diagnose and fix issues in your JavaScript code. The DevTools provide a wealth of information and tools to help you debug your code, so it’s definitely worth taking the time to learn how to use them effectively.

To demonstrate how to resolve the error, let’s take a look at one example of it in action:

Here’s an example of how the error occurs.

SyntaxError: Unexpected token u in JSON at position 0

When you pass an undefined to the JSON.parse function, the value will be converted to a String.

The sole element in the “u” string contains a variable and is mainly used to store an error message.

Inside the “u”, we have the error message: “Unexpected token u in JSON at position 0″.

Root Cause

Unexpected token u in JSON at position 0
Unexpected token u in JSON at position 0

But what “Unexpected token u in JSON at position 0″ means? And why this error happened?

Let’s summarize three reasons why the function JSON.parse failed:

Initially, attempting to access an attribute of a nonexistent object might be referenced. Then, nothing can be retrieved from your local storage or server when you try to extract the information. In addition to that, if you retrieve data too soon before page loading has completed, there is the risk of race conditions occurring.

What is the most effective solution? Utilizing JSON and adding in a try-and-catch statement for good measure! This practice is highly recommended for maximum efficiency and optimal results.

What does the Try do?

try {
  const obj = JSON.parse(undefined); # Try to convert and assign
} catch (e) {
  // The line below run only if an error happened.
  console.log('Message: ', e.message);

The code above calls the JSON.parse from inside the try. So, attempt to convert the value and put the value inside the variable obj. But, in case of the value is invalid (an invalid JSON), the function (JSON.parse) will raise a new exception so that the catch block will handle the error.

One thing is worth highlighting. All JSON values are strings, but remember that JSON has your unique “roles” and syntax, so it means that the string should contain those roles to be valid.

Also, before pulling data from your backend, ensure that the response is valid. You can take advantage of the console.log to print out the response and check if the JSON is valid.

Content Type

Also, always check on Developer Tools from Google Chrome, for example, if your request to the server contains the application/json in the header “Content-Type”.

The Content-Type header in an HTTP request or response specifies the format of the payload or the data being sent. When the Content-Type header is set to application/json, it means that the payload of the request or response is in JSON format.

By setting the Content-Type header to application/json, the recipient of the request or response can know that the payload is in JSON format and can parse it accordingly. This helps ensure that the recipient interprets the data correctly and enables them to process the payload accordingly.

Tip: You can easily find a website where you can copy and paste your JSON and check if it’s valid. It’s useful for a big string where you can’t catch minor issues.

Also, try to clean all browser data and try again if possible. I like to use the Guest mode or Incognito from Google Chrome to ensure it is not a cache issue.

Local Storage

Local storage is a method of storing data locally on a user’s computer instead of using server-side technology. It was first introduced in HTML5 and worked as an alternative to cookies, allowing websites to store more information than was previously permitted. The data is stored in key/value pairs and accessed via JavaScript code. Local storage differs from session storage, as it is persistent and will remain even after the browser window is closed.

The data stored in localStorage is not visible or accessible to other tabs open in the same browser window unless the website explicitly gives permission for it. It can be used to store user preferences, authentication tokens, and other information necessary to enable certain features on a website. Local storage is also secure, as any other website cannot access the data stored in it. This makes it ideal for storing sensitive information such as passwords and credit card numbers. Additionally, local storage can be used to store large amounts of data without compromising the user’s privacy.


For example, to clean all local storage, you can execute the following method below:


Find more examples here.

After cleaning the Local Storage, it’s essential to make sure that you write the value again to the Local Storage. If the value is not JSON, you can convert it using JSON.stringify.

// Let's store a JSON value in local storage 
localStorage.setItem('site', JSON.stringify({blog: 'BitsLovers'}));

// Now let's try to parse it
const obj = JSON.parse(localStorage.getItem('site'));

Also, there is one specific scenario where you may read data from a file without waiting enough time to load the page fully.

In complex scenarios where you must wait for the page to load, you can take advantage of the window.onload function. Alternatively, you can use the $(document).ready(), which uses Jquery.

Let’s see how you can easily do it.

// using onload
window.onload = function getUser() {
    .then(response => {
      if (!response.ok) 
        throw new Error(`Error message: ${response.status}`);
      return response.json();
    .then(result => {console.log(result);})
    .catch(err => console.log(err));

// using ready from jQuery
$(document).ready(function () {
  $.getJSON('', function (resp) {

The code first creates a function called getUser that is executed when the webpage is loaded. It uses the fetch API and then method to get a response from the specified URL. If there is an error, it logs an error message with the response status code. Then it uses the .then method to parse the JSON and log the result to the console.

The second part uses jQuery’s $(document).ready to call a callback function on the same URL, but this time via $.getJSON which fetches the JSON response. Then in the callback function, it logs the response to the console.


Unexpected token u in JSON at position 0

By following these tips, you can ensure that your data is properly loaded and interpreted. Additionally, always check the content type of requests and responses from the server and ensure the response is a valid string. Cleaning up browser data and using Local Storage or onload function can help troubleshoot complex scenarios.

Ultimately, understanding the importance of the Content-Type header and having a good grasp on tools such as JSON.stringify can help you handle data in your application effectively. Doing this ensures that all data is appropriately processed and interpreted from server to client.

Furthermore, using local storage and window.onload provide easy solutions for complex scenarios. With these tips and tools, you can ensure that your application functions properly and securely.

Thank You for reading. 🙂 Happy Coding!!

Extra tip: Use Maven to compile your Java and Javascript projects.

Leave a Comment

Your email address will not be published. Required fields are marked *

Free PDF with a useful Mind Map that illustrates everything you should know about AWS VPC in a single view.