---
title: Deploying Open WebUI with Scaleway's Generative APIs
description: This guide explains how to deploy Open WebUI with Scaleway's Generative APIs using Docker or Scaleway's Serverless Containers.
tags: open-webui docker scaleway generative-apis
products:
  - generative-apis
  - containers
dates:
  validation: 2026-05-27
  posted: 2025-02-17
  validation_frequency: 12
difficulty: beginner
usecase:
  - build-and-run-ai
ecosystem:
  - third-party
---
import Requirements from '@macros/iam/requirements.mdx'


Integrating Scaleway's Generative APIs with Open WebUI allows you to leverage powerful AI models in a user-friendly, self-hosted interface.
Open WebUI is an open-source frontend that simplifies interactions with AI models, providing an intuitive alternative to proprietary AI interfaces.

This tutorial will guide you through:

- Configuring Generative APIs on Scaleway
- Installing Open WebUI locally
- Deploying Open WebUI using Scaleway's Serverless Containers


By the end, you will have a fully functional AI-powered setup.

<Requirements />

### Prerequisites

- A Scaleway account logged into the [console](https://console.scaleway.com)
- [Owner](/iam/concepts/#owner) status or appropriate [IAM permissions](/iam/concepts/#permission)
- [Docker](https://docs.docker.com/get-docker/) installed on your system

## Configure Generative APIs on Scaleway

Scaleway's Generative APIs provide access to advanced AI models via simple API calls. Follow the instructions below to set up Generative APIs.

### Create an API key

1. Log in to the [Scaleway console](https://console.scaleway.com/).
2. Click the profile image in the top right corner of the console to display the Organization management menu.
3. Click **IAM & API keys** in the menu.
4. Click the **API keys** tab.
5. Click **Generate API key**, provide a description, then click **Generate API key**.
6. Store the key in a secure place.

For detailed information about creating API keys, refer to the [how to create API keys documentation](/iam/how-to/create-api-keys/).

### Identify the API endpoint

Scaleway assigns a unique endpoint for your Generative API access. This can be found in the Generative APIs section of the console. The format typically follows:

```
https://api.scaleway.ai/<YOUR_PROJECT_ID>/v1
```

If you have not created a dedicated Project and are using the `default` Project created with your Scaleway account, you can use the following URL: `https://api.scaleway.ai/v1`.
You can also find the exact URL snippet including your `project_id` by visiting the [Generative API Playground](https://console.scaleway.com/generative-api/models/fr-par/playground). Select a model, click **Deploy**, then select the **Serverless** option.

For information on how to retrieve your Project ID, refer to our [dedicated documentation](/organizations-and-projects/how-to/create-a-project/).

## Install Open WebUI locally

Open WebUI provides an easy-to-use interface for interacting with AI models. The recommended installation method is via Docker.

### Run Open WebUI with Scaleway integration

1. Pull and run the Docker container. Replace `<YOUR_PROJECT_ID>` and `<YOUR_API_KEY>` with your actual values.

   ```bash
   docker run -p 3000:8080 \
     -e OPENAI_API_BASE_URL=https://api.scaleway.ai/<YOUR_PROJECT_ID>/v1 \
     -e OPENAI_API_KEY=<YOUR_API_KEY> \
     -v open-webui:/app/backend/data \
     --name open-webui \
     --restart always \
     ghcr.io/open-webui/open-webui:main
   ```

2. Navigate to `http://localhost:3000` in your browser to access the Open WebUI interface.
3. Click **Sign Up** to create an administrator account.
4. Select a model from the available Scaleway AI models and start interacting.

For more details, refer to the [Open WebUI Quick Start Guide](https://docs.openwebui.com/getting-started/quick-start/).

## Deploy Open WebUI using Scaleway's Serverless Containers (Optional)

For cloud-based deployments, Scaleway's Serverless Containers offer a scalable solution.

### Deploy via the Scaleway console

1. In the Scaleway console, navigate to **Serverless** > **Containers**.
2. Click **Deploy Container** to display the container creation wizard.
3. Select an external registry and use the `ghcr.io/open-webui/open-webui:main` image.
    <Message type="note">
      The `ghcr.io/open-webui/open-webui:main` image uses the default port `8080`, so no further configuration is needed.
    </Message>
4. Enter a name for your container and configure its resources.
5. Click **Advanced options** and configure secrets. Set `OPENAI_API_BASE_URL` and `OPENAI_API_KEY` with your specific values.
6. Click **Deploy container** to launch deployment. Once deployed, note the provided endpoint to access Open WebUI.

   <Message type="note">
     Since the Open WebUI default image is around 5 GB, deployment can take a couple of minutes before being ready.
   </Message>

### Deploy via the Scaleway CLI

1. Scaleway Serverless Containers are deployed inside a **namespace**. Run the following command to create a namespace:

    ```bash
    scw container namespace create name=openwebui-ns region=fr-par
    ```
  
2. Run the following command to retrieve the namespace ID:

    ```bash
    scw container namespace list
    ```

3. Run the following command to create the Serverless Container with your **Docker image and secret injection**. Remember to replace the placeholders with your actual values.

    ```bash
    $ scw container container create name=open-webui \
        namespace-id=<YOUR_NAMESPACE_ID> \
        registry-image="ghcr.io/open-webui/open-webui:0.5.10" \
        environment-variables.OPENAI_API_BASE_URL="https://api.scaleway.ai/<YOUR_PROJECT_ID>/v1" \
        secret-environment-variables.0.key="OPENAI_API_KEY" \
        secret-environment-variables.0.value="<YOUR_SECRET_KEY>" \
        region=fr-par \
        cpu-limit=1000 \
        memory-limit=4000 \
        local-storage-limit=10000 \
        timeout=600s
    ```

   <Message type="tip">
     This snippet deploys Open WebUI version `0.5.10`. To use the latest version, replace `open-webui:0.5.10` with `open-webui:main`. Note that storage and memory requirements often increase in newer versions, as new features or built-in models may be included in the Open WebUI container image. In this case, if the container is in an `Error` state, we recommend increasing `cpu-limit`, `memory-limit`, or `local-storage-limit` values to recommended Open WebUI values.
   </Message>

  For more information, refer to Scaleway's [Serverless Containers documentation](/serverless-containers/).