#restapi

Hello Networkers,

We have released a new update to our existing ‘Network Automation using Ansible’ course we will show you how you can run python scripts inside of an Ansible playbook utilizing the shell module. Another type of task we can run is sending REST API requests inside of a playbook. For this example we will send a request to one of my Palo Alto Network firewalls to get some basic system information..

You can get more details here:

Hello Networkers,

We have released a new automation development course, where you will learn how to configure the Palo Alto Networks firewall appliance using REST APIs to provide network automation and programmability services to your network environment. You will learn about the structure and components of REST API requests.  You will learn how you can view, add, update, and delete a wide variety of firewall components to even performing a software upgrade. And you will learn how you can build REST API requests inside of a Python script to show what you can build further for your own tools to provide firewall automation.

Okay so let me tell you about the worst part of switching phones.

Not the setup process. not transferring photos. the part where you open your API client on the new device and everything is just... gone. all your saved collections, your environment variables, your auth configs, vanished. because the app stored everything locally and had no idea iCloud existed.

If you've been there, you know the specific frustration of rebuilding requests you've run a hundred times before. it's not hard, it's just deeply annoying. and completely avoidable.

Here's the thing about most API testing tools, they were built for desktops, by people who assumed you'd always be at a desk. the idea that you might test an endpoint from your iPad on the couch, then pick up on your Mac, then check a response on your iPhone while waiting for coffee, that workflow wasn't in the original design spec.

But that's just how a lot of developers actually work now.

When an app integrates properly with iCloud, your data lives with you. change something on one device, it's updated on the others. wipe your phone, restore from iCloud, open the app - everything's exactly where you left it. it sounds obvious. it should be obvious. and yet the number of developer tools that still treat local storage as the default in 2026 is genuinely baffling.

HTTPBot gets this right. it's a native iOS and macOS API client that syncs your collections and environments across all your Apple devices through iCloud Drive. your requests don't live on a single machine. they live in your Apple ecosystem, following you wherever you go.

But it's not just about backup.

iCloud sync in HTTPBot means something more practical than disaster recovery. it means you can genuinely split your workflow across devices without losing context.

Draft a complex POST request on your MacBook. pick up your iPhone an hour later and it's there, ready to send. spot a weird response on your iPad, switch to your Mac to inspect it in more detail. the request history, the environments, the saved auth tokens, all of it travels with you.

On top of that, you can import and export collections to iCloud Drive, Dropbox, Google Drive, and other file providers. so if you're working with a team, sharing collections is just sharing a file. no proprietary cloud account required, no per-seat collaboration fees.

Beyond iCloud, HTTPBot covers the full daily API testing stack — all HTTP methods, GraphQL, WebSockets, environment variables, authentication (OAuth 2.0, JWT, Basic, Digest — the full list), response inspection with syntax highlighting, JSONPath and XPath filtering, and Apple Shortcuts automation for anyone who wants to go full productivity nerd with their testing workflows.

It's free to download with a 7-day trial to unlock everything, and the pricing after that is the kind that doesn't make you do sad math — yearly subscription or a one-time lifetime purchase.

Your API collections took time to build. they should be safe, synced, and available on every device you own. that's not a premium feature. that's just what a well-made tool does.

Six months ago, I was integrating one AI API into a project. One endpoint, one provider, one set of headers to remember. It was straightforward enough that I kept most of it in my head.

That's not my life anymore.

Right now, the same project talks to four different AI providers. Each one has its own authentication pattern, its own request structure, its own way of handling streaming responses, and its own habit of quietly updating things without sending a memo. On top of that, I've been evaluating three more providers for a feature we're planning next quarter. That's seven APIs, all AI-related, all actively changing, all needing to be tested regularly.

I'm an iOS developer. My primary machine is a MacBook, but I spend a lot of time on my iPhone and iPad. And somewhere in the last year, the way I work has had to shift pretty dramatically to keep pace with how fast this space moves.

I don't think people outside of active development fully clock how quickly the AI API landscape is moving. It's not like integrating a payments API or a mapping service, where the endpoints are stable for years and documentation changes are rare. AI providers ship fast, iterate publicly, and deprecate things with timelines that would have seemed aggressive in any other part of the industry.

OpenAI alone has gone through multiple model generations, streaming format changes, and function calling revisions in the span of time most SaaS products would spend on a single minor release. Anthropic, Google, Mistral, Cohere, they're all moving at similar speeds. And if you're building on top of any of them, you're not just integrating once. You're re-testing constantly.

