De Linux-opdrachtregel en Bash-scripting beheersen · Les

REST API's gebruiken met curl en jq samen

Koppel curl-aanvragen aan jq om live API-antwoorden in scripts uit te lezen, te pagineren en opnieuw op te maken.

Les 3 van 413 stappen

REST API's gebruiken met curl en jq samen is een gratis De Linux-opdrachtregel en Bash-scripting beheersen-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject De Linux-opdrachtregel en Bash-scripting beheersen. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus De Linux-opdrachtregel en Bash-scripting beheersen bevat in totaal 4 lessen.

Waarom curl + jq de krachtige combinatie is

REST-API's retourneren JSON. curl haalt de ruwe respons op; jq knipt, filtert en geeft deze een andere vorm — allemaal in één pijplijn. Geen Python-script, geen Postman en geen tussenbestand nodig.

curl handelt HTTP af: methoden, headers, authenticatie en omleidingen.
jq handelt JSON af: filteren, toewijzen, transformeren en opmaken.
Door ze aan elkaar te koppelen ontstaan beknopte, combineerbare API-werkstromen.

In deze les bouw je die vaardigheid vanaf de basis op aan de hand van paginering en scriptpatronen uit de praktijk.

Basispijplijn van curl naar jq

Het eenvoudigste patroon: stuur de uitvoer van curl rechtstreeks door naar jq. Gebruik -s (stil) om de voortgangsmeter van curl te onderdrukken, zodat alleen de JSON-body jq bereikt.

-s — stille modus, zonder voortgangsbalk.
. — het identiteitsfilter van jq; maakt de volledige respons leesbaar op.
-r voor jq — onbewerkte uitvoer (zonder omringende aanhalingstekens bij tekenreeksen).

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

Verzoekheaders instellen en authenticatietokens doorgeven

De meeste productie-API's vereisen een Authorization-header of een API-sleutel. Geef headers door met -H en bewaar geheimen in omgevingsvariabelen — zet ze nooit rechtstreeks in de code.

-H 'Authorization: Bearer $TOKEN' — voegt de authenticatieheader in.
-H 'Accept: application/json' — vraagt expliciet JSON op.
Variabelen worden binnen dubbele aanhalingstekens uitgebreid; gebruik " rond de headertekenreeks.

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

Arrays filteren — .[] en select()

API's retourneren vaak arrays. Gebruik .[] om elk element te doorlopen en vervolgens select() om alleen items te behouden die aan een voorwaarde voldoen.

.[] — splitst een array op in een stroom objecten.
select(.field == value) — behoudt alleen overeenkomende objecten.
Koppel meerdere filters met |.

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

Meerdere velden extraheren met map()

map() past een transformatie toe op elk element van een array en retourneert een nieuwe array — gelijkwaardig aan [.[] | ...], maar beter leesbaar.

map({key: .field}) — geef elk object een nieuwe vorm.
Combineer dit met @csv of @tsv om tabelvormige uitvoer te genereren.
Gebruik -r met @csv/@tsv voor onbewerkte tekst (zonder JSON-aanhalingstekens).

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

Paginatiepatroon — herhaal totdat de pagina leeg is

De meeste API's verdelen resultaten over meerdere pagina's. Een veelgebruikt patroon is een while-lus die een paginateller verhoogt en stopt zodra de geretourneerde array leeg is.

Sla het curl-antwoord op in een variabele met $(curl ...).
Gebruik jq 'length' om te controleren of de pagina elementen bevat.
Verzamel resultaten met jq -s (slurp) of voeg ze toe aan een bestand.

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

Paginatie met de Link-header (GitHub-stijl)

GitHub en veel andere API's gebruiken een Link-antwoordheader om de URL van de volgende pagina door te geven. Je moet de header parseren in plaats van de URL te raden.

curl -i neemt antwoordheaders op in stdout; je kunt ook -D - gebruiken om headers naar stdout te schrijven.
Parse de header Link: <url>; rel="next" met grep en sed.
Herhaal totdat er geen link met rel="next" meer aanwezig is.

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

Verzoeken aan elkaar koppelen — gebruik de uitvoer van één aanroep als invoer voor een andere

Een veelgebruikte werkwijze: haal een lijst op, extraheer een ID en haal vervolgens de details voor elk ID op. Sla tussenliggende waarden op met opdrachtvervanging via $() en geef ze door aan de volgende URL.

Extraheer één waarde met jq -r '.field'.
Verwerk meerdere ID's in een lus met jq -r '.[].id' binnen een while read-lus.
Gebruik sleep tussen verzoeken om rekening te houden met snelheidslimieten.

