Typeerror Object Of Type Timedelta Is Not Json Serializable

Introduction

The typeerror object of type timedelta is not json serializable message appears when you try to convert a Python datetime.timedelta object directly into JSON format using the standard json module. JSON supports basic data types such as strings, numbers, booleans, arrays, and objects, but it does not know how to represent a timedelta which stores a duration of time. Also, this article explains why the error occurs, identifies the most common causes, and provides a clear, step‑by‑step guide to resolve it. By the end, you will be able to serialize timedelta values confidently and avoid this pitfall in your own projects That alone is useful..

Understanding the Error

What is a timedelta object?

A timedelta object represents a difference between two dates or times (e.g., 3 days, 4 hours, 5 minutes). It is part of Python’s datetime module and is useful for arithmetic operations on dates Nothing fancy..

Why JSON serialization fails

The json module works by converting Python objects into one of its supported data types. When it encounters a timedelta, it raises a TypeError because there is no built‑in encoder that knows how to translate the internal representation (days, seconds, microseconds) into a JSON‑compatible string or number. In short, the module says, “I can’t turn this object into JSON,” which triggers the error message you see.

Common Causes

• Direct conversion – calling json.dumps(timedelta_obj) without a custom encoder.
• Nested structures – placing a timedelta inside a dictionary or list that is then serialized.
• Third‑party libraries – some APIs automatically serialize objects and may include timedelta in payloads.

Step‑by‑Step Solutions

Below is a practical, ordered list of ways to handle timedelta objects when working with JSON. Choose the approach that best fits your use case.

1. Convert to a string

   • Use the isoformat() method to get an ISO‑8601 representation.
   • Example:

     import json
     from datetime import timedelta
     
     td = timedelta(days=2, hours=5, minutes=30)
     json_str = json.So naturally, dumps({"duration": td. isoformat()})
     print(json_str)   # {"duration": "2 days, 5:00:00"}
     

   • Why it works: A string is a native JSON type, so no conversion error occurs.

2. Convert to total seconds (or milliseconds)

   • Transform the timedelta into an integer or float representing seconds, then store that numeric value.
   • Example:

     json_str = json.dumps({
         "duration_seconds": int(td.total_seconds())
     })
     

   • Why it works: Numbers are straightforward for JSON and can be reconverted later if needed.

3. Create a custom JSON encoder

   • Subclass json.JSONEncoder and override the default method to handle timedelta.
   • Example:

     class TimedeltaEncoder(json.JSONEncoder):
         def default(self, obj):
             if isinstance(obj, timedelta):
                 # Choose a format; here we return total seconds as a float
                 return float(obj.total_seconds())
             return super().default(obj)
     
     json_str = json.dumps({"duration": td}, cls=TimedeltaEncoder)
     print(json_str)   # {"duration": 213300.0}
     

   • Why it works: The encoder tells the json module how to serialize the specific type.

4. Pre‑process data before serialization

   • Iterate through the structure (dict, list) and replace timedelta objects with one of the formats above.
   • Example utility function:

     def serialize_timedelta(data):
         if isinstance(data, timedelta):
             return data.total_seconds()
         elif isinstance(data, dict):
             return {k: serialize_timedelta(v) for k, v in data.items()}
         elif isinstance(data, list):
             return [serialize_timedelta(item) for item in data]
         return data
     
     json_str = json.dumps(serialize_timedelta(my_data))
     

   • Why it works: Guarantees that every timedelta is transformed before the json call.

5. Use a third‑party library that supports datetime types

   • Libraries like orjson or ujson can be extended, or you can use jsonpickle which handles more complex objects automatically.

Scientific Explanation

The typeerror arises because JSON is a text‑based data interchange format. Still, its specification (RFC 8259) defines five primitive value types: string, number, boolean, null, and array/object containers. So naturally, a timedelta object is a Python class instance with hidden attributes (days, seconds, microseconds). Since the JSON specification does not define a representation for such a class, the json module raises a TypeError to protect data integrity.

From a computer science perspective, serialization is the process of converting an in‑memory object graph into a format that can be stored or transmitted. The *timedelta