For a solo iOS developer or a small team, that creates real pressure. You need a testing workflow that's fast enough to keep up, flexible enough to handle different authentication schemes and request formats, and accessible enough that you can actually use it when the moment calls for it, not just when you're sitting at a desk.

For a long time, I was doing most of my API testing at my desk, on my Mac, using whatever tool was closest. That worked when the pace was slower. It stopped working when I found myself needing to test a streaming response at 9pm from my couch because a provider had pushed a model update and something in our integration was behaving differently.

The first shift was accepting that API testing had to move to wherever I was, not just where my laptop was. That sounds obvious in retrospect, but it took a few late nights of squinting at curl commands in a terminal app on my iPhone to really drive the point home. There had to be a better way to manage this from a mobile device.

The second shift was getting serious about organizing collections. When you're working with one or two APIs, you can afford to be loose about this. When you're juggling multiple AI providers, each with multiple endpoints, model variants, and environment configurations, loose doesn't cut it. I started treating my API collections the way I treat code — structured, named properly, grouped logically, and kept somewhere that syncs across my devices.

The third shift was around environment variables. Every AI provider has a different base URL, a different API key format, and often different headers depending on whether you're hitting a staging endpoint or production. Manually swapping these out every time you switch providers is a fast way to make mistakes. Environment variables that you can flip with one tap are the only sane way to manage it.

Standard REST API testing has a comfortable rhythm. You send a request, you get a response, you check the structure. AI APIs introduce patterns that break that rhythm in interesting ways.

Streaming is the big one. Most AI providers now return responses as server-sent events - a continuous stream of tokens rather than one complete JSON object. Testing streaming responses requires a client that can actually handle and display the stream in real time, not just show you a blob of text at the end. Watching tokens come back token-by-token is genuinely useful for catching latency issues, understanding model behavior, and debugging integration problems that only show up mid-stream.

Function calling and tool use is another layer. Modern AI APIs let you define tools that the model can invoke, which means your test requests are suddenly carrying complex JSON schemas and your responses include structured tool call outputs that need to be inspected carefully. Testing this manually takes a level of precision that rewards having a clean, well-organized request editor.

Then there's the context window management problem. If you're building anything with memory or multi-turn conversation, your test requests get long. Very long. Managing large JSON bodies on a mobile device used to be painful. It's gotten better, but it requires a client that handles large payloads gracefully.

My current setup revolves around keeping everything in a native API client that lives on all my Apple devices. I use HTTPBot - it's built specifically for iPhone, iPad, and Mac, syncs collections through iCloud, and handles streaming responses properly. When a provider ships an update, I can test the change from wherever I am, not just from my desk.

The ability to switch environments quickly has become non-negotiable. I keep a separate environment for each AI provider, with variables for the API key, base URL, and any model identifiers I use regularly. Switching from testing an Anthropic endpoint to testing an OpenAI one is a matter of tapping a different environment, not manually editing headers.

I'm not going to pretend I have this perfectly figured out. The AI API landscape moves faster than any workflow can fully keep up with. Providers still surprise me. Documentation still lags behind what's actually deployed. Things still break at inconvenient times.

But having a mobile-first testing setup, treating collections as living documents, and building proper environment management into my workflow has made the chaos significantly more manageable. The developers I know who are struggling most with this are the ones still treating API testing as a desk-only activity. The pace of this space doesn't accommodate that anymore.

Wenn du mit modernen Webdiensten, Smart-Home-Geräten oder IoT-Projekten arbeitest, wirst du früher oder später mit REST APIs in Berührung kommen. Viele Systeme – vom Webservice bis zum Mikrocontroller – stellen ihre Funktionen über solche Schnittstellen bereit.

Um diese APIs zu testen oder zu analysieren, brauchst du ein Werkzeug, mit dem du gezielt HTTP-Anfragen senden und die Antworten des Servers auswerten kannst. Genau dafür wurde Postman entwickelt.

Mit Postman kannst du API-Requests schnell zusammenstellen und ausführen:

- HTTP-Methoden wie GET, POST, PUT oder DELETE auswählen - Header oder Authentifizierung hinzufügen - JSON-Daten im Request senden - die Antwort des Servers direkt analysieren

Der große Vorteil: Du kannst eine API ohne eigenen Code testen. Statt erst ein Programm zu schreiben, genügt ein einfacher Request in Postman, um zu sehen, welche Daten eine Schnittstelle liefert.

