Jsondecodeerror python ошибка

JSONDecodeError: Expecting value: line 1 column 1 (char 0) occurs while working with JSON (JavaScript Object Notation) format. You might be storing some data or trying to fetch JSON data from an API(Application Programming Interface). In this guide, we will discuss where it can creep in and how to resolve it.

JSONDecodeError means there is an incorrect JSON format being followed. For instance, the JSON data may be missing a curly bracket, have a key that does not have a value, and data not enclosed within double-quotes or some other syntactic error.

Generally, the error expecting value: line 1 column 1 (char 0) error can occur due to the following reasons.

• Non-JSON conforming quoting
• Empty JSON file
• XML output (that is, a string starting with <)

Let’s elaborate on the points stated above:

1. Non-JSON conforming quoting

JSON or JavaScript Object Notation has a similar format to that of the python dictionary datatype. A dictionary requires a key or value to be enclosed in quotes if it is a string. Similarly, the JSON standard defines that keys need not be a string. However, keys should always be enclosed within double quotes. Not following this standard can also raise an error.

2. Empty JSON file

For this example, we have taken an empty JSON file named test.py and another file named test.py, which contains the code given below. Using context manager, we open the JSON file in reading mode and load it using the load method. However, an error is thrown because the JSON file is empty.

import json

with open("test.json", "r") as file:
    data = json.load(file)

print("Data retrieved")

3. XML output (that is, a string starting with <)

The Extensible Markup Language, or simply XML, is a simple text-based format for representing structured information: documents, data, configuration, books, transactions, invoices, and much more. Similar to JSON, it is an older way of storing data. Earlier APIs used to return data in XML format; however, JSON is nowadays the preferred choice. Let’s see how we can face the expecting value: line 1 column 1 (char 0) type error in this case.

<part number="1976">
  <name>Windscreen Wiper</name>
  <description>The Windscreen wiper
    automatically removes rain
    from your windscreen, if it
    should happen to splash there.
    It has a rubber <ref part="1977">blade</ref>
    which can be ordered separately
    if you need to replace it.
  </description>
</part>

import json
with open("test.xml", "r") as file:
    data = json.load(file)
print("Data retrieved")

Let’s break down what is happening here.

• For ease of example, suppose API returns an XML format data, as shown above.
• Now, when we try to load that response from API, we will get a type error.

Resolving JSONDecodeError: Expecting value: line 1 column 1 (char 0)

1. Solution for Non-JSON conforming quoting

To resolve the type error in this case, you need to ensure that the keys and values are enclosed within the double quotes. This is necessary because it is a part of JSON syntax. It is important to realize that JSON only uses double quotes, not single quotes.

2. Solution for empty JSON file

The solution for this is self-evident in the name. To resolve the type error, in this case, make sure that the JSON file or the response from an API is not empty. If the file is empty, add content to it, and for a response from an API, use try-except to handle the error, which can be empty JSON or a 404 error, for instance.

import json
import requests


def main():
    URL = "https://api.dictionaryapi.dev/api/v2/enties/en/"
    word = input("Enter a word:")
    data = requests.get(url + word)
    data = data.text
    try:
        data_json = json.loads(data)
        print(data_json)
    except json.JSONDecodeError:
        print("Empty response")


if __name__ == "__main__":
    main()

The above code takes in a word and returns all the information related to it in a JSON format. Now in order to show how we can handle the Expecting value: line 1 column 1 (char 0) type error, we have altered the URL. entries have been changed to enties. Therefore we will get an invalid response which will not be of the JSON format. However, this is merely done to imitate the error when you might get an invalid response from an API.

• Now, if you try to run the code above, you will be prompted to enter a word. The response is saved into the data variable and later converted to a string.
• However, in the try block json.loads method, which parses JSON string to python dictionary raises an error.
• This is because the response sent by API is not of JSON format, hence can’t be parsed, resulting in JSONDecodeError.
• JSONDecodeError gets handled by the try-except block, and a “Response content is not valid JSON” gets printed as an outcome.

3. Solution for XML output(that is, a string starting with <)

To avoid type errors resulting from an XML format, we will convert it to a JSON format. However, firstly install this library.

pip install xmltodict

import json
import xmltodict

