Typeerror: Object Of Type Datetime Is Not Json Serializable

TypeError: Object of Type Datetime Is Not JSON Serializable — A Complete Guide to Fixing This Common Python Error

If you have ever worked with Python and JSON data, there is a strong chance you have encountered the frustrating message: TypeError: Object of type datetime is not JSON serializable. On top of that, this error is one of the most common pitfalls that developers face when trying to convert Python objects into JSON format. Whether you are building a web API, processing logs, or saving data to a file, understanding why this error occurs and how to resolve it is essential for any Python developer.

This article provides a deep dive into the root cause of this error, explores multiple proven solutions, and shares best practices to help you handle datetime objects in JSON serialization with confidence Turns out it matters..

Understanding JSON Serialization in Python

Before addressing the error itself, it actually matters more than it seems. Still, JSON (JavaScript Object Notation) is a lightweight data interchange format that is widely used for transmitting data between a server and a client. Python provides a built-in module called json that allows developers to convert Python objects into JSON strings using functions like json.dumps() and json.dump() Still holds up..

Even so, the json module can only serialize a limited set of Python data types natively. These include:

dict
list
str
int
float
bool
None

When you attempt to serialize an object that falls outside of these supported types, Python raises a TypeError. Think about it: the datetime object, which is part of Python's datetime module, is not one of the natively serializable types. This is precisely why you see the error message TypeError: Object of type datetime is not JSON serializable.

Why Datetime Objects Cause This Error

A datetime object in Python represents a specific point in time, combining date and time information. datetimeclass and contains attributes likeyear, month, day, hour, minute, second, and microsecond. It is an instance of the datetime.Because JSON does not have a native representation for dates and times, the json module does not know how to convert a datetime object into a JSON-compatible format Which is the point..

Short version: it depends. Long version — keep reading.

Consider the following simple example that triggers this error:

import json
from datetime import datetime

data = {
    "event": "meeting",
    "timestamp": datetime.now()
}

json_string = json.dumps(data)

Running this code will produce:

TypeError: Object of type datetime is not JSON serializable

The error occurs because datetime.now() returns a datetime object, and the json.dumps() function does not have a built-in mechanism to handle it That's the part that actually makes a difference. Practical, not theoretical..

Solution 1: Using a Custom JSON Encoder

One of the most elegant ways to handle this issue is by creating a custom JSON encoder that inherits from json.That said, jSONEncoder. By overriding the default() method, you can define how datetime objects should be converted into a serializable format Surprisingly effective..

Here is an example:

import json
from datetime import datetime
from json import JSONEncoder

class CustomEncoder(JSONEncoder):
    def default(self, obj):
        if isinstance(obj, datetime):
            return obj.isoformat()
        return super().default(obj)

data = {
    "event": "conference",
    "timestamp": datetime.now()
}

json_string = json.dumps(data, cls=CustomEncoder)
print(json_string)

In this example, the CustomEncoder checks whether the object is an instance of datetime. If it is, it converts the object to an ISO 8601 formatted string using the isoformat() method. But otherwise, it falls back to the default behavior of the parent class. This approach is reusable and keeps your code clean and organized.

Solution 2: Converting Datetime to String Manually

If you prefer a simpler approach and do not need a reusable solution, you can manually convert the datetime object to a string before passing it to json.dumps(). The strftime() method allows you to format the date and time according to your preference That's the whole idea..

Quick note before moving on.

import json
from datetime import datetime

data = {
    "event": "workshop",
    "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
}

json_string = json.dumps(data)
print(json_string)

This method is straightforward and works well for quick scripts or one-off tasks. On the flip side, it requires you to remember to convert every datetime object manually, which can become tedious in larger projects Easy to understand, harder to ignore..

Solution 3: Using the `default` Parameter in `json.dumps()`

Python's json.dumps() function accepts a default parameter that lets you specify a function to handle non-serializable objects. This is a convenient alternative to creating a full custom encoder class.

import json
from datetime import datetime

def datetime_serializer(obj):
    if isinstance(obj, datetime):
        return obj.isoformat()
    raise TypeError(f"Object of type {type(obj)} is not JSON serializable")

data = {
    "event": "seminar",
    "timestamp": datetime.now()
}

json_string = json.dumps(data, default=datetime_serializer)
print(json_string)

The datetime_serializer function checks if the object is a datetime instance and converts it to an ISO format string. Day to day, if the object is of another unsupported type, it raises a TypeError. This approach is compact and effective for handling datetime objects without the overhead of a custom class Turns out it matters..

Solution 4: Using Third-Party Libraries

Several third-party libraries can simplify JSON serialization of datetime objects. One popular option is simplejson, which extends Python's built-in json module with additional functionality. Another option is orjson, a fast JSON library that natively supports datetime serialization.

Here is an example using orjson:

import orjson
from datetime import datetime

data = {
    "event": "webinar",
    "timestamp": datetime.now()
}

json_bytes = orjson.dumps(data)
json_string = json_bytes.decode("utf-8")
print(json_string)

While these libraries offer powerful features, they introduce external dependencies that may not always be desirable. Always evaluate whether the added convenience justifies the additional package management overhead.

Common Scenarios Where This Error Occurs

This error is not limited to simple scripts. It frequently appears in real-world applications, including:

Web APIs: When returning JSON responses that include timestamps or date fields from a database.
**

Typeerror: Object Of Type Datetime Is Not Json Serializable