Gerade beim Entwickeln oder Testen von IoT-Projekten, Smart-Home-Geräten oder eigenen Webservices spart das enorm viel Zeit. Fehler in der API lassen sich schnell erkennen und Requests können beliebig angepasst werden.

https://youtu.be/DTPS6nZ1VWs

In diesem Beitrag zeige ich dir Schritt für Schritt:

- wie du Postman installierst - wie du deinen ersten API-Request erstellst - und wie du die Antwort eines Servers richtig auswertest.

Postman anmelden, installieren und starten

Das Gute vorweg: Postman kann in der Grundversion kostenlos genutzt werden. Für die meisten Aufgaben – etwa das Testen von REST APIs oder das Debuggen von Requests – reicht der kostenlose Plan völlig aus.

Bevor du das Tool verwenden kannst, musst du zunächst ein Benutzerkonto erstellen. Die Registrierung ist schnell erledigt und kann auf verschiedenen Wegen erfolgen:

- klassisch mit Benutzername und Passwort - über ein vorhandenes Google-Konto - über GitHub

Postman - Anmelden

Nach der Registrierung kannst du Postman direkt herunterladen und als Desktop-Anwendung installieren. Die Software steht für die gängigen Betriebssysteme zur Verfügung:

- Windows - macOS - Linux

Die Installation läuft dabei wie bei anderen Programmen auch: Setup-Datei herunterladen, ausführen und den Installationsschritten folgen. Nach dem ersten Start meldest du dich mit deinem zuvor erstellten Account an und landest direkt in der Postman-Oberfläche.

Ein Vorteil der Anmeldung ist, dass deine Requests, Collections und Einstellungen automatisch synchronisiert werden. Wenn du Postman später auf einem anderen Rechner installierst, stehen deine gespeicherten Projekte sofort wieder zur Verfügung.

Im nächsten Schritt schauen wir uns an, wie du deinen ersten Request in Postman erstellst und eine API testest.

Installation abschließen und anmelden

Die Installation von Postman ist unkompliziert. Nach dem Download startest du einfach die Installationsdatei – ein Installationsassistent (Wizard) führt dich anschließend Schritt für Schritt durch den Vorgang. In der Regel musst du dabei keine besonderen Einstellungen vornehmen.

Sobald die Installation abgeschlossen ist und du Postman startest, wirst du aufgefordert, dich mit deinem zuvor erstellten Account anzumelden. Dabei erfolgt die Anmeldung meist über den Browser:

- Postman öffnet automatisch eine Anmeldeseite im Browser. - Dort meldest du dich mit deinem Account an (z. B. per E-Mail, Google oder GitHub). - Nach erfolgreicher Anmeldung wirst du wieder zurück zur Desktop-App geleitet.

Dieser kurze Wechsel zwischen Browser und Anwendung gehört zum normalen Ablauf. Danach ist Postman vollständig eingerichtet und du kannst direkt mit dem Erstellen deiner ersten API-Requests beginnen.

Im nächsten Abschnitt schauen wir uns an, wie du in Postman eine neue Anfrage erstellst und eine REST API testest.

Die wichtigsten HTTP-Methoden im Überblick

Wenn wir mit APIs arbeiten, begegnen uns immer wieder verschiedene HTTP-Methoden. Diese legen fest, was mit einer Ressource auf dem Server passieren soll.

Die wichtigsten Methoden sind:

- GET – Daten vom Server abrufen - POST – neue Daten erstellen - PUT – vorhandene Daten vollständig ersetzen - PATCH – einzelne Felder einer Ressource ändern - DELETE – Daten löschen

In diesem Beitrag konzentrieren wir uns hauptsächlich auf GET-Requests, da diese besonders häufig verwendet werden – zum Beispiel beim Abrufen von Sensordaten, API-Informationen oder Statuswerten von Geräten.

Erste Anfrage senden – ein einfacher GET-Request

Starten wir direkt mit einem einfachen Beispiel. Wir senden eine Anfrage an die Website von Google, um zu sehen, wie Postman mit HTTP-Requests arbeitet.

Dafür verwenden wir die HTTP-Methode GET. Diese Methode wird genutzt, um Daten von einem Server abzurufen – zum Beispiel eine Webseite oder API-Informationen.

Gehe dazu folgendermaßen vor:

- Öffne Postman und klicke auf „New“ bzw. „HTTP Request“. - Stelle sicher, dass als Methode GET ausgewählt ist. - Trage in das URL-Feld folgende Adresse ein: https://google.com - Klicke anschließend auf Send.

