Raccogli le discussioni delle community di Twitter/X con SocQ e tieni insieme testo dei post, autori, orari di pubblicazione e fonti. Trasforma le domande ricorrenti in idee per i contenuti, con i post originali allegati a ogni risultato per una revisione successiva.
Questo tutorial usa X Community Posts di SocQ per raccogliere i post e X Community per interrogare descrizione e regole. Gli esempi producono un JSON che conserva le fonti e un’esportazione CSV organizzata per community.
Risposta rapida: invia i link
x.com/i/communities/{id}aPOST /v1/x/community-posts, salva l’ID dell’attività e leggi tutte le pagine dei risultati dopo il completamento. Interroga i metadati conPOST /v1/x/communityusando lo stesso link. Allega la community di input a ogni post per collegare metadati e discussioni.
Usare l’URL di una community pubblica come input
Usa un URL di questa forma, sostituendolo con la community pubblica che vuoi analizzare:
https://x.com/i/communities/1493446837214187523
Il segmento numerico è l’ID della community. Entrambi gli endpoint delle community accettano un URL completo /i/communities/{numeric_id}.
Se conosci solo il nome della community, trova prima il suo URL pubblico e invia il link in urls.
Salva l’URL inviato, l’ID numerico della community, l’orario di pubblicazione (published_at) e l’orario di raccolta (collected_at). Abbina le varianti x.com e twitter.com supportate tramite l’ID della community e tieni separate le community con ID diversi anche quando i nomi coincidono.
Raccogliere i post dal feed di una community di Twitter/X
Imposta SOCQ_API_KEY e invia un’attività con un tetto di 40 post per community:
curl -X POST "https://api.socq.ai/v1/x/community-posts" \
-H "Authorization: Bearer $SOCQ_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"urls": ["https://x.com/i/communities/1493446837214187523"],
"results_limit": 40
}'
La risposta fornisce data.task_id. Salvalo, poi interroga l’attività esistente:
curl "https://api.socq.ai/v1/tasks/$TASK_ID?limit=100" \
-H "Authorization: Bearer $SOCQ_API_KEY"
Attendi tra una richiesta e l’altra finché l’attività è queued, running o retrying. Un’attività failed espone data.error_message. Quando è succeeded, i record dei post si trovano in data.results.items.
Community Posts restituisce i record in ordine di data di creazione. Per un report ordinato per like o commenti, ordina localmente i record raccolti e indica l’output come classifica del campione.
Capire i limiti per community
results_limit ha come valore predefinito 100 e accetta multipli di 20 da 20 a 2.000, come 20, 40, 60 e 100.
Il tetto si applica a ogni community di input. Due URL con results_limit=40 richiedono fino a 40 post ciascuno; il numero effettivo è determinato dai risultati deduplicati salvati.
Il limit della query dell’attività stabilisce quanti record salvati leggere per pagina e next_cursor indica la pagina successiva. Il results_limit inviato stabilisce il tetto di raccolta.
Sapere quali dati della community ottieni
| Risorsa | Campi standard | Domanda di ricerca |
|---|---|---|
| Community | name, text, rules, join_policy, invites_policy | Quali descrizione, regole e policy di partecipazione sono state registrate? |
| Conteggi della community | metrics.members_count, metrics.moderators_count | Quanti membri e moderatori indica la fonte? |
| Community Posts | id, text, author, published_at, media | Quali discussioni ci sono nella finestra raccolta? |
| Metriche dei post | Conteggi disponibili di like, commenti, condivisioni e visualizzazioni | Come si confrontano i post campionati al momento della raccolta? |
La richiesta dei metadati è separata:
curl -X POST "https://api.socq.ai/v1/x/community" \
-H "Authorization: Bearer $SOCQ_API_KEY" \
-H "Content-Type: application/json" \
-d '{"urls":["https://x.com/i/communities/1493446837214187523"]}'
Recupera i metadati con il proprio ID attività. I totali di membri e moderatori descrivono la dimensione della community, mentre il conteggio delle visualizzazioni di un post registra le visualizzazioni di quel post. Il numero di autori attivi e la copertura unica richiedono misurazioni separate.
Null significa che la fonte ha omesso una misurazione; 0 è un conteggio pari a zero restituito. Conserva i due valori in modo distinto nella tua esportazione.
Esportare i post delle community in JSON e CSV con Python
Il flusso di lavoro seguente usa la libreria standard di Python. Salva questo helper per le attività come 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")
L’helper stampa ogni ID attività, attende fino a dieci minuti e legge ogni pagina di risultati salvata. Dopo un timeout del client, conserva l’ID e riprendi a interrogare quell’attività.
Poi salva export_communities.py accanto al primo file:
import csv
import json
import sys
from urllib.parse import urlparse
from socq_collect import collect
urls = list(dict.fromkeys(sys.argv[1:]))
if not urls:
raise SystemExit("Usage: python3 export_communities.py COMMUNITY_URL [COMMUNITY_URL...]")
def cell(value):
text = "" if value is None else str(value)
return "'" + text if text.lstrip().startswith(("=", "+", "-", "@")) else text
fields = ["community_id", "community_url", "post_id", "post_url", "text",
"author_id", "author_username", "published_at", "collected_at",
"likes_count", "comments_count", "shares_count", "views_count"]
bundles, seen = [], set()
with open("community-posts.csv", "w", newline="", encoding="utf-8-sig") as output:
writer = csv.DictWriter(output, fieldnames=fields)
writer.writeheader()
for url in urls:
metadata_task, communities = collect("x/community", {"urls": [url]})
posts_task, posts = collect("x/community-posts", {
"urls": [url], "results_limit": 40,
})
bundles.append({
"input_url": url, "metadata_task_id": metadata_task,
"posts_task_id": posts_task, "communities": communities, "posts": posts,
})
# Save completed collections before processing another community.
with open("community-results.json", "w", encoding="utf-8") as saved:
json.dump(bundles, saved, ensure_ascii=False, indent=2)
community_id = urlparse(url).path.rstrip("/").split("/")[-1]
for post in posts:
post_id = post.get("id")
key = (community_id, post_id)
if post_id and key in seen:
continue
if post_id:
seen.add(key)
author = post.get("author") or {}
metrics = post.get("metrics") or {}
row = {
"community_id": community_id, "community_url": url,
"post_id": post_id, "post_url": post.get("url"), "text": post.get("text"),
"author_id": author.get("id"), "author_username": author.get("username"),
"published_at": post.get("published_at"),
"collected_at": post.get("collected_at"),
**{name: metrics.get(name) for name in
("likes_count", "comments_count", "shares_count", "views_count")},
}
writer.writerow({key: cell(value) for key, value in row.items()})
Eseguilo con uno o più URL di community pubbliche:
python3 export_communities.py \
"https://x.com/i/communities/1493446837214187523"
Ottieni due output:
community-results.jsonconserva ogni URL di input, entrambi gli ID attività, i metadati della community e i record dei post.community-posts.csvfornisce una riga per ogni post restituito all’interno di ciascuna community, con fonte, autore, timestamp e metriche disponibili.
L’esempio crea attività separate per i metadati e per i post di ogni community, allegando la community di input ai suoi post. Così la fonte di raccolta di ogni record è esplicita. Usa un batch per un recupero combinato, oppure il modello a community singola mostrato qui quando ti serve l’attribuzione della fonte per ogni post.
La deduplicazione usa community_id + post_id. Unisce le righe ripetute all’interno di una community e mantiene separate le osservazioni dello stesso post provenienti da community diverse. I record senza ID del post vengono conservati singolarmente.
Il programma aggiorna i file dopo il completamento di ogni community. Se una richiesta successiva fallisce, i file conservano le community completate in precedenza. Prima di usare l’output in un report, controlla gli input completati e gli errori registrati.
Tenere il JSON come fonte per le esportazioni in foglio di calcolo
Il CSV è comodo per chi fa la revisione, ma appiattisce i dati. Regole annidate, media e campi dell’autore restano disponibili nel JSON. Rigenera un foglio di calcolo diverso da quel JSON salvato quando le tue colonne cambiano.
L’esempio usa il writer CSV della libreria standard di Python per gestire virgolette, virgole e testo su più righe. L’UTF-8 con byte-order mark facilita le importazioni nei fogli di calcolo più comuni. Il testo pubblico che sembra una formula viene sottoposto a escape nel CSV; il JSON conserva il contenuto originale. Importa come testo gli ID numerici lunghi per evitare perdite di precisione nel foglio di calcolo.
Usare le discussioni delle community per la ricerca sugli argomenti
Per esempio, chiediti quali domande di onboarding ricorrono in queste discussioni raccolte. Raggruppale per domanda e conserva gli ID dei post a supporto di ciascuna categoria.
Leggi prima la descrizione e le regole della community. Poi esamina insieme testo dei post, orario di pubblicazione e link alle fonti. Raggruppa le domande ricorrenti, le lamentele sul prodotto o le richieste di risorse e tieni gli ID dei post a supporto accanto alle tue etichette.
Usa il flusso di lavoro per i dettagli della community per salvare descrizioni e regole, poi esegui la classificazione o il riepilogo degli argomenti nella tua applicazione.
Indica un ordinamento locale per like o commenti come “classifica all’interno di questa raccolta”, con il momento della raccolta e il numero di record. Segna un post assente da una raccolta successiva come “non osservato in questa raccolta”; interroga quel post separatamente per verificare un’eventuale eliminazione.
Esaminare una singola discussione
Per espandere una discussione, invia l’URL del post restituito a X Thread Context e leggi il post di destinazione, i post precedenti della catena di risposte e le relazioni tra le risposte.
Per questo passaggio successivo, leggi il tutorial sul contesto dei thread di Twitter. Se ti servono solo le risposte a un post noto, usa X Post Replies. Se il tuo punto di partenza è un account e non una community, usa X User Posts.
Tenere i post originali alla base delle tue decisioni sui contenuti
Gli endpoint SocQ per metadati e post delle community collegano identificazione della community, raccolta delle discussioni e revisione degli argomenti. Il codice conserva la community di origine di ogni post ed esporta JSON e CSV, così i team che si occupano di contenuti possono rivedere le domande, organizzare gli esempi e preparare gli input per i riepiloghi.
Apri Community Posts e raccogli la tua community di destinazione.
Fonti e approfondimenti
- Documentazione di SocQ Community Posts – link accettati, limiti per community e campi standard dei post.
- Documentazione di SocQ Community – metadati, regole e conteggi.
Domande frequenti (FAQ)
Posso raccogliere i post di più community di X?
Sì. Invia più URL di community in urls. Il tetto dei risultati si applica a ogni URL. L’esempio di esportazione in Python usa attività separate per conservare una chiara community di input come fonte di ogni post.
Questo restituisce ogni post mai pubblicato in una community?
Un’attività legge una selezione di post dalla community indicata, entro il tetto di results_limit. I record restituiti definiscono l’ambito di quella raccolta. Per l’analisi storica, salva raccolte separate e indica l’ambito di ciascuna.
Posso esportare anche i membri della community oltre ai post?
Community restituisce metadati e conteggi di membri e moderatori; Community Posts restituisce i post. Gli elenchi dei singoli membri sono dati separati e questi endpoint non li restituiscono.
In che cosa il feed di una community è diverso dalla timeline di un utente?
Il feed di una community raggruppa i post di uno spazio di discussione; la timeline di un utente raggruppa i post di un account. Usa i link delle community per Community Posts e i nomi utente per User Posts.
Posso scegliere l’ordinamento Top o per like?
L’endpoint restituisce l’ordine di data di creazione. Ordina il campione per like o commenti nella tua applicazione per ottenere una classifica per metrica di quella raccolta.
La paginazione raccoglie i nuovi post?
Il cursore legge la pagina successiva salvata dall’attività originale. Invia una nuova attività per ottenere un’osservazione aggiornata, poi gestisci i record sovrapposti tramite l’ID del post.
Come raccolgo i post dopo l’annuncio della migrazione delle community?
X ha pubblicato un annuncio sulla migrazione da Communities a XChat. Invia l’URL della community di destinazione a Community Posts e leggi i post restituiti dopo il completamento. Registra separatamente risultati vuoti ed errori e conserva i momenti di raccolta per distinguere la cronologia salvata da ogni nuova interrogazione.
X API
Prova il flusso di lavoro con un URL pubblico di X
Invia input pubblici e ricevi record normalizzati con un contesto di origine tracciabile.
Scopri le API di X