Is there a way to bulk import VPN configs?

[regions99rockery]

I only see a way to import wireguard files one by one. i have a large folder from a VPN provider with different servers so it would be convenient to import the whole folder.

[zhom]

Hi there :) You can't bulk import vpn profile via the GUI, but you can do that via the API. It can be enabled in the "Integrations" dialog and will look something like this:

After that, you can ask the AI to create a script in your preferred programming language to do what you need. Here is a shell script that would bulk import vpn configs and create a profile for each of them:

#!/usr/bin/env bash
#
# Bulk-import WireGuard .conf files and create one Donut Browser profile per VPN.
#
# Imports every *.conf in the given directory via /v1/vpns/import, creates a
# matching profile via /v1/profiles with the freshly created vpn_id assigned,
# and (optionally) puts all created profiles into a shared group.
#
# Requirements: bash, curl, jq.
#
# Usage:
#   DONUT_API_TOKEN=xxx ./bulk_import_vpn.sh /path/to/configs/
#
# Required:
#   DONUT_API_TOKEN     Your Donut Browser API token (Integrations dialog).
#
# Optional environment variables:
#   DONUT_API_BASE      API base URL.    Default: http://127.0.0.1:10109
#   BROWSER             wayfern|camoufox Default: wayfern
#   BROWSER_VERSION     Browser version. Default: 146.0.7680.166
#                       (Must already be downloaded — check the Browsers UI.)
#   GROUP_NAME          If set, all created profiles are placed in this group
#                       (the group is created if it doesn't exist).
#

set -euo pipefail

# ---- Argument & environment validation ---------------------------------------

if [[ $# -lt 1 ]]; then
  echo "usage: DONUT_API_TOKEN=xxx $0 <path-to-conf-directory>" >&2
  exit 2
fi

CONF_DIR="$1"
: "${DONUT_API_TOKEN:?DONUT_API_TOKEN must be set}"
API_BASE="${DONUT_API_BASE:-http://127.0.0.1:10109}"
BROWSER="${BROWSER:-wayfern}"
BROWSER_VERSION="${BROWSER_VERSION:-146.0.7680.166}"
GROUP_NAME="${GROUP_NAME:-}"

if [[ ! -d "$CONF_DIR" ]]; then
  echo "error: '$CONF_DIR' is not a directory" >&2
  exit 1
fi

for tool in curl jq; do
  if ! command -v "$tool" >/dev/null 2>&1; then
    echo "error: '$tool' is required but not installed" >&2
    exit 1
  fi
done

# ---- Helpers -----------------------------------------------------------------

# Wrap curl with auth + JSON content type. Prints raw response body on stdout
# and exits non-zero if the HTTP status is >= 400.
api() {
  local method="$1"; shift
  local path="$1"; shift
  local body="${1:-}"
  local out http_code
  out="$(mktemp)"
  if [[ -n "$body" ]]; then
    http_code=$(curl -s -o "$out" -w '%{http_code}' \
      -X "$method" \
      -H "Authorization: Bearer $DONUT_API_TOKEN" \
      -H "Content-Type: application/json" \
      -d "$body" \
      "$API_BASE$path")
  else
    http_code=$(curl -s -o "$out" -w '%{http_code}' \
      -X "$method" \
      -H "Authorization: Bearer $DONUT_API_TOKEN" \
      "$API_BASE$path")
  fi
  cat "$out"
  rm -f "$out"
  if [[ "$http_code" -ge 400 ]]; then
    echo >&2
    echo "  ! $method $path returned HTTP $http_code" >&2
    return 1
  fi
}

# ---- Optional: resolve / create the target group -----------------------------

GROUP_ID=""
if [[ -n "$GROUP_NAME" ]]; then
  # Look up an existing group by name first; only create if not found, to keep
  # re-runs of this script idempotent.
  GROUP_ID=$(api GET /v1/groups | jq -r --arg n "$GROUP_NAME" \
    '.[] | select(.name == $n) | .id' | head -n1)
  if [[ -z "$GROUP_ID" ]]; then
    echo "Creating group: $GROUP_NAME"
    GROUP_ID=$(api POST /v1/groups "$(jq -n --arg n "$GROUP_NAME" '{name:$n}')" \
      | jq -r '.id')
  fi
  echo "Using group: $GROUP_NAME ($GROUP_ID)"
fi

# ---- Main loop: import each .conf, then create a profile ---------------------

shopt -s nullglob
mapfile -t conf_files < <(find "$CONF_DIR" -maxdepth 1 -type f -name '*.conf' | sort)

if [[ ${#conf_files[@]} -eq 0 ]]; then
  echo "no *.conf files found in $CONF_DIR" >&2
  exit 1
fi

echo "Found ${#conf_files[@]} config(s) in $CONF_DIR"

imported=0
failed=0

for conf in "${conf_files[@]}"; do
  filename="$(basename "$conf")"
  # Strip the .conf suffix for the display name; the user can rename later.
  name="${filename%.conf}"

  echo
  echo "→ $filename"

  # Build the import payload. jq's --rawfile reads the file as a single string
  # and handles JSON escaping for us (newlines, quotes, etc.) — much safer
  # than hand-rolling shell escapes.
  import_payload=$(jq -n \
    --arg filename "$filename" \
    --arg name "$name" \
    --rawfile content "$conf" \
    '{filename:$filename, name:$name, content:$content}')

  if ! vpn_resp=$(api POST /v1/vpns/import "$import_payload"); then
    echo "  ! import failed, skipping" >&2
    failed=$((failed + 1))
    continue
  fi
  vpn_id=$(echo "$vpn_resp" | jq -r '.id')
  echo "  imported vpn  $vpn_id"

  # Build the profile payload, optionally attaching the group.
  profile_payload=$(jq -n \
    --arg name "$name" \
    --arg browser "$BROWSER" \
    --arg version "$BROWSER_VERSION" \
    --arg vpn_id "$vpn_id" \
    --arg group_id "$GROUP_ID" \
    '{name:$name, browser:$browser, version:$version, vpn_id:$vpn_id}
     + (if $group_id == "" then {} else {group_id:$group_id} end)')

  if ! profile_resp=$(api POST /v1/profiles "$profile_payload"); then
    echo "  ! profile create failed (vpn $vpn_id was still imported)" >&2
    failed=$((failed + 1))
    continue
  fi
  profile_id=$(echo "$profile_resp" | jq -r '.profile.id')
  echo "  created profile $profile_id"
  imported=$((imported + 1))
done

echo
echo "Done. $imported imported, $failed failed."
[[ "$failed" -eq 0 ]]

[zhom]

Hi there :) Closing due to inactivity. Feel free to reopen the discussion if there is more to it!