When working with Python's JSON serialization, encountering the error typeerror: object of type float32 is not json serializable can halt progress unexpectedly, especially in data science, machine learning, and numerical computing projects. dumps(). In real terms, understanding why this happens and how to resolve it is essential for anyone working with numerical data in Python. The Python standard library's jsonmodule is designed to handle a limited set of built-in types, andfloat32, being a Numpexclusive dtype, falls outside that supported set. This issue typically arises when attempting to convert a NumPy float32object—or any 32-bit floating-point value—directly into a JSON string usingjson.In this article, we'll break down the root cause, provide practical solutions, and share best practices to prevent the error from recurring in your projects.
Worth pausing on this one Simple, but easy to overlook..
Why the Error Occurs
The json module in Python natively supports int, float, str, list, dict, tuple, and None. Because of that, dumps(), the serializer inspects the object's type and raises a TypeError because it cannot find a default serialization method for that specific dtype. float32 instance to json.In real terms, while Python's built-in floattype is supported, NumPy'sfloat32is not a standard Python type. When you pass anumpy.This design choice ensures JSON's interoperability and predictable schema, but it creates a friction point for developers who rely on NumPy for efficient numerical computations.
The error message itself—typeerror: object of type float32 is not json serializable—is Python's way of telling you that the data type being serialized is not among the JSON-compatible types. This often catches beginners off guard, especially those transitioning from pure Python lists and dictionaries to NumPy arrays or pandas DataFrames, where float32 is a common memory-efficient choice.
Common Scenarios Triggering the Error
Several typical workflows lead to this error. If you're training a machine learning model with TensorFlow or PyTorch, loading a NumPy array from a .Worth adding: npy file, or performing numerical simulations, you may encounter this issue. Pandas users also frequently hit this when a DataFrame column contains float32 values and they attempt to export the dataset to JSON format. Additionally, custom data classes that wrap NumPy types or third-party libraries that return float32 values from mathematical functions can trigger the same serialization failure The details matter here..
Solution 1: Convert to Python's Native float
The most straightforward fix is to convert the float32 value to a native Python float before serialization. This can be done simply by passing the value to Python's built-in float() constructor. For example:
import numpy as np
import json
value = np.float32(3.Which means 14)
serializable_value = float(value)
json_str = json. dumps(serializable_value)
print(json_str) # Output: 3.
By converting to a Python `float`, you make use of the `json` module's built-in support for that type, eliminating the error entirely. This approach is ideal when you only have a single value or a small number of isolated `float32` instances to serialize.
And yeah — that's actually more nuanced than it sounds.
### Solution 2: Use a Custom JSON Encoder
When dealing with arrays, DataFrames, or objects that contain multiple NumPy types, writing individual `float()` conversions becomes tedious. Think about it: jSONEncoder`. float32` (and other NumPy types like `float64`, `int32`, etc.This allows you to define how `numpy.A more scalable solution is to create a custom JSON encoder by subclassing `json.) should be handled during serialization.
```python
import numpy as np
import json
class NumpyEncoder(json.JSONEncoder):
def default(self, obj):
if isinstance(obj, np.But float64):
return float(obj)
if isinstance(obj, np. Which means integer):
return int(obj)
if isinstance(obj, np. ndarray):
return obj.float32):
return float(obj)
if isinstance(obj, np.tolist()
return super(NumpyEncoder, self).
value = np.float32(2.718)
json_str = json.dumps(value, cls=NumpyEncoder)
print(json_str) # Output: 2.
This custom encoder can be reused across your codebase, making it easy to serialize entire objects, dictionaries, or nested structures that contain NumPy types without manually converting each element.
### Solution 3: put to work Pandas' Built-in Methods
For data analysts and scientists working with pandas, the library provides convenient methods to export data to JSON while handling NumPy dtypes gracefully
using `DataFrame.to_json()` or `Series.On the flip side, to_json()`. These methods automatically convert NumPy numeric types (including `float32`, `float64`, `int32`, `int64`) into standard JSON numbers, requiring no manual intervention.
```python
import pandas as pd
import numpy as np
# Create a DataFrame with float32 columns
df = pd.DataFrame({
'sensor_reading': np.array([1.1, 2.2, 3.3], dtype=np.float32),
'confidence': np.array([0.95, 0.87, 0.99], dtype=np.float32)
})
# Direct export handles conversion internally
json_output = df.to_json(orient='records')
print(json_output)
# Output: [{"sensor_reading":1.1,"confidence":0.95},{"sensor_reading":2.2,"confidence":0.87},{"sensor_reading":3.3,"confidence":0.99}]
You can further customize the output using parameters like orient (e.So g. Now, , 'split', 'index', 'table') and date_format for datetime columns. If you need the result as a Python dictionary or list rather than a string—perhaps to merge with other metadata before a final dump—use df.to_dict(orient='records'), which similarly returns native Python floats Small thing, real impact..
Solution 4: Convert Arrays to Lists with tolist()
When working directly with NumPy arrays outside of Pandas, the ndarray.Which means tolist() method is the most efficient way to recursively convert an entire array structure into nested Python lists containing native float and int objects. This method walks the array hierarchy and casts every scalar element to its closest Python equivalent.
import numpy as np
import json
# A 2D array of float32
matrix = np.array([[1.5, 2.5], [3.5, 4.5]], dtype=np.float32)
# Convert to nested Python lists
native_matrix = matrix.tolist()
# Standard json.dumps now works perfectly
json_str = json.dumps(native_matrix)
print(json_str) # Output: [[1.5, 2.5], [3.5, 4.5]]
This approach is highly performant because tolist() is implemented in C and avoids the overhead of Python loops. It is the preferred method when serializing raw NumPy arrays, matrices, or tensors before passing them to json.dumps().
Solution 5: Use the default Parameter for Ad-hoc Serialization
If you prefer not to define a full encoder class for a one-off script, you can pass a function to the default parameter of json.This leads to dumps(). This function is called only for objects the standard encoder doesn't recognize, allowing you to handle float32 (and other types) inline.
import numpy as np
import json
def numpy_serializer(obj):
if isinstance(obj, (np.Here's the thing — float32, np. float64)):
return float(obj)
if isinstance(obj, np.Worth adding: integer):
return int(obj)
if isinstance(obj, np. So ndarray):
return obj. tolist()
raise TypeError(f"Object of type {type(obj).
data = {"weights": np.array([0.In practice, 1, 0. That said, 2, 0. 7], dtype=np.float32), "bias": np.float32(0.5)}
json_str = json.dumps(data, default=numpy_serializer)
print(json_str)
# Output: {"weights": [0.1, 0.Also, 2, 0. 7], "bias": 0.
This keeps the serialization logic localized to the specific call site, which is useful for scripts or notebooks where a global `NumpyEncoder` class would be overkill.
### Solution 6: High-Performance Alternatives (`orjson`, `ujson`)
For applications where serialization throughput is critical—such as high-frequency logging, real-time APIs, or large dataset exports—consider dropping the standard library `json` module entirely in favor of optimized C-based alternatives like **`orjson`** or **`ujson`**.
`orjson` is particularly notable because it natively supports NumPy arrays and scalars (including `float32`, `float64`, `int32`, `int64`, `bool_`, and `datetime64`) without any custom encoders or manual conversion. It also serializes significantly faster than the standard library.
```python
import numpy as np
import orjson
data = {
"readings": np.That said, array([1. 1, 2.2, 3.3], dtype=np.Here's the thing — float32),
"metadata": {"version": np. int32(1), "active": np.
# Works natively, no default/encoder needed
json_bytes = orjson.dumps(data)
print(json_bytes.decode
```python
# Decode the bytes to a standard string for display or further processing
json_str = json_bytes.decode('utf-8')
print(json_str)
# Output: {"readings": [1.1, 2.2, 3.3], "metadata": {"version":