with open("test.xml", "r") as file:
    data = xmltodict.parse(file.read())
    file.close()

    json_data = json.dumps(data)
    with open("t.json", "w") as json_file:
        json_file.write(json_data)
        json_file.close()
print("Data retrieved")
print(data)

Let’s elaborate on the code above:

• We have imported two libraries, namely JSON and xmltodict.
• Using the context manager with, XML file test.xml is opened in read mode. Thereafter using the xmltodict parse method, it is converted to a dictionary type, and the file is closed.
• json.dumps() takes in a JSON object and returns a string of that object.
• Again using context manager with, a JSON file is created, XML data that was converted to a JSON string is written on it, and the file is closed.

JSONDecodeError: Expecting value: line 1 column 1 (char 0) Django

This issue is caused by the failure of Pipenv 2018.10.9. To resolve this issue, use Pipenv 2018.5.18. For more, read here.

Are you facing this error in Flask?

Many times, when you receive the data from HTTP requests, they are fetched as bytes. So, if you face JSONDecodeError, you might be dealing with a JSON in bytes. First, you need to decode the JSON by using response.decode('utf-8'). This will create a string, and then you can parse it.

FAQs

Conclusion JSONDecodeError: Expecting value: line 1 column 1 (char 0)

The following article discussed the JSONDecodeError: Expecting value: line 1 column 1 (char 0). This error is due to various decoding and formatting errors. We looked at likely situations where it can occur and how to resolve it.

If you try to parse invalid JSON or decode an empty string as JSON, you will encounter the JSONDecodeError: Expecting value: line 1 column 1 (char 0). This error can occur if you read an empty file using json.load, read an empty JSON or receive an empty response from an API call.

You can use a try-except code block to catch the error and then check the contents of the JSON string or file before retrying.

This tutorial will go through the error in detail and how to solve it with code examples.

JSONDecodeError: Expecting value: line 1 column 1 (char 0)

In Python, JSONDecodeError occurs when there is an issue with the formatting of the JSON data. This specific error tells us the JSON decoder has encountered an empty JSON.

Example #1: Incorrect use of json.loads()

Let’s look at an example where we have a JSON file with the following contents:

[
        {"margherita":7.99},
        {"pepperoni":9.99},
        {"four cheeses":10.99}
]

We want to read the data into a program using the json library. Let’s look at the code:

import json

json_path = 'pizza.json'

data = json.loads(json_path)

In the above code, we try to read the data in using json.loads(). Let’s run the code to see the result:

JSONDecodeError: Expecting value: line 1 column 1 (char 0)

The error occurs because json.loads() expects a JSON encoded string, not a filename. The string pizza.json is not a valid JSON encoded string.

Solution

We need to use json.load() instead of json.loads() to read a file. Let’s look at the revised code:

import json

json_path = 'pizza.json'

with open(json_path, 'r') as f:

    data = json.loads(f.read())

print(data)

In the above code, we use the open() function to create a file object that json.load() can read and return the decoded data object. The with statement is a context manager that ensures that the file is closed once the code is complete. Let’s run the code to see the result:

[{'margherita': 7.99}, {'pepperoni': 9.99}, {'four cheeses': 10.99}]

Example #2: Empty JSON file

Let’s look at an example where we have an empty file, which we will try to read in using json.loads(). The file is called particles.json. Since the JSON file is empty, the JSON decoder will throw the JSONDecodeError when it tries to read the file’s contents. Let’s look at the code:

import json

filename = 'particles.json'

with open(filename, 'r') as f:
    contents = json.loads(f.read())
    print(contents)

---------------------------------------------------------------------------
JSONDecodeError                           Traceback (most recent call last)
Input In [1], in <cell line: 5>()
      3 filename = 'particles.json'
      5 with open(filename, 'r') as f:
----> 6     contents = json.loads(f.read())
      7     print(contents)

File ~/opt/anaconda3/lib/python3.8/json/__init__.py:357, in loads(s, cls, object_hook, parse_float, parse_int, parse_constant, object_pairs_hook, **kw)
    352     del kw['encoding']
    354 if (cls is None and object_hook is None and
    355         parse_int is None and parse_float is None and
    356         parse_constant is None and object_pairs_hook is None and not kw):
--> 357     return _default_decoder.decode(s)
    358 if cls is None:
    359     cls = JSONDecoder

