Bemästra Linux-kommandoraden och Bash-skriptning · Lektion

Anropa REST-API:er med curl och jq tillsammans

Kedja curl-anrop med jq för att extrahera, sidindela och formatera om live-svar från API:er i skript.

Lektion 3 av 413 steg

Anropa REST-API:er med curl och jq tillsammans är en gratis lektion i Bemästra Linux-kommandoraden och Bash-skriptning på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Bemästra Linux-kommandoraden och Bash-skriptning, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Bemästra Linux-kommandoraden och Bash-skriptning innehåller totalt 4 lektioner.

Varför curl + jq är en kraftfull kombination

REST-API:er returnerar JSON. curl hämtar det råa svaret och jq skär ut, filtrerar och omformar det — allt i en enda pipeline. Inget Python-skript, inget Postman och ingen mellanliggande fil behövs.

curl hanterar HTTP: metoder, headers, autentisering och omdirigeringar.
jq hanterar JSON: filtrering, mappning, omformning och formatering.
Genom att koppla ihop dem skapas korta och kombinerbara API-arbetsflöden.

I den här lektionen bygger du upp den färdigheten från grunderna genom praktiska mönster för paginering och skript.

Grundläggande curl-pipeline till jq

Det enklaste mönstret är att skicka utdata från curl direkt till jq. Använd -s (silent) för att dölja curls förloppsindikator, så att endast JSON-innehållet når jq.

-s — tyst läge utan förloppsindikator.
. — jqs identitetsfilter; skriver ut hela svaret med indrag.
-r i jq — rå utdata (inga omgivande citattecken runt strängar).

#!/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'

Ange request-headers och skicka autentiseringstoken

De flesta produktions-API:er kräver en Authorization-header eller en API-nyckel. Skicka headers med -H och lagra hemligheter i miljövariabler — hårdkoda dem aldrig.

-H 'Authorization: Bearer $TOKEN' — infogar autentiseringsheadern.
-H 'Accept: application/json' — begär uttryckligen JSON som svar.
Variabler expanderas inuti dubbla citattecken; använd " runt headersträngen.

#!/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}'

Filtrera arrayer — .[] och select()

API:er returnerar ofta arrayer. Använd .[] för att iterera över varje element och sedan select() för att behålla endast objekt som uppfyller ett villkor.

.[] — delar upp en array i en ström av objekt.
select(.field == value) — behåller endast objekt som matchar.
Koppla samman flera filter 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'

Extrahera flera fält med map()

map() tillämpar en transformation på varje element i en array och returnerar en ny array — motsvarande [.[] | ...], men mer läsbart.

map({key: .field}) — omforma varje objekt.
Kombinera med @csv eller @tsv för att skapa tabellutdata.
Använd -r med @csv/@tsv för att få råtext (utan JSON-citering).

#!/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 — loopa tills sidan är tom

De flesta API:er delar upp resultat i sidor. Ett vanligt mönster är en while-loop som ökar en sidräknare och avslutas när den returnerade arrayen är tom.

Spara curl-svaret i en variabel med $(curl ...).
Använd jq 'length' för att kontrollera om sidan innehåller element.
Samla resultaten med jq -s (slurp) eller lägg till dem 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")"

Pagineringslänk i Link-headern (GitHub-stil)

GitHub och många andra API:er använder en Link-header i svaret för att ange URL:en till nästa sida. Ni måste tolka headern i stället för att gissa URL:en.

curl -i inkluderar svarshuvuden i stdout. Ni kan också använda -D - för att skriva ut headers till stdout.
Tolka headern Link: <url>; rel="next" med grep och sed.
Fortsätt loopa tills det inte längre finns någon länk med rel="next".

#!/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)"

Kedja anrop — använd utdata från ett anrop som indata till ett annat

Ett vanligt arbetsflöde är att hämta en lista, extrahera ett ID och sedan hämta detaljerna för varje ID. Lagra mellanliggande värden med kommandosubstitutionen $() och skicka in dem i nästa URL.

Extrahera ett enskilt värde med jq -r '.field'.
Iterera över flera ID:n med jq -r '.[].id' i en while read-loop.
Använd sleep mellan anropen för att respektera begränsningar av anropsfrekvensen.

#!/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-anrop — skicka JSON-nyttolaster

