Mestring av Linux-kommandolinjen og Bash-skripting · leksjon

Bruk av REST-API-er med curl og jq sammen

Koble curl-forespørsler sammen med jq for å hente ut, paginere og formatere API-svar i skript.

Leksjon 3 av 413 trinn

Bruk av REST-API-er med curl og jq sammen er en gratis leksjon i Mestring av Linux-kommandolinjen og Bash-skripting på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Mestring av Linux-kommandolinjen og Bash-skripting, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Mestring av Linux-kommandolinjen og Bash-skripting inneholder totalt 4 leksjoner.

Hvorfor curl + jq er den kraftfulle kombinasjonen

REST-API-er returnerer JSON. curl henter råsvaret, mens jq deler det opp, filtrerer det og omformer det – alt i én enkelt pipeline. De trenger verken Python-skript, Postman eller en mellomliggende fil.

curl håndterer HTTP: metoder, headere, autentisering og omdirigeringer.
jq håndterer JSON: filtrering, mapping, omforming og formatering.
Når De kobler dem sammen med en pipe, får De konsise og kombinerbare API-arbeidsflyter.

Denne leksjonen bygger opp ferdigheten fra grunnen av, gjennom praktiske mønstre for paginering og skripting.

Grunnleggende curl-pipeline inn i jq

Det enkleste mønsteret er å sende utdata fra curl direkte inn i jq. Bruk -s (silent) for å skjule fremdriftsmåleren til curl, slik at bare JSON-innholdet når jq.

-s – stille modus, uten fremdriftslinje.
. – jq sitt identitetsfilter; skriver ut hele svaret med pen formatering.
-r i jq – rå utdata (uten omsluttende anførselstegn rundt strenger).

#!/usr/bin/env bash
# Fetch a public endpoint and pretty-print the JSON
curl -s 'https://jsonplaceholder.typicode.com/todos/1' | jq '.'

# Extract just the title field as a plain string
curl -s 'https://jsonplaceholder.typicode.com/todos/1' | jq -r '.title'

Angi forespørselshadere og send autentiseringstokener

De fleste API-er i produksjon krever en Authorization-header eller en API-nøkkel. Send headere med -H, og lagre hemmeligheter i miljøvariabler – aldri skriv dem direkte i koden.

-H 'Authorization: Bearer $TOKEN' – setter inn autentiseringsheaderen.
-H 'Accept: application/json' – ber uttrykkelig om JSON som svar.
Variabler utvides inne i doble anførselstegn; bruk " rundt header-strengen.

#!/usr/bin/env bash
TOKEN="${GITHUB_TOKEN}"   # set in your shell environment
USER="octocat"

curl -s \
  -H "Authorization: Bearer ${TOKEN}" \
  -H "Accept: application/vnd.github+json" \
  "https://api.github.com/users/${USER}" \
| jq '{login: .login, repos: .public_repos, followers: .followers}'

Filtrere arrayer – .[] og select()

API-er returnerer ofte arrayer. Bruk .[] for å iterere over hvert element, og deretter select() for å beholde bare elementer som oppfyller en betingelse.

.[] – deler en array opp i en strøm av objekter.
select(.field == value) – beholder bare objekter som samsvarer.
Lenk sammen flere filtre med |.

#!/usr/bin/env bash
# Fetch all todos and keep only the completed ones
curl -s 'https://jsonplaceholder.typicode.com/todos' \
| jq '[.[] | select(.completed == true) | {id, title}]'

# Count how many are completed
curl -s 'https://jsonplaceholder.typicode.com/todos' \
| jq '[.[] | select(.completed == true)] | length'

Hente ut flere felt med map()

map() bruker en transformasjon på hvert element i en matrise og returnerer en ny matrise — tilsvarende [.[] | ...], men mer lesbart.

map({key: .field}) — omstrukturerer hvert objekt.
Kombiner med @csv eller @tsv for å produsere tabellformaterte data.
Bruk -r med @csv/@tsv for å få rå tekst (uten JSON-sitering).