File ~/opt/anaconda3/lib/python3.8/json/decoder.py:337, in JSONDecoder.decode(self, s, _w)
    332 def decode(self, s, _w=WHITESPACE.match):
    333     """Return the Python representation of ``s`` (a ``str`` instance
    334     containing a JSON document).
    335 
    336     """
--> 337     obj, end = self.raw_decode(s, idx=_w(s, 0).end())
    338     end = _w(s, end).end()
    339     if end != len(s):

File ~/opt/anaconda3/lib/python3.8/json/decoder.py:355, in JSONDecoder.raw_decode(self, s, idx)
    353     obj, end = self.scan_once(s, idx)
    354 except StopIteration as err:
--> 355     raise JSONDecodeError("Expecting value", s, err.value) from None
    356 return obj, end

JSONDecodeError: Expecting value: line 1 column 1 (char 0)

Solution

If the file is empty, it is good practice to add a try-except statement to catch the JSONDecodeError. Let’s look at the code:

import json

filename = 'particles.json'

with open(filename, 'r') as f:

   try:

       contents = json.loads(f.read())

       print(contents)

   except json.decoder.JSONDecodeError:

       print('File is empty')

File is empty

Now we have verified the file is empty, we can add some content to the file. We will add three particle names together with their masses.

[
        {"proton":938.3},
        {"neutron":939.6},
        {"electron":0.51}
]

Let’s try to read the JSON file into our program and print the contents to the console:

import json

filename = 'particles.json'

with open(filename, 'r') as f:

   try:

       contents = json.loads(f.read())

       print(contents)

   except json.decoder.JSONDecodeError:

       print('File is empty')

[{'proton': 938.3}, {'neutron': 939.6}, {'electron': 0.51}]

We successfully read the contents of the file into a list object.

Example #3: Response Request

Let’s look at an example where we want to parse a JSON response using the requests library. We will send a RESTful GET call to a server, and in return, we get a response in JSON format. The requests library has a built-in JSON decoder, response.json(), which provides the payload data in the JSON serialized format.

We may encounter a response that has an error status code or is not content-type application/json. We must check that the response status code is 200 (OK) before performing the JSON parse. Let’s look at the code to check the response has the 200 status code and has the valid content type. application/json.

import requests

from requests.exceptions import HTTPError

url = 'https://httpbin.org/get'

try:

    response = requests.get(url)

    status = response.status_code

    if (status != 204 and response.headers["content-type"].strip().startswith("application/json")):

        try:

            json_response = response.json()

            print(json_response)

        except ValueError:
            
            print('Bad Data from Server. Response content is not valid JSON')

    elif (status != 204):

        try:

            print(response.text)

        except ValueError:

            print('Bad Data From Server. Reponse content is not valid text')

except HTTPError as http_err:

    print(f'HTTP error occurred: {http_err}')

except Exception as err:

    print(f'Other error occurred: {err}')

In the above example, we use httpbin.org to execute a GET call. Let’s run the code to get the result:

{'args': {}, 'headers': {'Accept': '*/*', 'Accept-Encoding': 'gzip, deflate, br', 'Host': 'httpbin.org', 'User-Agent': 'python-requests/2.27.1', 'X-Amzn-Trace-Id': 'Root=1-6265a5c1-3b57327c02057a3a39ffe86d'}, 'origin': '90.206.95.191', 'url': 'https://httpbin.org/get'}

Summary

Congratulations on reading to the end of this tutorial! The JSONDecodeError: Expecting value: line 1 column 1 (char 0) occurs either when data is not present in a file, the JSON string is empty, or the payload from a RESTful call is empty.

You can resolve this error by checking the JSON file or string for valid content and using an if-statement when making a RESTful call to ensure the status code is 200 and the content type is application/json.

For further reading on errors involving JSON, go to the articles:

• How to Solve Python ValueError: Trailing data
• How to Solve Python JSONDecodeError: extra data
• How to Solve Python TypeError: Object of type datetime is not JSON serializable
• How to Solve Python JSONDecodeError: Expecting ‘,’ delimiter: line 1

Have fun and happy researching!

Many developers store data from a program in a JSON file; other programs reference APIs which require working with JSON. Indeed, you will have no trouble finding a use case for JSON, or its Python equivalent, dictionaries.

You may encounter a JSONDecodeError when you are working with JSON data. In this guide, we’re going to talk about the causes of a JSONDecodeError and how to fix this error.