För att skapa eller uppdatera resurser skickar ni en POST eller PUT med en JSON-kropp. Använd -X POST, -H 'Content-Type: application/json' och -d för kroppen. Bygg nyttolasten med jq -n för att undvika problem med citering.

jq -n --arg key value '{key: $key}' — säker variabelinterpolering i jq.
Skicka den konstruerade JSON-datan direkt till curls -d @- (läs kroppen från stdin).
Tolka svaret omedelbart med ytterligare ett 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 '.'

Felhantering — HTTP-statuskoder och API-fel

En lyckad HTTP-anslutning innebär inte att API-anropet lyckades. Kontrollera HTTP-statuskoden och JSON-fältet för fel separat.

curl -w '%{http_code}' lägger till statuskoden i stdout. Använd -o för att skriva kroppen till en fil.
Jämför koden i skriptet och hantera 4xx/5xx på olika sätt.
Många API:er bäddar in {"error": "..."} i kroppen — kontrollera detta med jqs 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"

Bygg en återanvändbar hjälpfunktion för API-anrop

Samla den återkommande curl- och felkontrollskoden i en shell-funktion. Funktionen hanterar autentisering, statuskontroll och JSON-extrahering — anroparen behöver bara skicka endpointen och ett jq-filter.

Returnera utgångskoder som inte är noll vid HTTP-fel, så att anroparen kan använda || eller set -e.
Acceptera ett jq-filter som argument, så att samma funktion kan användas för många endpoints.
Läs in den här funktionsfilen från alla skript som behöver 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)>"'

Kunskapskontroll: pagineringsstrategi

Testa er förståelse av hur ni hanterar paginerade svar från REST-API:er i ett Bash-skript med curl och jq.

Besvara frågan i den interaktiva lektionen

Lektionssammanfattning: curl + jq för API-skript

Ni har nu en komplett verktygslåda för att använda REST-API:er från Bash-kommandoraden:

Grundläggande pipeline: curl -s URL | jq 'filter' — grunden för allt.
Autentiseringsheaders: skicka tokens via -H från miljövariabler, aldrig hårdkodade.
Arrayhantering: .[], select() och map() filtrerar och omformar API-svar.
Pagination: loopa med en sidräknare (tom array som stoppvillkor) eller tolka Link-headers för API:er som anger nästa URL på detta sätt.
Kedjning: extrahera ID:n från ett svar och skicka in dem i nästa anrop i en while read-loop.
POST med säkra nyttolaster: bygg JSON-kroppar med jq -n --arg och skicka dem till curls -d @-.
Felhantering: skilj HTTP-status (-w '%{http_code}') från API-fel i svarskroppen.
Återanvändbar hjälpfunktion: samla standardkod i en shell-funktion så att skripten förblir korta och DRY.

Kombinera dessa mönster så kan ni automatisera arbetsflöden för alla JSON-API:er helt från skalet — utan någon ytterligare runtime.

Gratis att börja

Lär dig Bash med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 22
Lektioner: 88

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Anropa REST-API:er med curl och jq tillsammans” gratis?

Ja – hela texten till ”Anropa REST-API:er med curl och jq tillsammans” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Bemästra Linux-kommandoraden och Bash-skriptning, kan Ni uppgradera till CoddyKit PRO. Kursen i Bemästra Linux-kommandoraden och Bash-skriptning innehåller totalt 4 lektioner.

Vad lär jag mig i ”Anropa REST-API:er med curl och jq tillsammans”?

Kedja curl-anrop med jq för att extrahera, sidindela och formatera om live-svar från API:er i skript. Ni övar på Bemästra Linux-kommandoraden och Bash-skriptning med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Bemästra Linux-kommandoraden och Bash-skriptning?

Du behöver inga förkunskaper. Utbildningen i Bemästra Linux-kommandoraden och Bash-skriptning på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Anropa REST-API:er med curl och jq tillsammans”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Bemästra Linux-kommandoraden och Bash-skriptning-lektionen?

Ja. Varje Bemästra Linux-kommandoraden och Bash-skriptning-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Filtrera och välja JSON med jq-pipelines
Omforma och skapa JSON-objekt med jq
Anropa REST-API:er med curl och jq tillsammans
Redigera YAML-konfigurationsfiler med yq

← Tillbaka till Bemästra Linux-kommandoraden och Bash-skriptning