Threads-API ist da
Tags: graphapi, threads, automatisiert
Published: 2024-06-18 10:19:02

![](https://blog.disane.dev/content/images/2024/06/threads_api-ist-da_banner-1.jpeg)Ich zeige dir wie du die API von Threads nutzt um Posts automatisiert zu generieren 🎉

---

Seit heute steht die API von Threads bereit und ich zeige dir, wie du sie verwenden kannst um Inhalte automatisiert dort bereitzustellen. 

## Voraussetzungen

Du musst auf jeden Fall einen Entwickler-Konto bei Meta haben. Das kannst du dir ganz einfach hier anlegen:

[Meta for Developers![Preview image](https://facebook.com/security/hsts-pixel.gif?c=3.2)Mit Facebook for Developers kannst du Code entwickeln, der Menschen verbindet. Entdecke künstliche Intelligenz, Business-Tools, Gaming, Open Source, Publishing, soziale Hardware, soziale Integration und virtuelle Realität. Erfahre mehr über Facebooks globale Programme zur Schulung und Vernetzung von Entwickler\*innen.](https://developers.facebook.com/)

Zusätzlich dazu, muss dein Account zwingend als Business-Account verifiziert sein. Das musst du im Vorfeld machen, da du sonst keinen Zugriff hast. Bei mir hat ausgereicht entsprechende Dokumente vorzulegen und wurde dann zwar nach 1-2 Tagen abgelehnt, aber ein Widerspruch hat dann später dazu geführt, dass ich verifiziert wurde und nun Business-Apps anlegen kann.

### Business-App ist Pflicht ☝🏼

Die API richtet sich an geschäftliche Kunden, damit die Workflows geöffnet werden und so auch ein Crossposten von Inhalten ermöglicht wird. Darum musst du zwingend eine Business-App anlegen. Das kannst du recht einfach im App-Dashboard machen. Es muss auch eine neue App sein, da alte Apps Threads nicht integriert haben. In den Funktionen der neuen App wählst du "Access the Threads API" aus:

![](https://blog.disane.dev/content/images/2024/06/image-3.png)

Du gibst dann einen App-Namen an und deine Mailadresse. Das musst du dann einmal mit deinem Meta-Kennwort bestätigen und ab geht es.

### Berechtigungen setzen 🔏

Du musst dann deiner App entsprechende Berechtigungen setzen. Wenn du nur Posten willst, dann wird für dich vermutlich `threads_basic`und `threads_content_publish`ausreichen:

![](https://blog.disane.dev/content/images/2024/06/image-4.png)

Weitere Rechte kannst du aber später noch hinzufügen. Du kannst so auch zum Beispiel Replies prüfen, automatisch Bereinigen oder noch vieles anderes. Diese werden später als `SCOPES`noch weiter benötigt.

### OAuth konfigurieren 🤝

Damit du (oder eventuell auch andere Leute) deine App nutzen können, musst du URLs konfigurieren, die von OAuth genutzt werden. OAuth ist ein Autorisierungsprozess, der komplett passwortlos arbeitet und so die Benutzer am System der Ressource autorisiert.

![](https://blog.disane.dev/content/images/2024/06/image-5.png)

Sofern du keine eigene Website hast, kannst du hier Postman nutzen. Postman vereinfacht die Nutzung von APIs ungemein und kann auch den kompletten OAuth-Flow für dich übernehmen. Bei der `Redirect Callback URLs`kannst du, wenn du Postman schon hast, diese URL eintragen: <https://oauth.pstmn.io/v1/callback>. Alternativ jede andere URL, die die Autorisierungs-Codes von OAuth in Empfang nehmen kann.

### Tester hinzufügen 🤵🏼

Möchtest du nur bestimmte Leute einladen, kannst du auch bestimmte Tester hinzufügen. Das brauchst du in dem Falle aber nicht, da wir über OAuth die Rechte direkt anfragen und Threads mit deiner neuen App verknüpfen.

Für richtige App ist das durchaus sinnvoll, dass man hier bestimmte Leute auswählt, die einen-Testzugang zu deiner App haben.

### App-Einstellungen merken 💡

Damit du nun die API-Calls gegen die Threads-API machen kannst, brauchst du noch die `CLIENT_ID`und das `CLIENT_SECRET`. Vor allem auf das Secret musst du sehr gut aufpassen, da damit Zugriffe auf deine App möglich sind. Sei vorsichtig damit, wo du es eingibst und gebe es idealerweise an niemanden weiter. Beide Werte kannst du unter `App settings`und dann `Basic` einsehen:

![](https://blog.disane.dev/content/images/2024/06/image-7.png)

## Wir autorisieren uns

### Autorisierungscode abfragen ❓

Da wir nun soweit alle Voraussetzungen getroffen haben, können wir nun die ersten Anfragen an die Threads API erstellen. Damit wir überhaupt erst einmal Zugriff auf die Ressourcen haben, müssen wir einen Autorisierungscode beantragen. Das passiert über eine URL, die wir im Browser eingeben müssen oder dem Benutzer öffnen. Diese URL sieht wie folgt aus:

```bash
https://threads.net/oauth/authorize?
client_id=[CLIENT ID]&
redirect_uri=[REDIRECT URL]
&scope=[VERGEBENE SCOPES]
&response_type=code
```

Hast du die Abfrage im Browser aufgerufen, erscheint eine Seite, die dich auf eine Verknüpfungsanfrage hinweist und dich dies nochmal prüfen und akzeptieren lässt:

![](https://blog.disane.dev/content/images/2024/06/image-8.png)

Wenn du fortfährst, dann wird der Autorisierungscode an die `REDIRECT URL` (die du in OAuth der App konfiguriert hast) übergeben. Eine Rückgabe würde wie folgt aussehen:

```json
{
  "code": "Dein Autorisierungscode"
}
```

Mit diesem Code kannst du dann einen Access-Token beantragen.

### Kurzlebigen Access-Token beantragen 🔑

Damit du nun Zugriff auf die Ressourcen hast, musst Autorisierungscode in einen Access-Token umwandeln lassen. Hier gibt es zwei Arten von Tokens:

* Kurzlebigen Access Tokens
* Langlebige Access Tokens

Beide haben ihre Vor- und Nachteile. Da du vermutlich einen längeren Zugriff haben möchtest als nur wenige Stunden, holen wir uns einen langlebigen Access Token. Dafür brauchen wir aber erst einen kurzlebigen, den wir dann zu einem langlebigen umwandeln.

Um einen kurzlebigen Access Token zu bekommen, musst du den Autorisierungscode an die API senden:

```bash
curl -X POST \
  https://graph.threads.net/oauth/access_token \
  -F client_id=[CLIENT ID] \
  -F client_secret=[CLIENT SECRET] \
  -F grant_type=authorization_code \
  -F redirect_uri=[REDIRECT URL] \
  -F code=[AUTH CODE]
```

Wenn alles geklappt hat, solltest du eine solche Rückgabe erhalten:

```json
{
  "access_token": "THQVJ...",
  "user_id": xyz
}
```

Beides solltest du dir nun zusätzlich auch noch speichern. Den Access Token brauchst du bei jeder Anfrage an die API, ebenso die `user_id`.

### Langlebigen Access Token erzeugen 🧬

Da wir nun aber die API mehr als nur ein paar Stunden nutzen möchten, musst du den kurzlebigen Access Token in einen langlebigen umwandeln. Das geht recht einfach mit dem nachfolgenden API-Call:

```bash
curl -i -X GET "https://graph.threads.net/access_token
  ?grant_type=th_exchange_token
  &client_secret=[CLIENT SECRET]
  &access_token=[SHORT_LIVED_ACCESS_TOKEN]"
```

Wenn alles geklappt hat, solltest du folgende Rückgabe erhalten:

```json
{
  "access_token": "<LONG_LIVED_USER_ACCESS_TOKEN>",
  "token_type": "bearer",
  "expires_in": 5183944  // number of seconds until token expires
}
```

Den `access_token`kannst du dir dann anstelle des kurzlebigen merken und weiter verwenden.

### Access Token erneuern ♻️

Beide Tokens laufen irgendwann einmal aus, der eine früher und der andere später. Darum gibt es auch die Möglichkeit Access Tokens zu erneuern, bevor sie abgelaufen sind.

Hierfür kannst du ganz einfach einen langlebigen Access Token nehmen und ihn an die API senden, dass sie dir einen neuen ausstellen soll:

```bash
curl -i -X GET "https://graph.threads.net/refresh_access_token
  ?grant_type=th_refresh_token
  &access_token=[LONG_LIVED_ACCESS_TOKEN]"
```

Hat auch das geklappt, kannst du auf diese Rückgabe hoffen:

```json
{
  "access_token": "<LONG_LIVED_USER_ACCESS_TOKEN>",
  "token_type": "bearer",
  "expires_in": 5183944 // number of seconds until token expires
}
```

Und damit hättest du auch schon einen neuen gültigen Access Token erzeugt.

## Posten von Inhalten 📷

Jetzt wird es langsam spannend. Du kannst dich nun authentifizieren und autorisieren. Fehlt eigentlich nur noch das Posten von Inhalten. Threads bietet eine Vielzahl an Inhalten an, die gepostet werden können. Welche möglich sind, kannst du in der API-Dokumentation nachlesen. 

[Posts - Threads API - Dokumentation - Meta for Developers![Preview image](https://facebook.com/security/hsts-pixel.gif?c=3.2)Publish a single image, video, text, or carousel post on Threads.](https://developers.facebook.com/docs/threads/posts)

Möchten wir nur einen einfachen Text oder ein Bild senden, können wir das recht elegant mit diesem API-Call machen. Hierfür brauchst du deine `THREADS_USER_ID`die du oben beim Generieren eines Access Tokens bekommen und hoffentlich gespeichert hast:

```bash
curl -i -X POST \
"https://graph.threads.net/v1.0/<THREADS_USER_ID>/threads?media_type=IMAGE&image_url=https://www.example.com/images/bronz-fonz.jpg&text=#BronzFonz&access_token=<ACCESS_TOKEN>"
```

In diesem Falle laden wir ein Bild von einer öffentlichen URL bei Threads hoch und fügen noch den Text `#BronzFronz`hinzu. Du musst aber nicht nur Bilder hochladen, sondern kannst auch nur Texte mit URLs oder ähnliche Sachen hochladen. 

```json
{
  "id": "1234567" // Threads Media Container ID
}
```

Damit hast du aber nur einen Media-Container angelegt. Zu dem Zeitpunkt ist noch nichts hochgeladen worden! Das musst du separat mit einem eigenen API-Call machen. Hierfür brauchst du die `id`aus der vorherigen Rückgabe:

```bash
curl -i -X POST \ 
"https://graph.threads.net/v1.0/<THREADS_USER_ID>/threads_publish?creation_id=<MEDIA_CONTAINER_ID>&access_token=<ACCESS_TOKEN>"
```

Hat das geklappt, solltest du eine solche Rückgabe bekommen:

```json
{
  "id": "1234567" // Threads Media ID
}
```

Und du solltest deinen neuen Post nun auf Threads sehen! Gratulation 🎉

Die API kann aber nicht nur Posten. Du kannst damit auch komplett andere Dinge tun und dir Daten aus Threads für Analysezwecke ziehen. Aber schau einfach mal in die API-Doku hinein, da findest du sicher noch sehr schöne Anwendungsfälle.

## Fazit 📃

Du hast nun gelernt wie man die Threads API nutzt und kannst nun automatisiert Dinge dort hochladen. Wie einfach das geht, habe ich dir jetzt gezeigt. Es ist auf jeden Fall für Creator oder Geschäfte/Unternehmen sehr reizvoll, darauf Workflows auszurichten und z.B. Cross-Posts bei Threads zu realisieren.

Diesen Post wirst du vermutlich nun auch bei Threads gesehen haben, der wurde auch automatisch über die API hochgeladen 😉

---

If you like my posts, it would be nice if you follow my [Blog](https://blog.disane.dev) for more tech stuff.