I think I arrive a little bit late to the party, but I think this answer may come handy for future users having the same question.

To convert the dataclass to json you can use the combination that you are already using using (asdict plus json.dump).

from pydantic.dataclasses import dataclass

@dataclass
class User:
  id: int
  name: str

user = User(id=123, name="James")
d = asdict(user)  # {'id': 123, 'name': 'James'
user_json = json.dumps(d)
print(user_json)  # '{"id": 123, "name": "James"}'

# Or directly with pydantic_encoder
json.dumps(user, default=pydantic_encoder)

Then from the raw json you can use a BaseModel and the parse_raw method.

If you want to deserialize json into pydantic instances, I recommend you using the parse_raw method:

user = User.__pydantic_model__.parse_raw('{"id": 123, "name": "James"}')
print(user)
# id=123 name='James'

Otherwise, if you want to keep the dataclass:

json_raw = '{"id": 123, "name": "James"}'
user_dict = json.loads(json_raw)
user = User(**user_dict)

Pydantic 1.x (old answer)

The current version of pydantic does not support creating jsonable dict straightforwardly. But you can use the following trick:

Note: This is a suboptimal solution

class Model(BaseModel):
    the_id: UUID = Field(default_factory=uuid4)

print(json.loads(Model().json()))

{'the_id': '4c94e7bc-78fe-48ea-8c3b-83c180437774'}

Or more efficiently by means of orjson

orjson.loads(Model().json())

Pydantic 2

There is the model_dump() method accepting the mode parameter.

mode: Literal['json', 'python'] | str = 'python'

If mode is 'json', the dictionary will only contain JSON serializable types.

If mode is 'python', the dictionary may contain any Python objects.

class Model(BaseModel):
    the_id: UUID = Field(default_factory=uuid4)

print(Model().model_dump(mode='json'))
# {'the_id': '4c94e7bc-78fe-48ea-8c3b-83c180437774'}

My suggestion would be to use Pydantic TypeAdapter instead.

from pydantic import BaseModel, TypeAdapter
from typing import TypeAlias

class User(BaseModel):
    id: int
    name: str = 'Jane Doe'

UserList: TypeAlias = list[User]
UserListModel = TypeAdapter(UserList)

if __name__ == '__main__':
    user1 = User(id=123)
    user2 = User(id=456)

    users = [user1, user2]
    print(UserListModel.dump_json(users))
    # b'[{"id":123,"name":"Jane Doe"},{"id":456,"name":"Jane Doe"}]'

Simple and updated answer Pydantic +2

Using RootModel

from datetime import date, datetime

from pydantic import BaseModel, RootModel


class Car(BaseModel):
    model: str
    is_fast: bool
    buy_date: date
    buy_datetime: datetime
    max_speed: float


Cars = RootModel[list[Car]]
cars = Cars(
    [
        Car(
            model=f"G Wagon {i}",
            is_fast=i % 2 == 0,
            buy_date=datetime.now().date(),
            buy_datetime=datetime.now(),
            max_speed=i + 1337,
        )
        for i in range(2)
    ]
)
json_txt = cars.model_dump_json(indent=2)

print(json_txt)

[
  {
    "model": "G Wagon 0",
    "is_fast": true,
    "buy_date": "2025-01-27",
    "buy_datetime": "2025-01-27T14:41:04.559555",
    "max_speed": 1337.0
  },
  {
    "model": "G Wagon 1",
    "is_fast": false,
    "buy_date": "2025-01-27",
    "buy_datetime": "2025-01-27T14:41:04.560554",
    "max_speed": 1338.0
  }
]

https://docs.pydantic.dev/latest/concepts/models/#rootmodel-and-custom-root-types