TypeError: dump() missing 1 required positional argument: ‘fp’

The TypeError: dump() missing 1 required positional argument: ‘fp’ is a common error faced while dealing with alternate libraries. BeautifulSoup is an alternative Python library to URLlib that performs web scraping. It extracts data from the HTML of a webpage as the programmer has requested. You will also use the json standard library in Python to work with output and other advanced data sorting when working with web scraping libraries.

However, when working with such a program,, it is a common for Python developers to encounter the error TypeError: dump() missing 1 required positional argument: ‘fp’. In this article, we will discuss the various cases due to which errors may arise and how to solve them.

What causes “TypeError: dump() missing 1 required positional argument: ‘fp'”?

Not passing the file object when using the dump function

The error “TypeError: dump() missing 1 required positional argument: ‘fp’” can also arise if you have not passed the file object argument to the dump method. Consider this code

import json

data = {"name": "Rahul", "age": "15"}


TypeError: dump() missing 1 required positional argument: 'fp'

This code will give us the error “TypeError: dump() missing 1 required positional argument: ‘fp’” because we did not pass the required file object into the json.dump() method.

Incorrect use of the pickle module

The pickle module is a Python standard library for the serialization and deserialization of a Python object. Its behavior can vary depending on the version of Python and the version of the pickle module that is being used. Consider the following code for the demonstration:

import pickle

data = {'name': 'John', 'age': 30}



TypeError: dump() missing 1 required positional argument: 'fp'
TypeError: dump() missing 1 required positional argument: 'fp'

Executing this code in the latest version of Python will give us the related error “TypeError: dump() missing required argument ‘file’“. The error, once again, arises from the similar circumstance of not passing in the file module object as an argument for the pickle.dump() function.

How can the “TypeError: dump() missing 1 required positional argument: ‘fp'” error be resolved?

Using the dumps function correctly

In the code given in Case 1, the error occurred due to the incorrect use of the json.dumps() function. The correct code in this situation will be:

import requests as tt
from bs4 import BeautifulSoup
import json

get_url = tt.get('https://examplesite.com')
soup = BeautifulSoup(get_url.text, "html.parser")

# Check if the result is not empty
if soup.select("script#jsInit1"):
    select_css = soup.select("script#jsInit1")[0]
    for i in select_css:
        print("data dumped successfully")
    print("No data found.")

Output –

No data found

In the above code, we changed the json.dump() function to json.dumps(), which gave us the correct output. json.dumps() function is used to dump the output to a string, while the json.dump() function requires a buffer, i.e., a file object, as previously discussed. Hence, the correct function to use in this regard is json.dumps().

Pass the file object with the dump function

In the code given in case 2, the error occurred due to the file object not being passed to the json.dump() function. To correct the code, we will integrate file manipulation into the codebase. Below is the correct code

import json

data = {"name": "Rahul", "age": "15"}
with open("file.json", "w") as f:
   json.dump(data, f)

print("Data written successfully")

Output –

Data written successfully

In the above-given code, the data dictionary object has been passed to a file called “file.json” which we assigned to the variable f; we opened the file in write mode (“w”) to pass data to the json file. The file object f was then passed to the function json.dump(). The output code, after successful execution of the program, as signified in the print statement, is output to the terminal thereafter.

Use the pickle module correctly

In the given code in Case 3, the error occurred due to the incorrect use of the pickle module in Python. Two different code implementations exist to serialize or deserialize a Python object using Pickle. The given codebase below is specifically for serialization.

import pickle

data = {'name': 'John', 'age': 30}
with open('data.pickle', 'wb') as f:
    pickle.dump(data, f)

print("data pickled succesfully")

Output –

data pickled successfully

In the above-given code, we serialized the data object into a file called ‘data.pickle’ using the pickle.dump() method in the Write Binary(“wb”) access mode in the open() function. The output, as assigned to the print function upon successful program execution, was then shown on screen.

Below is the given code for the deserialization part:

import pickle

with open('data.pickle', 'rb') as f:
    loaded_data = pickle.load(f)


In the deserialization mode, we open the data.pickle file in Read Binary (“rb”) mode with the open() function. We use the function pickle.load(f) to deserialize the data from the file object f and store it in the loaded_data variable. If we print the loaded_data variable, we get the following output

{'name': 'John', 'age': 30}

This shows that the serialization and deserialization process was successful, and we got the output as intended.


Why do we need the pickle module in Python?

The pickle module in Python is crucial for serializing and deserializing Python objects. The process of serialization involves converting a Python object into a byte stream, while the process of deserialization involves reconstructing a Python object from the byte stream. The pickle module provides functions to perform these operations.

Why are serialization and deserialization in Python important

Serialization and deserialization in Python are used to convert a data object into a format that will allow us to store or transmit the data as well as recreate the object when needed using the reverse process deserialization. This is done to save space and processing when working with complex objects in Python; the process of serialization makes it easier to store the objects in any file-like object, such as a disk file or memory stream.

What is the difference between the dump and dumps functions in json?

Dump() serializes a Python object to a file, while dumps() serializes a Python object to a JSON formatted string. dump() writes to a file object, while dumps() returns a string.


In this article, we learned thecauses of the error “TypeError: dump() missing 1 required positional argument: ‘fp’” occurs. We learned that it occurs in 3 cases. We are either using the incorrect JSON function, not passing the file object to the dump function as it requires, or not using the pickle module correctly. The resolution to the cases of error is to use the correct json function if we are trying to print the json data to a string, Passing the file object to the json.dump() function, and lastly, correctly serialize the deserializing with the pickle module in Python.

TypeErrors are the most common form of error in Python, and in this instance, using json functions can add another layer of complexity for new coders to deal with. Still, the problems that arise with the module are very simplistic to deal with and can be resolved easily by adding a few lines of code.


  1. BeautifulSoup
  2. URLlib

To remain up to date, follow PythonClear/Errors for error resolving.

Leave a Comment