Postman sendet nun die Anfrage an den Server. Innerhalb weniger Millisekunden erhältst du eine Antwort, die im unteren Bereich des Fensters angezeigt wird.

Dabei siehst du mehrere wichtige Informationen:

- Statuscode – zeigt an, ob die Anfrage erfolgreich war (z. B. 200 OK) - Antwortzeit – wie lange der Server für die Antwort benötigt hat - Größe der Antwort – wie viele Daten übertragen wurden - Response Body – der Inhalt der Antwort, in diesem Fall der HTML-Code der Webseite

Da wir hier keine klassische REST API aufrufen, sondern eine normale Webseite, liefert der Server den HTML-Code der Google-Startseite zurück. Genau das zeigt Postman im Antwortbereich an.

Dieses einfache Beispiel zeigt bereits das Grundprinzip: Postman sendet eine HTTP-Anfrage an einen Server und zeigt dir anschließend die komplette Antwort an.

APIs testen – Beispiel mit einer offenen API

Das vorherige Beispiel mit der Google-Webseite war noch relativ simpel. In der Praxis wird Postman jedoch meist genutzt, um REST APIs zu testen. Dabei unterscheidet man grundsätzlich zwischen zwei Arten von Schnittstellen:

- offene APIs – können ohne Anmeldung oder Zugangsdaten genutzt werden - geschützte APIs – erfordern Authentifizierung, z. B. über API-Keys oder Tokens

Beginnen wir zunächst mit einer offenen API, da diese besonders einfach zu testen ist.

Ein gutes Beispiel stammt aus einem meiner letzten Blogbeiträge. Dort habe ich aktuelle Edelmetallpreise über folgende API abgerufen:

https://api.edelmetalle.de/public.json

Diese Schnittstelle ist öffentlich zugänglich und liefert die Daten direkt als JSON zurück. Genau solche APIs eignen sich hervorragend, um die Arbeit mit Postman kennenzulernen.

Um diese API zu testen, gehst du ähnlich vor wie im vorherigen Beispiel:

- Öffne in Postman einen neuen HTTP Request. - Stelle sicher, dass die Methode GET ausgewählt ist. - Trage folgende URL ein: https://api.edelmetalle.de/public.json - Klicke anschließend auf Send.

Postman sendet nun die Anfrage an den Server und zeigt dir im Antwortbereich die zurückgegebenen Daten an.

In diesem Fall erhältst du ein JSON-Dokument, das unter anderem aktuelle Preise für verschiedene Edelmetalle enthält – beispielsweise für Gold, Silber oder Platin. Im Gegensatz zum vorherigen Beispiel sehen wir hier also keinen HTML-Code, sondern strukturierte Daten im JSON-Format.

Postman - HTTP Request - offene API

Damit Postman die Antwort korrekt als JSON darstellen kann, geben wir in der Anfrage zusätzlich einen passenden Header mit. Dieser teilt dem Server mit, welches Datenformat wir erwarten.

Dazu wechseln wir in Postman in den Bereich Headers und tragen folgenden Eintrag ein:

Accept: application/json

Mit diesem Header signalisieren wir dem Server, dass wir die Antwort im JSON-Format erhalten möchten. Viele APIs liefern dann automatisch strukturierte JSON-Daten zurück.

Postman - setzen des Wertes für Accept für formatierten JSON Response

Ein großer Vorteil von Postman ist, dass JSON-Daten anschließend automatisch formatiert dargestellt werden. Dadurch lassen sich einzelne Werte deutlich einfacher lesen und analysieren – zum Beispiel, wenn du die Daten später in eigenen Anwendungen, Skripten oder Mikrocontroller-Projekten weiterverarbeiten möchtest.

Geschützte APIs – Zugriff mit API-Key oder Token

Das vorherige Beispiel mit den Edelmetallpreisen war eine offene API. In der Praxis sind viele Schnittstellen jedoch geschützt, damit nicht jeder beliebig auf die Daten zugreifen kann.

In solchen Fällen muss sich der Client – also unsere Anwendung oder in diesem Fall Postman – gegenüber dem Server authentifizieren.

Dafür gibt es verschiedene Verfahren. Zwei der häufigsten sind:

API-Key

Die einfachste Form der Authentifizierung ist ein API-Key. Dabei erhält man vom Anbieter einen eindeutigen Schlüssel, der bei jeder Anfrage mitgesendet werden muss.

Der Server prüft diesen Schlüssel und entscheidet anschließend, ob die Anfrage erlaubt ist.