Python JSONDecodeError

A Python JSONDecodeError indicates there is an issue with the way in which your JSON data is formatted. For example, your JSON data may be missing a curly bracket, or have a key that does not have a value, or be missing some other piece of syntax.

To completely fix a JSONDecodeError, you need to go into a JSON file to see what the problem is. If you anticipate multiple problems coming up in the future, you may want to use a try…except block to handle your JSONDecodeError.

Followed by the JSONDecodeError keyword, you should see a short description which describes the cause of the error.

All properly-formatted JSON should look like this:

“value” can be any valid JSON value, such as a list, a string, or another JSON object.

An Example Scenario

We are building a program that stores a list of JSON objects which represent which computers have been issued to employees at a business. Each JSON object should look like this:

[
	{
		"name": "Employee Name",
		"equip_id": "000"
	}
]

We store these JSON objects in a file called equipment.json. The file only contains one entry:

[
	{
		"name": "Laura Harper",
		"equip_id" "309"
	}
]

To read this data into our program, we can use the json module:

import json

with open("equipment.json") as file:
	data = json.load(file)

print("Equipment data has been successfully retrieved.")

First, we import the json module which we use to read a JSON file. Then, we use an open() statement to read the contents of our JSON file. We print out a message to the console that tells us the equipment data has been retrieved once our with statement has run.

