Sanic holds the configuration in the config attribute of the application object. The configuration object is merely an object that can be modified either using dot-notation or like a dictionary.

```python
app = Sanic("myapp")
app.config.DB_NAME = "appdb"
app.config["DB_USER"] = "appuser"
```

You can also use the `update()` method like on regular dictionaries.

```python
db_settings = {
    'DB_HOST': 'localhost',
    'DB_NAME': 'appdb',
    'DB_USER': 'appuser'
}
app.config.update(db_settings)
```

It is standard practice in Sanic to name your config values in **uppercase letters**. Indeed, you may experience weird behaviors if you start mixing uppercase and lowercase names.

Any environment variables defined with the `SANIC_` prefix will be applied to the Sanic config. For example, setting `SANIC_REQUEST_TIMEOUT` will be loaded by the application automatically and fed into the `REQUEST_TIMEOUT` config variable.

```bash
$ export SANIC_REQUEST_TIMEOUT=10
```
```python
>>> print(app.config.REQUEST_TIMEOUT)
10
```

You can change the prefix that Sanic is expecting at startup.

```bash
$ export MYAPP_REQUEST_TIMEOUT=10
```
```python
>>> app = Sanic(__name__, env_prefix='MYAPP_')
>>> print(app.config.REQUEST_TIMEOUT)
10
```

You can also disable environment variable loading completely.

```python
app = Sanic(__name__, load_env=False)
```

Let's say you have `my_config.py` file that looks like this.

```python
# my_config.py
A = 1
B = 2
```

You can load this as config values by passing its path to `app.update_config`.

```python
>>> app.update_config("/path/to/my_config.py")
>>> print(app.config.A)
1
```

This path also accepts bash style environment variables.

```bash
$ export my_path="/path/to"
```
```python
app.update_config("${my_path}/my_config.py")
```

Just remember that you have to provide environment variables in the format `${environment_variable}` and that `$environment_variable` is not expanded (is treated as "plain" text).

The `app.update_config` method also works on plain dictionaries.

```python
app.update_config({"A": 1, "B": 2})
```

You can define your own config class, and pass it to `app.update_config`

```python
class MyConfig:
    A = 1
    B = 2

app.update_config(MyConfig)
```

It even could be instantiated.

```python
app.update_config(MyConfig())
```

Additionally, Sanic can be configured to cast additional types using additional type converters. This should be any callable that returns the value or raises a `ValueError`.

*Added in v21.12*

```python
app = Sanic(..., config=Config(converters=[UUID]))
```

This feature was added in version 25.12

For more sophisticated conversion logic that needs access to the full environment variable context, you can use `DetailedConverter`. This abstract base class provides access to the full environment variable key, the raw value, and the current config defaults.

This is useful when you need to:
- Cast values to the type of their defaults
- Perform validation based on the variable name pattern
- Use default values for fallback logic
- Access configuration context during conversion

```python
from sanic.config import DetailedConverter

class DefaultsTypeCastingConverter(DetailedConverter):
    def __call__(self, full_key: str, config_key: str, value: str, defaults: dict):
        try:
            if config_key in defaults:
                return type(defaults[config_key])(value)
        except (ValueError, TypeError) as e:
            raise TypeError(f"Configuration environment variable '{full_key}' type mismatch: expected"
                            f" {type(defaults[config_key]).__name__}, got {type(value).__name__}") from e

app = Sanic(..., config=Config(converters=[DefaultsTypeCastingConverter()]))
```

The `DetailedConverter.__call__` method receives four parameters:

- `full_key`: The full environment variable name with prefix (e.g., "SANIC_DATABASE_URL")
- `config_key`: The config key without prefix (e.g., "DATABASE_URL")
- `value`: The raw string value from the environment
- `defaults`: The current default configuration values

```python
class ValidationConverter(DetailedConverter):
    def __call__(self, full_key: str, config_key: str, value: str, defaults: dict):
        if config_key.endswith('_PORT'):
            port = int(value)
            if not 1 <= port <= 65535:
                raise ValueError(f"Invalid port: {port}")
            return port
        raise ValueError  # Let other converters handle it
```

- The `USE_UVLOOP` value will be ignored if running with Gunicorn. Defaults to `False` on non-supported platforms (Windows).
- The `WEBSOCKET_` values will be ignored if in ASGI mode.
- v21.12 added: `AUTO_EXTEND`, `MOTD`, `MOTD_DISPLAY`, `NOISY_EXCEPTIONS`
- v22.9 added: `INSPECTOR`
- v22.12 added: `INSPECTOR_HOST`, `INSPECTOR_PORT`, `INSPECTOR_TLS_KEY`, `INSPECTOR_TLS_CERT`, `INSPECTOR_API_KEY`