#!/usr/bin/env bash
# Reshape a posts list into id + title pairs
curl -s 'https://jsonplaceholder.typicode.com/posts' \
| jq 'map({id, title: .title[0:40]})'

# Output as CSV for import into a spreadsheet
curl -s 'https://jsonplaceholder.typicode.com/posts' \
| jq -r '.[] | [.id, .userId, .title] | @csv'

Pagineringsmønster — løkk til en tom side

De fleste API-er deler resultater inn i sider. Et vanlig mønster er en while-løkke som øker en sideteller og stopper når den returnerte matrisen er tom.

Ta vare på curl-svaret i en variabel med $(curl ...).
Bruk jq 'length' for å kontrollere om siden inneholder elementer.
Akkumuler resultater med jq -s (slurp), eller legg dem til i en fil.

#!/usr/bin/env bash
# Paginate through jsonplaceholder posts (simulated: page stops at page 2
# because the API returns the full list regardless of ?_page, but the
# pattern is correct for real paginated APIs)

PAGE=1
PER_PAGE=10
OUTPUT="all_posts.json"
echo '[]' > "$OUTPUT"

while true; do
  RESPONSE=$(curl -s "https://jsonplaceholder.typicode.com/posts?_page=${PAGE}&_limit=${PER_PAGE}")
  COUNT=$(echo "$RESPONSE" | jq 'length')

  if [ "$COUNT" -eq 0 ]; then
    echo "No more pages. Stopping at page $((PAGE - 1))."
    break
  fi

  # Merge new items into the accumulated JSON array
  CURRENT=$(cat "$OUTPUT")
  echo "$CURRENT" "$RESPONSE" | jq -s '.[0] + .[1]' > "$OUTPUT"
  echo "Page $PAGE: fetched $COUNT items."
  PAGE=$((PAGE + 1))
done

echo "Total collected: $(jq 'length' "$OUTPUT")"

Paginerering med Link-header (GitHub-stil)

GitHub og mange andre API-er bruker en Link-svarheader for å oppgi URL-en til neste side. Headeren må analyseres i stedet for at URL-en gjettes.

curl -i inkluderer svarheadere i stdout. Alternativt kan -D - brukes til å skrive headere til stdout.
Analyser Link: <url>; rel="next"-headeren med grep og sed.
Fortsett løkken til det ikke lenger finnes noen rel="next"-lenke.

#!/usr/bin/env bash
# Follow Link-header pagination (GitHub repos example)
# Requires GITHUB_TOKEN in environment
TOKEN="${GITHUB_TOKEN}"
NEXT_URL="https://api.github.com/users/torvalds/repos?per_page=5"
ALL_REPOS="[]"

while [ -n "$NEXT_URL" ]; do
  # Capture full response (headers + body) to a temp file
  TMPFILE=$(mktemp)
  curl -sD "$TMPFILE" \
    -H "Authorization: Bearer ${TOKEN}" \
    -H "Accept: application/vnd.github+json" \
    "$NEXT_URL" \
  | {
      BODY=$(cat)
      ALL_REPOS=$(echo "$ALL_REPOS" "$BODY" | jq -s '.[0] + .[1]')
      echo "$ALL_REPOS" > /tmp/repos_acc.json
    }

  # Extract next URL from Link header
  NEXT_URL=$(grep -i '^link:' "$TMPFILE" \
    | sed -E 's/.*<([^>]+)>; rel="next".*/\1/;t;d')
  rm -f "$TMPFILE"
done

echo "Total repos: $(jq 'length' /tmp/repos_acc.json)"

Kjede forespørsler — bruk resultatet fra ett kall som inndata til et annet

En vanlig arbeidsflyt er å hente en liste, trekke ut en ID og deretter hente detaljene for hver ID. Lagre mellomverdier med kommandosubstitusjon via $(), og send dem inn i den neste URL-en.

