Führen Sie mit SocQ Ziel-Posts, vorangehenden Kontext und Antwortbeziehungen zusammen. Ordnen Sie Twitter/X-Diskussionen danach, wer wem geantwortet hat, und nutzen Sie Konversations- und Eltern-IDs zum Lesen, Prüfen, Zusammenfassen und Filtern von Autoren-Threads.
Die SocQ X Thread Context API fragt den öffentlichen Ziel-Post, frühere Posts der Antwortkette und von der Quelle zurückgegebene Antworten ab. Diese Anleitung behandelt Erfassung, Gruppierung nach Konversation, Eltern-Kind-Exporte und das Filtern von Autoren-Threads.
Kurzantwort: Senden Sie die URL eines öffentlichen Posts an
POST /v1/x/thread-contextund lesen Sie die Ergebnisseiten der abgeschlossenen Aufgabe. Gruppieren Sie nachconversation_idund verbinden Sie direkte Eltern-Posts überin_reply_to_id. Fehlt der Inhalt eines Eltern-Posts, behalten Sie seine Referenz bei und markieren Sie die Lücke.
Post-Abfrage, Antworten oder Thread-Kontext wählen
| Was Sie brauchen | SocQ-Endpunkt | Ausgangseingabe |
|---|---|---|
| Den ausgewählten Post selbst | X Posts | URLs öffentlicher Posts |
| Antworten auf einen ausgewählten Post | X Post Replies | URLs öffentlicher Posts |
| Das Ziel, frühere Posts der Antwortkette und verfügbare Antworten | X Thread Context | URLs öffentlicher Posts |
| Posts, die innerhalb einer Community geteilt wurden | X Community Posts | URLs öffentlicher Communities |
Mit Thread Context lesen Sie die Diskussion, die dem ausgewählten Post vorausgeht. „Frühere Posts“ sind Posts, die man erreicht, wenn man direkten Eltern-Beziehungen rückwärts folgt.
Wenn zum Beispiel B auf A antwortet und C auf B, lautet die Elternkette von C: C → B → A. Die Konversations-IDs bestimmen die Gruppierung, die IDs der Eltern-Posts die Verbindungen, und die Veröffentlichungszeiten liefern die chronologische Reihenfolge der Anzeige.
Nach der Erfassung übergeben Sie Text und Beziehungsdaten an eine Leseoberfläche oder an einen separaten Workflow zur Zusammenfassung.
Thread-Kontext anhand der URL eines öffentlichen Posts abrufen
Verwenden Sie eine öffentliche URL der Form /status/{numeric_id} und ersetzen Sie das Beispiel durch den Post, den Sie untersuchen möchten:
curl -X POST "https://api.socq.ai/v1/x/thread-context" \
-H "Authorization: Bearer $SOCQ_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"urls": ["https://x.com/BaganiTohid/status/2110635249889919362"],
"results_limit": 100
}'
Die Eingabe akzeptiert Links zu öffentlichen X- und Twitter-Posts, auch zu einer Antwort aus der Mitte einer Diskussion. Tragen Sie die vollständige URL der Form /status/{numeric_id} in urls ein.
data.task_id in der Antwort kennzeichnet die Hintergrundaufgabe. Bewahren Sie sie auf und fragen Sie ab:
curl "https://api.socq.ai/v1/tasks/$TASK_ID?limit=100" \
-H "Authorization: Bearer $SOCQ_API_KEY"
Warten Sie, solange die Aufgabe queued, running oder retrying ist. Bei failed prüfen Sie data.error_message. Bei succeeded lesen Sie data.results.items und fahren mit next_cursor fort, solange has_more wahr ist.
results_limit hat den Standardwert 100 und akzeptiert pro Eingabe-URL ganze Zahlen von 1 bis 2000. Zwei URLs mit einer Obergrenze von je 100 fordern jeweils unabhängig bis zu 100 Datensätze an. Entfernen Sie beim Zusammenführen mehrerer Erfassungen derselben Konversation Duplikate anhand der Post-ID.
Thread Context akzeptiert jede ganze Zahl innerhalb dieses Limitbereichs. Bauen Sie die Eltern-Kind-Verbindungen nach dem Abruf aus den Beziehungsfeldern auf und nutzen Sie die Array-Reihenfolge, um die Datensätze zu durchlaufen.
Konversations-IDs und IDs von Eltern-Posts verstehen
Die beiden Beziehungsfelder erfüllen unterschiedliche Zwecke:
| Feld | Bedeutung | Verarbeitung |
|---|---|---|
conversation_id | Die Konversation, zu der der Post gehört | Datensätze mit demselben Wert gruppieren |
in_reply_to_id | Die ID des direkten Eltern-Posts | Diese ID nachschlagen und die Posts verbinden |
id | Die Kennung des aktuellen Posts | Posts indizieren und Duplikate entfernen |
Die folgenden Beispieldaten veranschaulichen die Beziehungen:
| Post | Autor | Konversation | Direkter Eltern-Post |
|---|---|---|---|
| A | Alice | A | Keiner angegeben |
| B | Alice | A | A |
| C | Bob | A | B |
| D | Alice | A | C |
Alle vier Posts gehören zur Konversation A, und der direkte Eltern-Post von D ist C. Die Verbindung über die Eltern-ID erhält den Antwortpfad D → C → B → A.
Definitionen finden Sie in der Feldreferenz zu Thread Context. Verwenden Sie die Konversations-ID und die ID des direkten Eltern-Posts jeweils für den Schritt der Gruppierung und den der Verknüpfung.
Standarddatensätze enthalten außerdem Text, Autoren, Veröffentlichungs- und Erfassungszeiten, Medien und Interaktionszahlen. Felder, die die Quelle auslässt, bleiben null.
Gespeicherte Ergebnisseiten mit Python erfassen
Speichern Sie diesen Helfer, der nur die Standardbibliothek nutzt, als socq_collect.py:
import json
import os
import time
from urllib.parse import urlencode
from urllib.request import Request, urlopen
BASE = "https://api.socq.ai/v1"
PENDING = {"queued", "running", "retrying"}
def api(method, path, payload=None):
body = json.dumps(payload).encode("utf-8") if payload is not None else None
request = Request(
BASE + path, data=body, method=method,
headers={
"Authorization": "Bearer " + os.environ["SOCQ_API_KEY"],
"Content-Type": "application/json",
},
)
with urlopen(request, timeout=60) as response:
result = json.load(response)
if result.get("code") != 200:
raise RuntimeError(result)
return result["data"]
def collect(endpoint, payload):
task_id = api("POST", "/" + endpoint, payload)["task_id"]
print("Task:", task_id, flush=True)
path = "/tasks/" + task_id
deadline = time.monotonic() + 600
data = api("GET", path + "?limit=100")
while data["status"] in PENDING:
if time.monotonic() >= deadline:
raise TimeoutError("Resume GET " + path + "; do not resubmit automatically")
time.sleep(2)
data = api("GET", path + "?limit=100")
if data["status"] != "succeeded":
raise RuntimeError(data.get("error_message") or data["status"])
items, seen_cursors = [], set()
while True:
if time.monotonic() >= deadline:
raise TimeoutError("Resume pagination for " + task_id)
page = data["results"]
items.extend(page["items"])
if not page["has_more"]:
return task_id, items
cursor = page.get("next_cursor")
if not cursor or cursor in seen_cursors:
raise RuntimeError("Missing or repeated result cursor")
seen_cursors.add(cursor)
data = api("GET", path + "?" + urlencode({"limit": 100, "cursor": cursor}))
if data["status"] != "succeeded":
raise RuntimeError("Task is not ready for result pagination")
Speichern Sie das nächste Skript als collect_thread.py im selben Verzeichnis:
import json
import sys
from socq_collect import collect
if len(sys.argv) != 2:
raise SystemExit("Usage: python3 collect_thread.py PUBLIC_POST_URL")
payload = {"urls": [sys.argv[1]], "results_limit": 100}
task_id, posts = collect("x/thread-context", payload)
with open("thread-context.json", "w", encoding="utf-8") as output:
json.dump({"task_id": task_id, "input": payload, "items": posts},
output, ensure_ascii=False, indent=2)
Setzen Sie SOCQ_API_KEY und führen Sie das Skript mit dem ausgewählten öffentlichen Post aus:
python3 collect_thread.py \
"https://x.com/BaganiTohid/status/2110635249889919362"
thread-context.json speichert die Eingabelinks, die Aufgaben-ID und die Datensätze. Der Helfer wartet clientseitig bis zu zehn Minuten. Behalten Sie nach einer Zeitüberschreitung die ausgegebene Aufgaben-ID und prüfen Sie die Serveraufgabe weiter.
Die Paginierung liest die von dieser Aufgabe gespeicherten Datensätze. Wenn Sie jede Seite lesen, erhalten Sie die vollständige gespeicherte Ergebnismenge; die Datensätze und Lückenmarker beschreiben die Abdeckung der Konversation.
Antwortbeziehungen über die ID des direkten Eltern-Posts aufbauen
Indizieren Sie die Posts nach ID und ergänzen Sie dann Eltern-Kind-Verknüpfungen. Fehlt der Inhalt eines referenzierten Eltern-Posts, behalten Sie die ID bei und setzen parent_in_dataset auf false.
Speichern Sie dies als build_thread.py:
import json
import sys
if len(sys.argv) not in (2, 3):
raise SystemExit("Usage: python3 build_thread.py INPUT_JSON [THREAD_AUTHOR_ID]")
with open(sys.argv[1], encoding="utf-8") as source:
records = json.load(source)["items"]
author_id = sys.argv[2] if len(sys.argv) == 3 else None
nodes, missing_id_records = {}, []
for post in records:
if post.get("id"):
nodes[str(post["id"])] = post
else:
missing_id_records.append(post)
edges, groups, unknown_conversation_ids, unknown_parent_ids = [], {}, [], []
for post_id, post in nodes.items():
conversation_id = post.get("conversation_id")
if conversation_id:
groups.setdefault(str(conversation_id), []).append(post_id)
else:
unknown_conversation_ids.append(post_id)
parent_id = post.get("in_reply_to_id")
if parent_id is None:
unknown_parent_ids.append(post_id)
else:
parent_id = str(parent_id)
edges.append({
"parent_id": parent_id, "child_id": post_id,
"parent_in_dataset": parent_id in nodes,
})
self_reply_edges = []
if author_id:
for edge in edges:
parent = nodes.get(edge["parent_id"])
child = nodes[edge["child_id"]]
if parent and edge["parent_id"] != edge["child_id"]:
parent_author = (parent.get("author") or {}).get("id")
child_author = (child.get("author") or {}).get("id")
if parent_author == author_id and child_author == author_id:
self_reply_edges.append(edge)
graph = {
"nodes": list(nodes.values()), "edges": edges, "conversation_groups": groups,
"missing_parent_ids": sorted({
edge["parent_id"] for edge in edges if not edge["parent_in_dataset"]
}),
"unknown_conversation_post_ids": unknown_conversation_ids,
"unknown_parent_post_ids": unknown_parent_ids,
"records_without_id": missing_id_records,
"selected_author_id": author_id, "selected_author_self_reply_edges": self_reply_edges,
}
with open("thread-graph.json", "w", encoding="utf-8") as output:
json.dump(graph, output, ensure_ascii=False, indent=2)
Erstellen Sie den Beziehungsexport:
python3 build_thread.py thread-context.json
Die entstehende Datei thread-graph.json enthält:
- Eindeutig identifizierbare Post-Knoten sowie gesondert aufbewahrte Datensätze ohne ID.
- Eltern-Kind-Kanten, wobei
parent_in_datasetangibt, ob der Eltern-Post vorhanden ist. - Gruppen für bekannte Konversations-IDs und eine separate Liste für fehlende Konversations-IDs.
- Referenzierte Eltern-IDs, zu denen kein erfasster Post gehört.
- Post-IDs, deren Feld für den direkten Eltern-Post null ist.
in_reply_to_id=null bedeutet, dass der Datensatz keine Referenz auf einen direkten Eltern-Post liefert; das Programm nimmt ihn in unknown_parent_post_ids auf. Existiert eine Eltern-ID, fehlt der zugehörige Datensatz aber im Index, behalten Sie die Kante bei und markieren den fehlenden Eltern-Post.
Der Export erhält Konversationsgruppen, bekannte Kanten und Marker für fehlende Datensätze. Eine Leseoberfläche kann verbundene Zweige und Kontextlücken getrennt anzeigen.
Thread eines Autors von Antworten der Leser trennen
In den Beispieldaten hat Alice A, B und D geschrieben. Von A zu B ist es ein Selbstantwort-Abschnitt des Autors, während D Alices Antwort an Bob ist. Filtern Sie nach der Autoren-ID, um alle Aussagen des Autors zu lesen, und prüfen Sie dann die Autoren-IDs von Eltern- und Kind-Post, um Selbstantwort-Abschnitte zu erkennen.
Kennen Sie die Konto-ID des Thread-Autors, übergeben Sie diese Zeichenfolge als zweites Argument:
python3 build_thread.py thread-context.json THREAD_AUTHOR_ID
selected_author_self_reply_edges speichert Kanten, bei denen Eltern- und Kind-Post vom angegebenen Autor stammen. Bestätigen Sie diese Autoren-ID vor dem Filtern; der Eingabelink kann den Post des Autors oder die Antwort eines Lesers bezeichnen.
Wählen Sie einen zusammenhängenden Selbstantwort-Abschnitt rund um den Post des Autors, den Sie lesen möchten. Hat der Autor mehrere Selbstantworten auf einen Eltern-Post, behält der Export diese Zweige bei, sodass die Leseoberfläche den Anzeigeumfang festlegen kann.
Bewahren Sie die vollständigen Datensätze und die nach Autor gefilterte Ansicht zusammen auf, damit spätere Lesefilter auf die Originaldaten zugreifen können.
Kontext zum Lesen, Prüfen oder Zusammenfassen exportieren
Zeigen Sie in der Leseoberfläche Quell-URLs, Autoren, Veröffentlichungszeiten und Eltern-Beziehungen an, mit Markern für fehlende Eltern-Posts. Speichern Sie das Beziehungs-JSON neben Text- oder Markdown-Exporten, um die Struktur später rekonstruieren zu können.
Ein Workflow zur Zusammenfassung liest Post-Text und Beziehungen, behandelt Aussagen des Autors und Reaktionen der Leser getrennt und behält die Marker für Kontextlücken bei. Thread Context liefert die Datensätze; Ihr Modell oder Ihre Anwendung erzeugt die Zusammenfassung.
Wenn Sie Aufgaben derselben Konversation zusammenführen, entfernen Sie Duplikate anhand der Post-ID und behalten Eingabelinks und Aufgaben-IDs bei. Posts, die in einer späteren Erfassung fehlen, bleiben unter ihrer ursprünglichen Erfassungszeit erhalten.
Um Diskussionen vor der Untersuchung zu finden, nutzen Sie die Anleitung zur Erfassung von Communities oder den Leitfaden zu X-Suche und -Erfassung.
Einen Kontext-Datensatz für Lesen, Prüfung und Zusammenfassungen nutzen
SocQ Thread Context legt Post-Text und Beziehungs-IDs in denselben Standardergebnissen ab. Mit dem Code gruppieren Sie Konversationen, exportieren Antwortbeziehungen und erstellen eine nach Autor gefilterte Ansicht. Leseoberflächen und Workflows zur Zusammenfassung können diese Datensätze samt Quellen und Markern für Kontextlücken wiederverwenden.
Thread Context öffnen und die Zieldiskussion erkunden.
Quellen und weiterführende Literatur
- SocQ-Dokumentation zu Thread Context – öffentliche Eingaben, Obergrenzen und Standard-Beziehungsfelder.
Häufig gestellte Fragen (FAQ)
Kann ich bei einer Antwort statt beim ersten Post beginnen?
Ja. Tragen Sie die URL dieser öffentlichen Antwort in urls ein. Die Aufgabe liest das Ziel, öffentliche vorangehende Posts und von der Quelle zurückgegebene Antworten bis zur konfigurierten Obergrenze.
Ist das dasselbe wie das Abrufen von Antworten auf einen Post?
Post Replies konzentriert sich auf Antworten auf den ausgewählten Post. Thread Context liest das Ziel, vorangehende Posts und Antworten, um den Kontext über Antwortbeziehungen zu ordnen.
Liefert die API jede Antwort einer Konversation?
Die Aufgabe erfasst öffentliche Datensätze bis zum results_limit jeder Eingabe. Wenn Sie alle Seiten lesen, erhalten Sie die in dieser Erfassung gespeicherten Posts; beurteilen Sie die Abdeckung der Diskussion zusätzlich anhand der Datensätze zu fehlenden Eltern-Posts und zu Antworten.
Wie gehe ich mit Antworten auf Antworten um?
Verbinden Sie direkte Eltern-Posts über in_reply_to_id und gruppieren Sie Konversationen mit conversation_id. Behalten Sie die ID eines fehlenden Eltern-Posts bei und zeigen Sie einen Lückenmarker an.
Warum fehlt ein referenzierter Eltern-Post?
Die Referenz auf den Eltern-Post wurde zurückgegeben, sein Inhalt fehlt aber in dieser Erfassung. Behalten Sie die Referenz bei und fragen Sie den Post ab, wenn Sie mehr Kontext brauchen; einen konkreten Grund für sein Fehlen können Sie nur aus von der Quelle gemeldeten Informationen ableiten.
Wie behalte ich nur den Thread des ursprünglichen Autors?
Bestätigen Sie die Autoren-ID und behalten Sie Kanten, bei denen Eltern- und Kind-Post von diesem Autor stammen. Wählen Sie einen zusammenhängenden Abschnitt rund um den Ziel-Post und legen Sie den Anzeigeumfang fest, wenn sich Selbstantworten verzweigen.
Kann ich den Thread für eine KI-Zusammenfassung speichern?
Ja. Speichern Sie erfassten Text, Autoren, Zeiten und Beziehungen als JSON und führen Sie anschließend einen separaten Schritt zur Zusammenfassung aus. Bewahren Sie Marker für fehlenden Kontext und Quell-URLs zusammen mit der Zusammenfassung auf.
X API
Workflow mit einer öffentlichen X-URL testen
Senden Sie öffentliche Eingaben und erhalten Sie normalisierte Datensätze mit nachvollziehbarem Quellkontext.
X-APIs ansehen