Let’s run our code and see what happens:

Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
  File "/usr/lib/python3.8/json/__init__.py", line 293, in load
	return loads(fp.read(),
  File "/usr/lib/python3.8/json/__init__.py", line 357, in loads
	return _default_decoder.decode(s)
  File "/usr/lib/python3.8/json/decoder.py", line 337, in decode
	obj, end = self.raw_decode(s, idx=_w(s, 0).end())
  File "/usr/lib/python3.8/json/decoder.py", line 353, in raw_decode
	obj, end = self.scan_once(s, idx)
json.decoder.JSONDecodeError: Expecting ':' delimiter: line 4 column 16 (char 47

Our code returns a long error. We can see Python describes the cause of our error after the term JSONDecodeError.

The Solution

Our JSONDecodeError is telling us we are missing a colon (:) in our JSON data. This colon should appear on line four at column 16. If we look at this line of data in our equipment.json file, we can see our JSON is invalid:

Our code is missing a colon. To fix this error, we should add a colon:

Now that we have fixed the problem with the way in which our data is represented, we can try to run our program again:

Equipment data has been successfully retrieved.

Our code executes successfully.

Alternatively, we could use a try…except handler to handle this issue so that our code will not immediately return an error if we face another formatting issue:

import json

try:
	with open("equipment.json") as file:
		data = json.load(file)

	print("Equipment data has been successfully retrieved.")
except json.decoder.JSONDecodeError:
	print("There was a problem accessing the equipment data.")

If there is an error in our JSON data, this program will return:

There was a problem accessing the equipment data.

Otherwise, the program will read the data and then display the following text on the console:

Equipment data has been successfully retrieved.

Conclusion

The Python JSONDecodeError indicates there is an issue with how a JSON object is formatted. To fix this error, you should read the error message and use it to guide you in fixing your JSON data. Alternatively, you can use a try…except block to catch and handle the error.

Are you interested in learning more about Python coding? Read our How to Learn Python guide. You’ll find expert advice on how to learn Python and a list of learning resources to help you build your knowledge.

When working with URLs and APIs in Pythons, you often have to use the urllib and json libraries. More importantly, the json library helps with processing JSON data which is the default way to transfer data, especially with APIs.

Within the json library, there is a method, loads(), that returns the JSONDecodeError error. In this article, we will discuss how to resolve such errors and deal with them appropriately.

Use try to Solve raise JSONDecodeError("Expecting value", s, err.value) from None in Python

Before dealing with JSON, we often had to receive data via the urllib package. However, when working with the urllib package, it is important to understand how to import such a package into your code as it could result in errors.

For us to make use of the urllib package, we have to import it. Often, people might import it as below.

import urllib
queryString = { 'name' : 'Jhon', 'age' : '18'}
urllib.parse.urlencode(queryString)

The output of the code above will give an AttributeError:

Traceback (most recent call last):
  File "c:UsersakinlDocumentsHTMLpythontest.py", line 3, in <module>
    urllib.parse.urlencode(queryString)
AttributeError: module 'urllib' has no attribute 'parse'

The correct way to import the urllib can be seen below.

import urllib.parse
queryString = {'name': 'Jhon', 'age': '18'}
urllib.parse.urlencode(queryString)

Alternatively, you can use the as keyword and your alias (often shorter) to make it easier to write your Python code.

import urllib.parse as urlp
queryString = {'name': 'Jhon', 'age': '18'}
urlp.urlencode(queryString)

All of the above works for request, error, and robotparser:

import urllib.request
import urllib.error
import urllib.robotparser

With these common errors out of the way, we can deal further with the function that often works with the urllib library when working with URLs that throws the JSONDecodeError error, as seen earlier, which is the json.load() function.

raise JSONDecodeError("Expecting value", s, err.value) from None
json.decoder.JSONDecodeError: Expecting value: line 1 column 1 (char 0)

The load() method parses valid JSON string that it receives as an argument and converts it into a Python dictionary for manipulation. The error message shows that it expected a JSON value but did not receive one.

That means your code did not parse JSON string or parse an empty string to the load() method. A quick code snippet can easily verify this.

import json

data = ""

js = json.loads(data)

The output of the code:

Traceback (most recent call last):
  File "c:UsersakinlDocumentspythontexts.py", line 4, in <module>
    js = json.loads(data)
  File "C:Python310libjson__init__.py", line 346, in loads
    return _default_decoder.decode(s)
  File "C:Python310libjsondecoder.py", line 337, in decode
    obj, end = self.raw_decode(s, idx=_w(s, 0).end())
  File "C:Python310libjsondecoder.py", line 355, in raw_decode
    raise JSONDecodeError("Expecting value", s, err.value) from None
json.decoder.JSONDecodeError: Expecting value: line 1 column 1 (char 0)

The same error message is present, and we can ascertain that the error came from an empty string argument.

For a more detailed example, let us try to access a Google Map API and collect user location, e.g., US or NG, but it does not return any value.

import urllib.parse
import urllib.request
import json

googleURL = 'http://maps.googleapis.com/maps/api/geocode/json?'

while True:
    address = input('Enter location: ')

        if address == "exit":
      break

    if len(address) < 1:
        break

    url = googleURL + urllib.parse.urlencode({'sensor': 'false',
                                              'address': address})
    print('Retrieving', url)
    uReq = urllib.request.urlopen(url)
    data = uReq.read()
    print('Returned', len(data), 'characters')

    js = json.loads(data)
    print(js)

The output of the code:

Traceback (most recent call last):
  File "C:UsersakinlDocumentshtmlpythonjsonArt.py", line 18, in <module>
    js = json.loads(str(data))
  File "C:Python310libjson__init__.py", line 346, in loads
    return _default_decoder.decode(s)
  File "C:Python310libjsondecoder.py", line 337, in decode
    obj, end = self.raw_decode(s, idx=_w(s, 0).end())
  File "C:Python310libjsondecoder.py", line 355, in raw_decode
    raise JSONDecodeError("Expecting value", s, err.value) from None
json.decoder.JSONDecodeError: Expecting value: line 1 column 1 (char 0)

We obtained the same error. However, to catch such errors and prevent breakdown, we can use the try/except logic to safeguard our code.

Therefore, if the API does not return any JSON value at a point of request, we can return another expression and not an error.

The above code becomes:

import urllib.parse
import urllib.request
import json

googleURL = 'http://maps.googleapis.com/maps/api/geocode/json?'

while True:
    address = input('Enter location: ')

    if address == "exit":
        break

    if len(address) < 1:
        break

    url = googleURL + urllib.parse.urlencode({'sensor': 'false',
                                              'address': address})
    print('Retrieving', url)
    uReq = urllib.request.urlopen(url)
    data = uReq.read()
    print('Returned', len(data), 'characters')

    try:
        js = json.loads(str(data))
    except:
        print("no json returned")

The output of the code when we enter location as US:

Enter location: US
Retrieving http://maps.googleapis.com/maps/api/geocode/json?sensor=false&address=US
Returned 237 characters
no json returned

Because no JSON value was returned, the code prints no json returned. Because the error is more a non-presence of argument that cannot be controlled, the use of try/except is important.