Python json.JSONEncoder.default() Method

The Pythonjson.JSONEncoder.default() method is a method of thejson.JSONEncoder class that can be overridden to customize how non-serializable objects are encoded into JSON.

By default, thedefault() method raises aTypeError if an object is not serializable. However, we can override this method to define custom serialization logic for unsupported data types.

Syntax

Following is the syntax of the Pythonjson.JSONEncoder.default() method −

json.JSONEncoder().default(obj)

Parameters

This method accepts the Python object as a parameter that needs to be serialized.

Return Value

This method should return a JSON-serializable object. If an object cannot be serialized, aTypeError is raised unless handled in a custom implementation.

Example: Default Behavior of default()

If we try to serialize an unsupported object, Python will raise aTypeError by default −

import json# Sample classclass Person:   def __init__(self, name, age):      self.name = name      self.age = age# Create a Person objectperson = Person("Alice", 30)# Attempt to encode the objecttry:   json_data = json.dumps(person)except TypeError as e:   print("Error:", e)

Following is the output obtained −

Error: Object of type 'Person' is not JSON serializable

Example: Custom Serialization Using default()

We can override thedefault() method to convert an unsupported object into a JSON-compatible format −

import json# Sample classclass Person:   def __init__(self, name, age):      self.name = name      self.age = age# Custom JSON Encoderclass CustomEncoder(json.JSONEncoder):   def default(self, obj):      if isinstance(obj, Person):         return {"name": obj.name, "age": obj.age}  # Convert to dictionary      return super().default(obj)  # Fallback to default behavior# Create a Person objectperson = Person("Alice", 30)# Encode the object using the custom encoderjson_data = json.dumps(person, cls=CustomEncoder)print("Serialized JSON:", json_data)

We get the output as shown below −

Serialized JSON: {"name": "Alice", "age": 30}

Example: Handling Multiple Custom Types

We can modify thedefault() method to support multiple custom types −

import jsonfrom datetime import datetime# Sample classesclass Person:   def __init__(self, name, age):      self.name = name      self.age = ageclass Event:   def __init__(self, event_name, date):      self.event_name = event_name      self.date = date  # datetime object# Custom JSON Encoderclass CustomEncoder(json.JSONEncoder):   def default(self, obj):      if isinstance(obj, Person):         return {"name": obj.name, "age": obj.age}      elif isinstance(obj, Event):         return {"event_name": obj.event_name, "date": obj.date.isoformat()}  # Convert datetime to string      return super().default(obj)# Create objectsperson = Person("Bob", 25)event = Event("Conference", datetime(2025, 5, 17))# Encode the objectsjson_data = json.dumps({"person": person, "event": event}, cls=CustomEncoder)print("Serialized JSON:", json_data)

The result produced is as shown below −

Serialized JSON: {"person": {"name": "Bob", "age": 25}, "event": {"event_name": "Conference", "date": "2025-05-17T00:00:00"}}

Example: Using default() with JSONEncoder Subclass

Instead of creating a custom encoder class, we can pass a function to thedefault() method directly using thedefault parameter injson.dumps() function −

import json# Sample classclass Product:   def __init__(self, name, price):      self.name = name      self.price = price# Custom serialization functiondef custom_serializer(obj):   if isinstance(obj, Product):      return {"product_name": obj.name, "product_price": obj.price}   raise TypeError(f"Object of type {obj.__class__.__name__} is not JSON serializable")# Create a Product objectproduct = Product("Laptop", 1200.50)# Encode the object with custom serialization functionjson_data = json.dumps(product, default=custom_serializer)print("Serialized JSON:", json_data)

After executing the above code, we get the following output −

Serialized JSON: {"product_name": "Laptop", "product_price": 1200.5}

Example: Handling Nested Objects

We can also handle nested objects inside dictionaries or lists using thedefault() method −

import json# Sample classclass Address:   def __init__(self, street, city):      self.street = street      self.city = cityclass Person:   def __init__(self, name, age, address):      self.name = name      self.age = age      self.address = address  # Nested object# Custom JSON Encoderclass CustomEncoder(json.JSONEncoder):   def default(self, obj):      if isinstance(obj, Address):         return {"street": obj.street, "city": obj.city}      elif isinstance(obj, Person):         return {"name": obj.name, "age": obj.age, "address": self.default(obj.address)}      return super().default(obj)# Create objectsaddress = Address("123 Main St", "New York")person = Person("Alice", 30, address)# Encode the objectjson_data = json.dumps(person, cls=CustomEncoder)print("Serialized JSON:", json_data)

Following is the output of the above code −

Serialized JSON: {"name": "Alice", "age": 30, "address": {"street": "123 Main St", "city": "New York"}}