You can run the Multilogin launcher in a Docker container when you need a headless environment for browser automation.

➡️ Create the Docker Compose file below → start the container → check that the launcher is healthy → send the quick-profile request using your automation token.

For this setup, use an automation token. Don’t use a refresh token to authorize launcher requests. Refresh tokens are only used to get new regular API tokens.

Before you start

Make sure you have:

• Docker Desktop or Docker Engine installed and running
• A Multilogin automation token
• Ports 45001 and 45003 available

If the Multilogin desktop app or agent is running on the same computer, close it before starting the container. It normally uses port 45001, which prevents Docker from binding the same port.

Create the Docker Compose file

1. Create a folder for your Docker files in any directory
2. Open a text editor and paste this text:
   

   docker-compose.yaml

   services:
       launcher:
         image: public.ecr.aws/d3n0b1o9/mlx-launcher:mlx-latest
         ports:
           - "45001:45001"   # HTTPS REST API
           - "45003:45003"   # WSS
         restart: unless-stopped

    

    
3. Save it as docker-compose.yaml inside the folder from Step 1

Start the container

1. Open Terminal or Command prompt (depending on your OS)
2. Download the Docker image. It includes a modified Ubuntu setup with Multilogin launcher preinstalled: 
   docker pull public.ecr.aws/d3n0b1o9/mlx-launcher:mlx-latest
3. Go to the folder with your docker-compose.yaml file using the cd command
   

   Let's say you made a folder called “container” in your user folder. Terminal sets the user folder as the default one. In this case, run:

   cd container

    
4. Type the following command to create a container: docker compose up -d

The command will create a network called %your folder%_default and a container %your folder%-launcher-1. Copy the container name, as you will need to execute it.

Open the container terminal

To open the container terminal, run:

docker exec -it %container name% bash

If it works, you’ll see the container terminal. You’re inside the container now. In the next sections, you’ll run a few test API commands.

Check if the launcher is running

To send API requests from inside the container, you’ll use cURL. Use the command below to make sure the launcher is working:

curl -sS https://launcher.mlx.yt:45001/api/v1/version

If you see that the launcher is running, you’ll see a response with code 200: 

{"data":{"env":"Multilogin EU","version":"master"},"status":{"error_code":"","http_code":200,"message":""}}

The next sections show how to start and stop profiles. For more API requests, check the Multilogin API documentation.

Get your API token

To run the API requests, you need a bearer token. To get the bearer token, run the POST User Sign In request with cURL.

1. Visit MD5 Hash Generator and convert your Multilogin account password
2. Edit the command below by putting your Multilogin email and password (converted from Step 1) there:
   

   cURL command with User Sign In request

   curl --location 'https://api.multilogin.com/user/signin' \
   --header 'Content-Type: application/json' \
   --header 'Accept: application/json' \
   --data-raw '{
    "email": "your email",
    "password": "your password in MD5"
   }'

    

    

3. Copy and paste the cURL request into the terminal.

You will get the following response:

{"status":{"error_code":"","http_code":200,"message":"Successful signin"},"data":{"refresh_token":"YOUR BEARER TOKEN"}}

Copy the value of the refresh_token. You’ll need it for the next requests.

Start a quick profile

To see if the profiles can run inside the container, try using the POST Start Quick Profile v3 request. You’ll need to add an authorization header with your bearer token. You can use the reference below. You can change the profile parameters if needed. Don't forget to put your bearer token (replace YOUR_TOKEN with your bearer token):

curl --location 'https://launcher.mlx.yt:45001/api/v3/profile/quick' \
--header 'Authorization: YOUR_TOKEN' \
--header 'Content-Type: application/json' \
--header 'Accept: application/json' \
--data '{
  "browser_type": "mimic",
  "os_type": "macos",
  "parameters": {
    "flags": {
      "navigator_masking": "mask",
      "audio_masking": "mask",
      "localization_masking": "mask",
      "geolocation_popup": "prompt",
      "geolocation_masking": "mask",
      "timezone_masking": "mask",
      "canvas_noise": "natural",
      "graphics_noise": "natural",
      "graphics_masking": "mask",
      "webrtc_masking": "natural",
      "fonts_masking": "mask",
      "media_devices_masking": "mask",
      "screen_masking": "mask",
      "proxy_masking": "custom",
      "ports_masking": "mask"
    }
  }
}'

A successful response looks like this:

{"data":{"browser_type":"mimic","core_version":148,"id":"PROFILE_ID","is_quick":true},"status":{"error_code":"","http_code":200,"message":"Quick profile started successfully"}}

Copy the profile ID. You’ll need it to stop the profile.

Stop the profile

Now stop the profile using the GET Stop Browser Profile request. Change PROFILE_ID and YOUR_TOKEN values:

curl --location 'https://launcher.mlx.yt:45001/api/v1/profile/stop/p/PROFILE_ID' \
--header 'Authorization: YOUR_TOKEN' \
--header 'Accept: application/json'

The profile should stop after the request.

How to use your own cURL commands

You can use any requests from the Multilogin API documentation, but you will need to adjust them for cURL. First, copy a request:

1. Go to the Multilogin API documentation
2. Expand the folder in the library dashboard
3. Choose the endpoint you want to use
4. Set the request example language to cURL
5. Click “Copy”

Then edit the request:

1. Add the authentication header under the first line: --header 'Authorization: YOUR_TOKEN' \
2. Change the parameter values.

After that, copy the command and paste it into the terminal inside your container.

Extra tips

• Docker image in the article is a modified Ubuntu setup. If you want to install additional tools (for example, Python script support), run the following command to execute the container as a super user: docker exec -it -u 0 %container name% bash
• If you need to stop the container without removing it, type this command: docker stop %container name%
• If you need to start an inactive container, type this command: docker start %container name%

Troubleshooting

no matching manifest for linux/arm64/v8

The Launcher image is built for AMD64. Make sure the service includes:

platform: linux/amd64

bind: address already in use

Another process is already using port 45001 or 45003.

Close the Multilogin desktop app or agent, then run:

docker compose up -d

401 – Authorization error

Make sure you’re using a workspace automation token. Don’t use:

• A refresh token
• An expired regular API token
• A token from another workspace

Generate a new token using Workspace Automation Token.

BROWSER_VERSION_NOT_FOUND

The Mimic browser core may still be downloading. Check “Loaded Browser Cores” and retry after a Mimic version appears.

The start request returns 200, but the profile isn’t running

Check /api/v1/profile/statuses.

For this Docker setup, make sure the request contains:

"is_headless": true

"proxy_masking": "disabled" when no proxy is supplied

The no-sandbox and disable-dev-shm-usage command parameters

x509: certificate signed by unknown authority

Your company network may inspect HTTPS traffic using a private certificate authority.

Ask your IT administrator for the organization’s root CA, install it in the container’s trusted certificate store, and restart the container. Don’t disable TLS certificate verification as a permanent workaround.

FAQ

Can I use a regular API token?

Use a workspace automation token for this Docker workflow. Regular API tokens expire after 30 minutes and were not accepted by the tested Launcher profile endpoint.

Can I use a refresh token?

No. A refresh token cannot authorize normal API or Launcher requests. It is used only with “User Refresh Token (Switch Workspace)” to obtain new regular tokens.

Is the quick profile saved?

No. A quick profile is temporary. Its browsing data is removed after it stops.

Can I use a proxy?

Yes. Add a valid proxy object under parameters.proxy and set proxy_masking to custom. If you aren’t supplying a proxy, keep proxy_masking set to disabled.