Quando você cria uma *operação de rota* no **FastAPI**, normalmente você pode retornar qualquer dado: um `dict`, uma `list`, um modelo do Pydantic, um modelo do banco de dados, etc.

Se você declarar um [Modelo de resposta](../tutorial/response-model.md), o FastAPI irá usá-lo para serializar os dados para JSON, usando o Pydantic.

Supongamos que solo tienes un único parámetro de cuerpo `item` de un modelo Pydantic `Item`.

Por defecto, **FastAPI** esperará su cuerpo directamente.

Pero si deseas que espere un JSON con una clave `item` y dentro de ella los contenidos del modelo, como lo hace cuando declaras parámetros de cuerpo extra, puedes usar el parámetro especial `Body` `embed`:

```Python

/// info | Información

Ten en cuenta que el `TestClient` recibe datos que pueden ser convertidos a JSON, no modelos de Pydantic.

Si tienes un modelo de Pydantic en tu prueba y quieres enviar sus datos a la aplicación durante las pruebas, puedes usar el `jsonable_encoder` descrito en [Codificador Compatible con JSON](encoder.md).

///

import `ServerSentEvent` de `fastapi.sse`:

{* ../../docs_src/server_sent_events/tutorial002_py310.py hl[4,26] *}

El campo `data` siempre se codifica como JSON. Puedes pasar cualquier valor que pueda serializarse como JSON, incluidos modelos de Pydantic.

## Datos sin procesar { #raw-data }

Si necesitas enviar datos **sin** codificarlos a JSON, usa `raw_data` en lugar de `data`.

{* ../../docs_src/server_sent_events/tutorial002_py310.py hl[4,26] *}

O campo `data` é sempre codificado como JSON. Você pode passar qualquer valor que possa ser serializado como JSON, incluindo modelos do Pydantic.

## Dados brutos { #raw-data }

Se você precisar enviar dados sem codificação JSON, use `raw_data` em vez de `data`.

{* ../../docs_src/path_params/tutorial005_py310.py hl[1,6:9] *}

/// tip | Consejo

Si te estás preguntando, "AlexNet", "ResNet" y "LeNet" son solo nombres de <dfn title="Técnicamente, arquitecturas de modelos de Deep Learning">modelos</dfn> de Machine Learning.

///

### Declarar un *path parameter* { #declare-a-path-parameter }

Luego crea un *path parameter* con una anotación de tipo usando la clase enum que creaste (`ModelName`):

/// info | Informação

Observe que o `TestClient` recebe dados que podem ser convertidos para JSON, não para modelos Pydantic.

Se você tiver um modelo Pydantic em seu teste e quiser enviar seus dados para o aplicativo durante o teste, poderá usar o `jsonable_encoder` descrito em [Codificador compatível com JSON](encoder.md).

///

Suponha que você tem um único parâmetro de corpo `item`, a partir de um modelo Pydantic `Item`.

Por padrão, o **FastAPI** esperará que seu conteúdo venha no corpo diretamente.

Mas se você quiser que ele espere por um JSON com uma chave `item` e dentro dele os conteúdos do modelo, como ocorre ao declarar vários parâmetros de corpo, você pode usar o parâmetro especial de `Body` chamado `embed`:

Ele não consegue lidar muito bem com modelos aninhados. Então, se o corpo JSON na requisição for um objeto JSON que contém campos internos que por sua vez são objetos JSON aninhados, ele não consegue ser documentado e validado apropriadamente.

    hashed_password = user_dict["hashed_password"],
)
```

/// info | Información

Para una explicación más completa de `**user_dict` revisa en [la documentación para **Extra Models**](../extra-models.md#about-user-in-dict).

///

## Devolver el token { #return-the-token }

El response del endpoint `token` debe ser un objeto JSON.