Trekk ut én enkelt verdi med jq -r '.field'.
Gå gjennom flere ID-er med jq -r '.[].id' i en while read-løkke.
Bruk sleep mellom forespørslene for å overholde hastighetsbegrensninger.

#!/usr/bin/env bash
# Step 1: get all user IDs from the /users endpoint
# Step 2: for each user, fetch their posts and count them

curl -s 'https://jsonplaceholder.typicode.com/users' \
| jq -r '.[].id' \
| while read -r USER_ID; do
    POST_COUNT=$(curl -s "https://jsonplaceholder.typicode.com/posts?userId=${USER_ID}" \
                 | jq 'length')
    echo "User ${USER_ID}: ${POST_COUNT} posts"
    sleep 0.1   # be polite to the API
done

POST-forespørsler — sende JSON-nyttelaster

For å opprette eller oppdatere ressurser sender du en POST- eller PUT-forespørsel med en JSON-body. Bruk -X POST, -H 'Content-Type: application/json' og -d for body-en. Bygg nyttelasten med jq -n for å unngå problemer med sitering.

jq -n --arg key value '{key: $key}' — trygg interpolering av variabler i jq.
Send den konstruerte JSON-en direkte videre til curl med -d @- (les body fra standard input).
Analyser svaret umiddelbart med et annet jq-filter.

#!/usr/bin/env bash
TITLE="My New Post"
BODY_TEXT="Written via curl and jq."
USER_ID=1

# Build the JSON payload safely and POST it
RESPONSE=$(jq -n \
  --arg title   "$TITLE" \
  --arg body    "$BODY_TEXT" \
  --argjson userId "$USER_ID" \
  '{title: $title, body: $body, userId: $userId}' \
| curl -s \
    -X POST \
    -H 'Content-Type: application/json' \
    -d @- \
    'https://jsonplaceholder.typicode.com/posts')

echo "Created post ID: $(echo "$RESPONSE" | jq '.id')"
echo "Full response:"
echo "$RESPONSE" | jq '.'

Feilhåndtering — HTTP-statuskoder og API-feil

En vellykket HTTP-tilkobling betyr ikke at API-kallet var vellykket. Kontroller HTTP-statuskoden og JSON-fe feltet separat.

curl -w '%{http_code}' legger statuskoden til stdout. Bruk -o for å skrive body-en til en fil.
Sammenlign koden i skriptet, og håndter 4xx/5xx på forskjellige måter.
Mange API-er legger inn {"error": "..."} i body-en — kontroller dette med jq-funksjonene has() eller type.

#!/usr/bin/env bash
API_URL='https://jsonplaceholder.typicode.com/todos/99999'
TMPBODY=$(mktemp)

HTTP_CODE=$(curl -s -o "$TMPBODY" -w '%{http_code}' "$API_URL")

if [ "$HTTP_CODE" -ge 200 ] && [ "$HTTP_CODE" -lt 300 ]; then
  echo "Success ($HTTP_CODE):"
  jq '.' "$TMPBODY"
elif [ "$HTTP_CODE" -eq 404 ]; then
  echo "Resource not found (404). Body:"
  jq '.' "$TMPBODY"
elif [ "$HTTP_CODE" -ge 500 ]; then
  echo "Server error ($HTTP_CODE). Retrying later."
else
  echo "Unexpected status: $HTTP_CODE"
  cat "$TMPBODY"
fi

rm -f "$TMPBODY"

Bygge en gjenbrukbar API-hjelpefunksjon

Pakk standardkoden for curl og feilsjekking inn i en shell-funksjon. Funksjonen håndterer autentisering, statussjekking og JSON-uttrekking — kallere trenger bare å oppgi endepunktet og et jq-filter.

Returner avslutningskoder som ikke er null ved HTTP-feil, slik at kallere kan bruke || eller set -e.
Ta imot et jq-filter som argument, slik at den samme funksjonen kan brukes for mange endepunkter.
Last inn denne funksjonsfilen fra alle skript som trenger API-et.

