export const description =
  'On this page, we’ll dive into the different conversation endpoints you can use to manage conversations programmatically.'


## Request Object

The request object is a dataclass that contains all the information about the request. It is available in the route handler as the first argument.



<Row>
<Col>
The request object is created in Rust side but is exposed to Python as a dataclass.

<ul>
<li>
Attributes:
</li>
<li>
query_params (QueryParams): The query parameters of the request. `e.g. /user?id=123 -> {"id": [ "123" ]}`
</li>
<li>
headers (dict[str, str]): The headers of the request. `e.g. {"Content-Type": "application/json"}`
</li>
<li>
params (dict[str, str]): The parameters of the request. `e.g. /user/:id -> {"id": "123"}`
</li>
<li>
body (Union[str, bytes]): The body of the request. If the request is a JSON, it will be a dict.
</li>
<li>
method (str): The method of the request. `e.g. GET, POST, PUT, DELETE`
</li>
<li>
ip_addr (Optional[str]): The IP Address of the client
</li>
<li>
identity (Optional[Identity]): The identity of the client
</li>


</ul>





</Col>
  <Col>

    <CodeGroup title="Request" tag="GET" label="/hello_world">

    ```python {{ title: 'untyped' }}
    @dataclass
    class Request:
      """
      query_params: QueryParams
      headers: Headers
      path_params: dict[str, str]
      body: Union[str, bytes]
      method: str
      url: Url
      form_data: dict[str, str]
      files: dict[str, bytes]
      ip_addr: Optional[str]
      identity: Optional[Identity]
      """
    ```

    ```python {{ title: 'typed' }}
    @dataclass
    class Request:
      """
      query_params: QueryParams
      headers: Headers
      path_params: dict[str, str]
      body: Union[str, bytes]
      method: str
      url: Url
      form_data: dict[str, str]
      files: dict[str, bytes]
      ip_addr: Optional[str]
      identity: Optional[Identity]
      """
    ```
    </CodeGroup>
  </Col>
</Row>

## Extra Path Parameters

Robyn supports capturing extra path parameters using the `*extra` syntax in route definitions. This allows you to capture any additional segments in the URL path that come after the defined route.

For example, if you define a route like this:

<CodeGroup>
```python
@app.get("/sync/extra/*extra")
def sync_param_extra(request: Request):
    extra = request.path_params["extra"]
    return extra
```
</CodeGroup>

Any additional path segments after `/sync/extra/` will be captured in the `extra` parameter. For instance:

<ul>
<li>
A request to `/sync/extra/foo/bar` would result in `extra = "foo/bar"`
</li>
<li>
     A request to `/sync/extra/123/456/789` would result in `extra = "123/456/789"`
</li>
</ul>

You can access the extra path parameters through `request.path_params["extra"]` in your route handler.

This feature is particularly useful when you need to handle dynamic, nested routes or when you want to capture an unknown number of path segments.

---


## What's next?

Now, Batman wanted to understand the configuration of the Robyn server. He was then introduced to the concept of Robyn env files.

- [Robyn Env](/documentation/en/api_reference/robyn_env)