Ein Beispiel dafür sind viele Smart-Home-Geräte wie Shelly, bei denen der Zugriff auf bestimmte Funktionen über einen API-Key abgesichert werden kann.

Der API-Key wird meist über:

- einen Header - einen URL-Parameter - oder einen Query-Parameter

übergeben.

Token-basierte Authentifizierung

Eine etwas komplexere Methode ist die Token-basierte Authentifizierung.

Dabei meldet sich der Client zunächst beim Server an und erhält anschließend einen Token, der nur für eine bestimmte Zeit gültig ist. Dieser Token wird dann bei jeder weiteren Anfrage mitgesendet.

Ein bekanntes Beispiel für dieses Verfahren ist die Kartenplattform HERE Technologies, deren APIs häufig mit zeitlich begrenzten Tokens arbeiten.

Der Vorteil dieser Methode: Die Zugangsdaten müssen nicht bei jeder Anfrage übertragen werden, sondern nur der temporäre Zugriffstoken.

Geschützte APIs – Beispiel mit Shelly

Viele APIs sind nicht öffentlich zugänglich, sondern erfordern eine Authentifizierung. Der Server prüft dabei, ob der Client berechtigt ist, die Schnittstelle zu nutzen.

Ein Beispiel dafür sind Geräte von Shelly, die eine REST API zur Steuerung und zum Auslesen von Statusinformationen bereitstellen.

Dabei gibt es grundsätzlich zwei Möglichkeiten auf die API zuzugreifen:

- lokal im Heimnetzwerk über die IP-Adresse des Geräts - über die Shelly Cloud, wobei ein Auth-Key übergeben werden muss

Beim lokalen Zugriff erfolgt die Anfrage meist über eine einfache HTTP GET Anfrage. Wird die API über die Cloud angesprochen, muss der entsprechende Authentifizierungsschlüssel bei der Anfrage mitgesendet werden.

Genau solche Authentifizierungsmechanismen lassen sich in Postman sehr einfach testen. Postman bietet dafür eigene Bereiche, in denen sich API-Keys, Tokens oder andere Zugangsdaten konfigurieren lassen.

Im nächsten Schritt schauen wir uns an, wie ein API-Key direkt in einer Anfrage mit Postman übergeben wird.

Parameter in Postman übergeben

Im Fall eines Shelly-Geräts wird der authKey als Parameter übergeben. In Postman können solche Parameter bequem im Reiter Params verwaltet werden.

Postman - Reiter Params für die Angabe von Parameter

Dort lassen sich Schlüssel-Wert-Paare definieren, die Postman beim Absenden der Anfrage automatisch an die URL anhängt.

Ein Beispiel könnte so aussehen:

Key: authKey Value: DEIN_AUTH_KEY

Postman erzeugt daraus automatisch eine Anfrage in der Form:

http://example-api/shelly?authKey=DEIN_AUTH_KEY

Der Vorteil dieser Methode ist, dass du die Parameter übersichtlich verwalten kannst, ohne sie direkt in die URL schreiben zu müssen.

Und solltest du mal eine URL in Postman mit Parameter einfügen so wird diese automatisch zerlegt und du findest anschließend die Parameter sauber im Reiter Params.

Fazit

Mit Postman steht ein leistungsfähiges Werkzeug zur Verfügung, um REST APIs schnell und ohne eigenen Code zu testen. Bereits mit wenigen Klicks lassen sich HTTP-Anfragen erstellen, Parameter definieren und die Antworten eines Servers direkt analysieren.

Wie die Beispiele gezeigt haben, lassen sich sowohl offene APIs als auch geschützte Schnittstellen problemlos testen. Dabei spielt es keine Rolle, ob es sich um klassische Webservices, Cloud-APIs oder lokale Geräte im Heimnetzwerk handelt.

Gerade bei IoT- und Smart-Home-Projekten ist Postman ein sehr hilfreiches Werkzeug. APIs von Geräten oder Webdiensten können damit schnell geprüft werden, ohne dass sofort eine eigene Anwendung oder ein Skript geschrieben werden muss. Fehler in Requests lassen sich so deutlich schneller finden und beheben.

Wenn du häufiger mit APIs arbeitest, lohnt es sich außerdem, einen Blick auf weitere Funktionen von Postman zu werfen. Dazu gehören unter anderem:

- das Speichern von Requests in Collections - das automatische Testen von APIs - oder das Dokumentieren von Schnittstellen