#!/usr/bin/env bash
# api_get <endpoint_path> <jq_filter>
# Returns filtered JSON or exits non-zero on error.
api_get() {
  local PATH_PART="$1"
  local JQ_FILTER="${2:-.}"
  local BASE_URL='https://jsonplaceholder.typicode.com'
  local TMPBODY
  TMPBODY=$(mktemp)

  local HTTP_CODE
  HTTP_CODE=$(curl -s \
    -o "$TMPBODY" \
    -w '%{http_code}' \
    "${BASE_URL}${PATH_PART}")

  if [ "$HTTP_CODE" -lt 200 ] || [ "$HTTP_CODE" -ge 300 ]; then
    echo "[ERROR] HTTP $HTTP_CODE for ${PATH_PART}" >&2
    rm -f "$TMPBODY"
    return 1
  fi

  jq -r "$JQ_FILTER" "$TMPBODY"
  rm -f "$TMPBODY"
}

# Usage examples
api_get '/todos/1' '.title'
api_get '/posts?userId=1' '[.[] | .title]'
api_get '/users' '.[] | "\(.id) \(.name) <\(.email)>"'

Kunnskapssjekk: pagineringsstrategi

Test forståelsen av hvordan paginerte REST API-svar håndteres i et Bash-skript ved hjelp av curl og jq.

Besvar den i den interaktive leksjonen

Oppsummering av leksjonen: curl + jq API-skripting

Du har nå et komplett verktøysett for å bruke REST API-er fra Bash-kommandolinjen:

Grunnleggende pipeline: curl -s URL | jq 'filter' — grunnlaget for alt.
Autentiseringsheadere: send token-er via -H fra miljøvariabler, aldri hardkodet.
Håndtering av matriser: .[], select() og map() filtrerer og omstrukturerer API-svar.
Paginerering: bruk en løkke med sideteller (tom matrise som stoppmarkør), eller analyser Link-headere for API-er som oppgir URL-en til neste side.
Kjeding: trekk ut ID-er fra ett svar, og bruk dem i den neste forespørselen i en while read-løkke.
POST med trygge nyttelaster: bygg JSON-body-er med jq -n --arg, og send dem videre til curl med -d @-.
Feilhåndtering: skill HTTP-status (-w '%{http_code}') fra API-feil i body-en.
Gjenbrukbar hjelpefunksjon: pakk standardkode inn i en shell-funksjon, slik at skriptene forblir korte og DRY.

Kombiner disse mønstrene, så kan du automatisere enhver arbeidsflyt mot et JSON-API direkte fra skallet — uten behov for ekstra kjøremiljø.

Gratis å komme i gang

Lær deg Bash med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 22
Leksjoner: 88

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Bruk av REST-API-er med curl og jq sammen» gratis?

Ja – hele teksten i «Bruk av REST-API-er med curl og jq sammen» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Mestring av Linux-kommandolinjen og Bash-skripting-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Mestring av Linux-kommandolinjen og Bash-skripting inneholder totalt 4 leksjoner.

Hva lærer jeg i «Bruk av REST-API-er med curl og jq sammen»?

Koble curl-forespørsler sammen med jq for å hente ut, paginere og formatere API-svar i skript. Du øver på Mestring av Linux-kommandolinjen og Bash-skripting med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Mestring av Linux-kommandolinjen og Bash-skripting?

Ingen tidligere erfaring er nødvendig. Mestring av Linux-kommandolinjen og Bash-skripting på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Bruk av REST-API-er med curl og jq sammen»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Mestring av Linux-kommandolinjen og Bash-skripting-leksjonen?

Ja. Alle Mestring av Linux-kommandolinjen og Bash-skripting-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Filtrering og utvalg av JSON med jq-pipelines
Transformering og bygging av JSON-objekter med jq
Bruk av REST-API-er med curl og jq sammen
Redigering av YAML-konfigurasjonsfiler med yq

← Tilbake til Mestring av Linux-kommandolinjen og Bash-skripting