#!/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-verzoeken — JSON-ladingen verzenden

Om resources te maken of bij te werken, verstuur je een POST of PUT met een JSON-body. Gebruik -X POST, -H 'Content-Type: application/json' en -d voor de body. Bouw de lading met jq -n om problemen met aanhalingstekens te voorkomen.

jq -n --arg key value '{key: $key}' — veilige interpolatie van variabelen in jq.
Leid de opgebouwde JSON rechtstreeks door naar curl's -d @- (lees de body uit stdin).
Parse het antwoord direct met een ander 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 '.'

Foutafhandeling — HTTP-statuscodes en API-fouten

Een geslaagde HTTP-verbinding betekent niet dat de API-aanroep is geslaagd. Controleer de HTTP-statuscode en het JSON-foutveld afzonderlijk.

curl -w '%{http_code}' voegt de statuscode toe aan stdout; gebruik -o om de body naar een bestand te schrijven.
Vergelijk de code in je script en handel 4xx- en 5xx-fouten verschillend af.
Veel API's nemen {"error": "..."} op in de body — controleer dit met has() of type van jq.

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

Een herbruikbare API-helperfunctie bouwen

Verpak de standaardcode voor curl en foutcontrole in een shellfunctie. De functie handelt authenticatie, statuscontrole en JSON-extractie af — aanroepers geven alleen het eindpunt en een jq-filter door.

Retourneer niet-nul-exitcodes bij HTTP-fouten, zodat aanroepers || of set -e kunnen gebruiken.
Accepteer een jq-filter als argument, zodat dezelfde functie voor veel eindpunten kan worden gebruikt.
Laad dit functiebestand vanuit elk script dat de API nodig heeft.

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

Kenniscontrole: paginatiestrategie

Test je begrip van het verwerken van gepagineerde REST API-antwoorden in een Bash-script met curl en jq.

Beantwoord dit in de interactieve les

Samenvatting van de les: curl + jq API-scripting

Je beschikt nu over een complete gereedschapsset om REST API's vanaf de Bash-opdrachtregel te gebruiken:

Basis-pijplijn: curl -s URL | jq 'filter' — de basis van alles.
Authenticatieheaders: geef tokens via -H door vanuit omgevingsvariabelen, nooit hardgecodeerd.
Arrays verwerken: .[], select() en map() selecteren delen van API-antwoorden en geven ze een nieuwe vorm.
Paginatie: gebruik een lus met een paginateller (een lege array als stopteken) of parse Link-headers voor API's die de URL van de volgende pagina doorgeven.
Aanroepen koppelen: extraheer ID's uit één antwoord en geef ze binnen een while read-lus door aan het volgende verzoek.
POST met veilige ladingen: bouw JSON-bodies met jq -n --arg en leid ze door naar curl's -d @-.
Foutafhandeling: houd de HTTP-status (-w '%{http_code}') gescheiden van API-fouten in de body.
Herbruikbare helper: verpak standaardcode in een shellfunctie, zodat scripts beknopt en DROOG blijven.

Combineer deze patronen en je kunt elke JSON API-werkwijze volledig vanuit de shell automatiseren — er is geen extra runtime nodig.

Gratis beginnen

Leer Bash met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 22
Lessen: 88

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “REST API's gebruiken met curl en jq samen” gratis?

Ja — de volledige tekst van “REST API's gebruiken met curl en jq samen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus De Linux-opdrachtregel en Bash-scripting beheersen wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus De Linux-opdrachtregel en Bash-scripting beheersen bevat in totaal 4 lessen.

Wat leer ik in “REST API's gebruiken met curl en jq samen”?

Koppel curl-aanvragen aan jq om live API-antwoorden in scripts uit te lezen, te pagineren en opnieuw op te maken. Je oefent met De Linux-opdrachtregel en Bash-scripting beheersen door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met De Linux-opdrachtregel en Bash-scripting beheersen te beginnen?

Ervaring vooraf is niet nodig. De Linux-opdrachtregel en Bash-scripting beheersen op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “REST API's gebruiken met curl en jq samen”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over De Linux-opdrachtregel en Bash-scripting beheersen?

Ja. Elke les over De Linux-opdrachtregel en Bash-scripting beheersen bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

JSON filteren en selecteren met jq-pipelines
JSON-objecten transformeren en opbouwen met jq
REST API's gebruiken met curl en jq samen
YAML-configuratiebestanden bewerken met yq

← Terug naar De Linux-opdrachtregel en Bash-scripting beheersen