How to Work with JSON.dump() in Python: Ultimate Guide

This guide explains how the json.dump() and json.dumps in Python operate — a key tool for storing structured data in JSON format. This approach is widely applied when working with configuration files, web scraping results, API responses, and other structured data. The material covers the function’s syntax, its parameters, difference between json.dump vs json.dumps, usage examples, supported data types, as well as best practices for efficient and reliable handling of JSON in Python.

What Does json.dump Do?

json.dump is a function from the json module used to serialize a Python object into JSON format and directly save it to a file.

Syntax and Parameters of json.dump()

The json.dump() function accepts two main arguments — the data and the file object where the JSON output will be written. The general call structure looks as follows:

json.dump(obj, file, **kwargs)

• obj — a Python object (for example, a dictionary or list) that needs to be stored.
• file — an open file in write mode, where the output will be saved.

In addition to the main arguments, several optional parameters are available:

• indent — defines indentation for pretty-printing JSON.
• sort_keys — if set to True, sorts dictionary keys in alphabetical order.
• ensure_ascii — if set to False, allows non-ASCII characters to be stored in the output.

These parameters are particularly useful when the readability of the data is important, as well as when preparing files for machine processing.

How and When to Use json.dump() in Python

The Python json dump function is applied for serializing data and immediately saving it to a file in JSON format. It is useful in cases where results of web scraping, application configuration, or collected data need to be stored in a file for further analysis or transfer.

Key advantages include:

• Direct file output — reduces memory usage since no intermediate string is created.
• Flexible parameters — options such as indent, sort_keys, and ensure_ascii make it easy to adapt the output to specific requirements.
• Unicode support — critical when working with multilingual projects.

The json module is part of Python’s standard library, meaning no third-party installations are required — an import at the beginning of the script is sufficient.

What Data Types Can Be Converted to JSON in Python

The json.dump() function supports serialization only of objects that can be represented in JSON format. These include lists, dictionaries, strings, integers, floating-point numbers, Boolean values, and None.

An example demonstrating typical usage of json.dump() for saving a dictionary:

import json

data = {
    "name": "Helen",
    "age": 28,
    "is_active": True,
    "skills": ["Python", "SQL"]
}

with open("user.json", "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False, indent=2)

If an attempt is made to serialize unsupported objects (such as classes or functions), a TypeError will be raised.

json.dump() vs json.dumps()

Python provides two similar functions for serializing data into JSON format — json.dump() and json.dumps(). Despite the similarity in their names, they serve different purposes:

• json.dump() writes serialized data directly to a file. It accepts two main arguments — the object and an open file descriptor.
• json.dumps() returns a string in JSON format, which can then be processed further or written to a file manually. Any parameter available in json.dumps() (such as indent, ensure_ascii, or sort_keys) can be applied to customize the result.

The difference between json.dump() and writing the output of json.dumps() to a file is illustrated in the examples below:

import json

data = {"key": "value"}

# Using json.dump()
with open("output.json", "w", encoding="utf-8") as f:
    json.dump(data, f)

# Using json.dumps()
json_string = json.dumps(data)
print(json_string)  # {"key": "value"}

The key distinction between the two is based on the task:

• if the goal is to save data directly to a file — json.dump() should be used;
• if a string representation is needed for further processing — json.dumps() is more suitable.

How to Save Data to a File Using JSON in Python

Saving data to a JSON file is one of the most common scenarios in Python. To do this, just create a Python object (for example, a dictionary), open the file in write mode, and pass the object to the json.dump() function.

Writing JSON to a File in Python:

import json

# 1. Data to be stored
user_data = {
    "username": "admin",
    "active": True,
    "roles": ["editor", "moderator"]
}

# 2. Open file in write mode
with open("data.json", "w", encoding="utf-8") as f:
    # 3. Write to file
    json.dump(user_data, f, ensure_ascii=False, indent=4)

In this example:

• ensure_ascii=False allows Cyrillic characters to be stored without escape sequences.
• indent=4 adds indentation for improved readability.
• The file data.json is created (or overwritten), and the structure is written in a formatted JSON representation.

Mastering JSON in Python: Best Practices

When working with JSON in Python, it is advisable to follow a set of practices that simplify data handling and increase code reliability:

• Use the json.dumps indent parameter: it adds spacing to the JSON file, making the structure easier to read both for humans and during debugging.
• Validate data before serialization: some object types (for example, classes, functions, or objects like datetime) are not supported by JSON by default and need to be converted manually.
• Handle encoding properly: for storing data with Cyrillic or other non-ASCII characters, use ensure_ascii=False and open the file with UTF-8 encoding.
• Avoid loading entire large files into memory: instead of storing the full structure at once, write data in parts or use streaming approaches.

Following these principles helps prevent errors and improves scalability, especially in tasks related to collecting and processing large volumes of structured information.

Conclusion

json.dump() is a reliable and efficient tool for saving structured data in JSON format, it enables writing Python objects directly to files while supporting formatting, key sorting, and proper handling of multilingual text. The json.dumps() function complements it by providing string-based serialization for flexible processing. These functions cover a wide range of use cases, from storing configuration files to managing results of web scraping and API responses.

Adhering to best practices ensures readability, correctness, and stability when working with JSON in Python, making these tools an integral part of modern development workflows.