> ## Documentation Index
> Fetch the complete documentation index at: https://apidoc.cometapi.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Bruk OpenClaw med CometAPI
> Bruk denne veiledningen til å konfigurere OpenClaw med CometAPI gjennom Chat Completions, Responses, Anthropic Messages eller Google Generative AI.
Bruk denne veiledningen til å koble [OpenClaw](https://openclaw.ai) til CometAPI. Velg
ett API-format og én modell-ID for den første konfigurasjonen.
OpenClaw v2026.8.1 har også merkenavnet OpenClaw 2.0. Pakken bruker ikke et
`2.x` versjonsnummer. Se
[kunngjøringen om OpenClaw 2.0](https://openclaw.ai/blog/openclaw-2-accidentally)
og [versjonsmerknadene for v2026.8.1](https://docs.openclaw.ai/releases/2026.8.1).
Offisielle OpenClaw-referanser:
* [Installasjon](https://docs.openclaw.ai/install)
* [Oppdatering](https://docs.openclaw.ai/install/updating)
* [Onboarding](https://docs.openclaw.ai/start/onboarding-overview)
* [Egendefinert leverandørkonfigurasjon](https://docs.openclaw.ai/gateway/config-tools)
* [Miljøvariabler og SecretRef](https://docs.openclaw.ai/help/environment)
## Forutsetninger
* Node.js 22.22.3+, 24.15+ eller 25.9+. Node 26 anbefales. Node 23 støttes ikke
.
* En CometAPI-konto med en aktiv API-nøkkel fra
[dashbordet](https://www.cometapi.com/console/token).
* En modell-ID fra [CometAPI Models-siden](/no/overview/models).
## Installasjon og oppgraderinger
Det offisielle installasjonsprogrammet kan installere CLI uten å starte onboarding.
Dette holder modellkonfigurasjonen som et separat trinn.
Følgende kommando kjører det offisielle installasjonsprogrammet:
```bash theme={null}
curl -fsSL https://openclaw.ai/install.sh \
| bash -s -- --no-onboard
```
Følgende kommando kjører det offisielle PowerShell-installasjonsprogrammet:
```powershell theme={null}
& ([scriptblock]::Create(
(iwr -useb https://openclaw.ai/install.ps1)
)) -NoOnboard
```
Hvis du selv administrerer Node.js og npm, godtar npm 11.16+ og npm 12
`--allow-scripts` alternativet. Følgende kommando installerer OpenClaw uten å
starte onboarding:
```bash theme={null}
npm install -g openclaw@latest --allow-scripts=openclaw
```
På npm 11.15 og tidligere må du utelate `--allow-scripts=openclaw`, fordi den npm-versjonen
ikke gjenkjenner alternativet.
Kontroller at den installerte CLI-en oppfyller minimumsversjonen for denne veiledningen:
```bash theme={null}
openclaw --version
```
Fortsett til [Konfigurer CometAPI](#configure-cometapi). Ikke kjør vanlig
onboarding først, fordi den veiledede flyten ikke viser alle egendefinerte API-
adaptere.
Opprett og verifiser en sikkerhetskopi før en betydelig oppdatering. Arkivet kan
inneholde API-nøkler, kanaltilstand og autentiseringsdata, så beskytt det på samme måte som
du beskytter OpenClaw-tilstandskatalogen.
Følgende kommandoer oppretter sikkerhetskopien og oppdaterer OpenClaw:
```bash theme={null}
mkdir -p ~/Backups/openclaw
openclaw backup create --output ~/Backups/openclaw --verify
openclaw update
```
Etter oppdateringen reparerer du støttede migreringer og kontrollerer Gateway-tilstanden:
```bash theme={null}
openclaw doctor --fix
openclaw gateway restart
openclaw health
```
En oppdatering beholder den konfigurerte modellruten. Ikke gjenta onboarding
med mindre du vil endre modellleverandøren eller autentiseringen dens.
## Konfigurer CometAPI
### Bruk klassisk oppsett
Klassisk oppsett er den foretrukne banen for førstegangsinstallasjon for Chat
Completions, Responses og Anthropic Messages.
Følgende kommando åpner klassisk oppsett og installerer bakgrunns
tjenesten:
```bash theme={null}
openclaw onboard --classic --install-daemon
```
I **Model/Auth**, velger du **Custom Provider**. Angi deretter verdiene for ett av
disse kompatibilitetsalternativene:
| API-format | Leverandør-ID | Kompatibilitetsalternativ | Basis-URL |
| ------------------ | --------------------------- | ------------------------------- | ----------------------------- |
| Chat Completions | `cometapi-openai` | **OpenAI-kompatibel** | `https://api.cometapi.com/v1` |
| Responses | `cometapi-openai-responses` | **OpenAI Responses-kompatibel** | `https://api.cometapi.com/v1` |
| Anthropic Messages | `cometapi-claude` | **Anthropic-kompatibel** | `https://api.cometapi.com` |
Angi samsvarende leverandør-ID, `your-model-id`, og CometAPI API-nøkkelen når
du blir bedt om det. Terminalveiviseren maskerer inndata for API-nøkkelen.
Menyen Custom Provider i klassisk oppsett inkluderer ikke Google Generative AI-
adapteren. Hvis du vil bruke den adapteren, fullfører du
[Konfigurer en leverandør med config-kommandoer](#configure-a-provider-with-config-commands),
, angir primærmodellen og kjører deretter klassisk oppsett. Velg **Behold eksisterende
modellkonfigurasjon** når veiviseren viser dette alternativet.
### Konfigurer en leverandør med config-kommandoer
Bruk denne fremgangsmåten for Google-adapteren eller for kontrollerte konfigurasjonsendringer.
OpenClaw støtter JSON5, så ikke analyser og skriv `openclaw.json` på nytt med et
strengt JSON-verktøy.
OpenClaws innebygde config-skriver validerer JSON5, men normaliserer filen til
JSON når den skriver. Eksisterende kommentarer, avsluttende kommaer og formatering kan
bli fjernet. Opprett en verifisert sikkerhetskopi før du bruker en patch hvis disse detaljene
er viktige for deg.
Skriv først ut banen til den aktive konfigurasjonen, og valider innholdet:
```bash theme={null}
openclaw config file
openclaw config validate
```
OpenClaw leser leverandørens API-nøkler fra prosessmiljøet eller den globale
statusfilen `.env`. Den stoler ikke på en `.env`-fil i arbeidsområdet for leverandørens API-
nøkler. Den globale filen er `~/.openclaw/.env`, eller
`$OPENCLAW_STATE_DIR/.env` når `OPENCLAW_STATE_DIR` er angitt.
Hvis klassisk oppsett lagret API-nøkkelen, kan du hoppe over neste trinn. Ellers
bruker du fanen for operativsystemet ditt til å lagre API-nøkkelen uten å vise
den.
Følgende kommandoer oppdaterer `COMETAPI_KEY` atomisk og avviser en tom
verdi:
```bash theme={null}
state_dir="${OPENCLAW_STATE_DIR:-$HOME/.openclaw}"
install -d -m 700 "$state_dir"
read -rsp "CometAPI API key: " COMETAPI_KEY
printf '\n'
if [ -z "$COMETAPI_KEY" ]; then
echo "The CometAPI API key cannot be empty." >&2
unset COMETAPI_KEY
exit 1
fi
umask 077
env_file="$state_dir/.env"
temp_file="$(mktemp "${env_file}.XXXXXX")"
if [ -f "$env_file" ]; then
awk -F= '$1 != "COMETAPI_KEY"' "$env_file" > "$temp_file"
fi
printf 'COMETAPI_KEY=%s\n' "$COMETAPI_KEY" >> "$temp_file"
chmod 600 "$temp_file"
mv "$temp_file" "$env_file"
unset COMETAPI_KEY temp_file env_file state_dir
```
Følgende kommandoer oppdaterer `COMETAPI_KEY` uten å vise den:
```powershell theme={null}
$stateDir = if ($env:OPENCLAW_STATE_DIR) {
$env:OPENCLAW_STATE_DIR
} else {
Join-Path $HOME ".openclaw"
}
New-Item -ItemType Directory -Force -Path $stateDir | Out-Null
$secureKey = Read-Host "CometAPI API key" -AsSecureString
$plainKey = [Net.NetworkCredential]::new("", $secureKey).Password
if ([string]::IsNullOrWhiteSpace($plainKey)) {
throw "The CometAPI API key cannot be empty."
}
$envFile = Join-Path $stateDir ".env"
$lines = @()
if (Test-Path $envFile) {
$lines = @(Get-Content $envFile | Where-Object {
$_ -notmatch '^COMETAPI_KEY='
})
}
$lines += "COMETAPI_KEY=$plainKey"
$tempFile = Join-Path $stateDir ".$([guid]::NewGuid()).tmp"
[IO.File]::WriteAllLines($tempFile, $lines)
Move-Item -Force $tempFile $envFile
$plainKey = $null
$secureKey = $null
```
Før du legger til en leverandør, må du undersøke målbanen. Erstatt leverandør-ID-en i
følgende kommando med ID-en fra den valgte fanen:
```bash theme={null}
openclaw config get models.providers.cometapi-openai --json
```
Hvis kommandoen returnerer en konfigurert leverandør, stopper du før du bruker eksempelet.
`config patch` slår sammen objekter, men erstatter matriser. Slå sammen den nye modellen i
leverandørens modellmatrise før du skriver matrisen. Dette bevarer modell
metadata, egendefinerte headere og andre leverandørinnstillinger.
Velg ett API-format. Hver patch bruker en miljøstøttet SecretRef, endrer
bare målkonfigurasjonsbanene og beholder andre konfigurasjonsseksjoner intakte.
En modell-ID er ikke automatisk kompatibel med alle API-adaptere. Velg en
adapter som den nøyaktige CometAPI-modellen og ruten støtter, og verifiser deretter den
kombinasjonen av leverandør/modell/adapter med en direkte forespørsel. Verdien
`your-model-id` nedenfor er en konfigurasjonsplassholder, ikke en universell
påstand om kompatibilitet.
* Leverandør-ID: `cometapi-openai`
* OpenClaw-adapter: `openai-completions`
* Basis-URL: `https://api.cometapi.com/v1`
* Referanse til primærmodell: `cometapi-openai/your-model-id`
Opprett `cometapi.patch.json5` med denne leverandør-patchen:
```json5 theme={null}
{
models: {
mode: "merge",
providers: {
"cometapi-openai": {
baseUrl: "https://api.cometapi.com/v1",
apiKey: {
source: "env",
provider: "default",
id: "COMETAPI_KEY",
},
api: "openai-completions",
models: [
{
id: "your-model-id",
name: "CometAPI model",
input: ["text"],
},
],
},
},
},
}
```
Valider patchen før OpenClaw skriver konfigurasjonen:
```bash theme={null}
openclaw config patch --file ./cometapi.patch.json5 --dry-run
```
Hvis valideringen lykkes, bruker du den samme patchen:
```bash theme={null}
openclaw config patch --file ./cometapi.patch.json5
```
Hvis ingen primærmodell er konfigurert, angir du denne modellen som standard:
```bash theme={null}
openclaw models set cometapi-openai/your-model-id
```
Verifiser leverandørkonfigurasjonen og send en minimal modellforespørsel:
```bash theme={null}
openclaw models list --provider cometapi-openai
openclaw models status --probe \
--probe-provider cometapi-openai
openclaw agent exec \
"Reply exactly with: OPENCLAW_OK" \
--model cometapi-openai/your-model-id \
--thinking off \
--json
```
For å bytte den aktive OpenClaw-chatøkten kjører du denne chat-kommandoen:
```text theme={null}
/model cometapi-openai/your-model-id
```
* Leverandør-ID: `cometapi-openai-responses`
* OpenClaw-adapter: `openai-responses`
* Basis-URL: `https://api.cometapi.com/v1`
* Referanse til primærmodell: `cometapi-openai-responses/your-model-id`
Opprett `cometapi.patch.json5` med denne leverandør-patchen:
```json5 theme={null}
{
models: {
mode: "merge",
providers: {
"cometapi-openai-responses": {
baseUrl: "https://api.cometapi.com/v1",
apiKey: {
source: "env",
provider: "default",
id: "COMETAPI_KEY",
},
api: "openai-responses",
models: [
{
id: "your-model-id",
name: "CometAPI model",
input: ["text"],
},
],
},
},
},
}
```
Valider patchen før OpenClaw skriver konfigurasjonen:
```bash theme={null}
openclaw config patch --file ./cometapi.patch.json5 --dry-run
```
Hvis valideringen lykkes, bruker du den samme patchen:
```bash theme={null}
openclaw config patch --file ./cometapi.patch.json5
```
Hvis ingen primærmodell er konfigurert, angir du denne modellen som standard:
```bash theme={null}
openclaw models set cometapi-openai-responses/your-model-id
```
Verifiser leverandørkonfigurasjonen og send en minimal modellforespørsel:
```bash theme={null}
openclaw models list --provider cometapi-openai-responses
openclaw models status --probe \
--probe-provider cometapi-openai-responses
openclaw agent exec \
"Reply exactly with: OPENCLAW_OK" \
--model cometapi-openai-responses/your-model-id \
--thinking off \
--json
```
For å bytte den aktive OpenClaw-chatøkten kjører du denne chat-kommandoen:
```text theme={null}
/model cometapi-openai-responses/your-model-id
```
* Leverandør-ID: `cometapi-claude`
* OpenClaw-adapter: `anthropic-messages`
* Basis-URL: `https://api.cometapi.com`
* Referanse til primærmodell: `cometapi-claude/your-model-id`
Opprett `cometapi.patch.json5` med denne leverandør-patchen:
```json5 theme={null}
{
models: {
mode: "merge",
providers: {
"cometapi-claude": {
baseUrl: "https://api.cometapi.com",
apiKey: {
source: "env",
provider: "default",
id: "COMETAPI_KEY",
},
api: "anthropic-messages",
models: [
{
id: "your-model-id",
name: "CometAPI model",
input: ["text"],
},
],
},
},
},
}
```
Valider patchen før OpenClaw skriver konfigurasjonen:
```bash theme={null}
openclaw config patch --file ./cometapi.patch.json5 --dry-run
```
Hvis valideringen lykkes, bruker du den samme patchen:
```bash theme={null}
openclaw config patch --file ./cometapi.patch.json5
```
Hvis ingen primærmodell er konfigurert, angir du denne modellen som standard:
```bash theme={null}
openclaw models set cometapi-claude/your-model-id
```
Verifiser leverandørkonfigurasjonen og send en minimal modellforespørsel:
```bash theme={null}
openclaw models list --provider cometapi-claude
openclaw models status --probe \
--probe-provider cometapi-claude
openclaw agent exec \
"Reply exactly with: OPENCLAW_OK" \
--model cometapi-claude/your-model-id \
--thinking off \
--json
```
For å bytte den aktive OpenClaw-chatøkten kjører du denne chat-kommandoen:
```text theme={null}
/model cometapi-claude/your-model-id
```
* Leverandør-ID: `cometapi-google`
* OpenClaw-adapter: `google-generative-ai`
* Basis-URL: `https://api.cometapi.com/v1beta`
* Referanse til primærmodell: `cometapi-google/your-model-id`
Opprett `cometapi.patch.json5` med denne leverandør-patchen:
```json5 theme={null}
{
models: {
mode: "merge",
providers: {
"cometapi-google": {
baseUrl: "https://api.cometapi.com/v1beta",
apiKey: {
source: "env",
provider: "default",
id: "COMETAPI_KEY",
},
api: "google-generative-ai",
models: [
{
id: "your-model-id",
name: "CometAPI model",
input: ["text"],
},
],
},
},
},
}
```
Valider patchen før OpenClaw skriver konfigurasjonen:
```bash theme={null}
openclaw config patch --file ./cometapi.patch.json5 --dry-run
```
Hvis valideringen lykkes, bruker du den samme patchen:
```bash theme={null}
openclaw config patch --file ./cometapi.patch.json5
```
Hvis ingen primærmodell er konfigurert, angir du denne modellen som standard:
```bash theme={null}
openclaw models set cometapi-google/your-model-id
```
Verifiser leverandørkonfigurasjonen og send en minimal modellforespørsel:
```bash theme={null}
openclaw models list --provider cometapi-google
openclaw models status --probe \
--probe-provider cometapi-google
openclaw agent exec \
"Reply exactly with: OPENCLAW_OK" \
--model cometapi-google/your-model-id \
--thinking off \
--json
```
For å bytte den aktive OpenClaw-chatøkten kjører du denne chat-kommandoen:
```text theme={null}
/model cometapi-google/your-model-id
```
Hvis en konfigurasjon allerede bruker leverandør-ID-en `cometapi-gemini`, beholder du
den ID-en og bruker den i modellreferanser og kommandoer. Ikke gi den nytt navn eller
opprett en duplikatleverandør bare for å samsvare med denne veiledningen.
For en ny leverandør gir `openclaw config set` det samme skjemaet og de samme
SecretRef-kontrollene. Bruk `--strict-json`, `--merge` og `--dry-run` før
skrivingen. Følgende alternativ forhåndsviser Chat Completions-leverandøren:
```bash theme={null}
openclaw config set models.providers.cometapi-openai \
'{
"baseUrl": "https://api.cometapi.com/v1",
"apiKey": {
"source": "env",
"provider": "default",
"id": "COMETAPI_KEY"
},
"api": "openai-completions",
"models": [
{
"id": "your-model-id",
"name": "CometAPI model",
"input": ["text"]
}
]
}' \
--strict-json --merge --dry-run
```
Hvis tørrkjøringen lykkes, gjentar du kommandoen uten `--dry-run` for å lagre den. Ikke
bruk dette eksempelet på en konfigurert leverandør. Matrisen `models` må inneholde
leverandørens fullstendige sammenslåtte modelliste før en skriving.
### Forstå modellmetadata
De minimale patchene deklarerer en modell som bare bruker tekst. Legg bare til valgfri metadata når
du har verifisert modellens spesifikasjoner:
| Felt | Effekt |
| --------------- | ---------------------------------------------------------------------------------------------------------------- |
| `input` | Deklarerer godtatte inndatamodaliteter. Bruk `["text", "image"]` bare når modellen godtar innebygd bildeinndata. |
| `contextWindow` | Registrerer modellens opprinnelige Context Window-kapasitet. |
| `contextTokens` | Begrenser det aktive inndatabudsjettet uten å endre `contextWindow`. |
| `maxTokens` | Begrenser output Tokens som OpenClaw ber om fra modellen. |
Feil verdier kan skjule støttede inndata, overvurdere den brukbare konteksten eller
be om en output-størrelse som ikke støttes. Behold `your-model-id` i gjenbrukbare eksempler,
og bruk [CometAPI Models-siden](/no/overview/models) til å velge en modell-ID.
## Verifiser hele oppsettet
Etter endringer i konfigurasjonsfilen eller den globale `.env`-filen, start Gateway på nytt:
```bash theme={null}
openclaw gateway restart
```
Valider deretter konfigurasjonen og Gateway-statusen:
```bash theme={null}
openclaw config validate
openclaw doctor
openclaw health
```
Kjør de leverandørspesifikke kommandoene fra fanen for valgt API-format. En modell
liste eller statuskontroll bekrefter bare konfigurasjonen. Kommandoen `openclaw agent exec`
sender en faktisk modellforespørsel. Bekreft at den returnerer `OPENCLAW_OK`
uten en uavklart autentiserings-, adapter- eller modellfeil. Hvis OpenClaw
prøver en forespørsel på nytt, registrer og undersøk hvert forsøk i stedet for å behandle den
endelige markøren som suksess på ett enkelt forsøk.
## Feilsøking
Bekreft at `COMETAPI_KEY` finnes i prosessmiljøet eller i den
globale tilstandsfilen `.env`. Ikke skriv ut verdien i terminalutdata.
Når du har korrigert den pålitelige nøkkelkilden, start Gateway på nytt og kontroller den:
```bash theme={null}
openclaw gateway restart
openclaw health
```
Ikke overskriv en leverandør med avvikende `baseUrl`, `api`, egendefinerte
overskrifter eller modellmetadata. Undersøk mål-leverandøren først:
```bash theme={null}
openclaw config get models.providers.cometapi-openai --json
openclaw config validate
```
Bruk en annen leverandør-ID når begge konfigurasjonene er tilsiktede. Hvis
forskjellen er utilsiktet, opprett en verifisert sikkerhetskopi før du endrer
mål-leverandøren.
Undersøk oppdateringsstatusen før du reparerer installasjonen:
```bash theme={null}
openclaw update status --json
openclaw update repair
openclaw doctor --fix
openclaw health
```
Disse kommandoene bevarer tilstandskatalogen.
Installer en kjent pakkeversjon på nytt mens du beholder tilstandskatalogen. Først
forhåndsviser du operasjonen:
```bash theme={null}
openclaw update --tag 2026.8.1 --dry-run
```
Hvis forhåndsvisningen er riktig, kjør samme operasjon uten `--dry-run`:
```bash theme={null}
openclaw update --tag 2026.8.1
openclaw doctor --fix
openclaw health
```
Gjenopprett en sikkerhetskopi av tilstanden bare når den installerte koden ikke kan lese tilstanden.
En gjenoppretting av tilstanden kan forkaste økter og konfigurasjonsendringer som ble
opprettet etter sikkerhetskopien.