API e server MCP di LKDN Autopilot

Con le API di LKDN Autopilot i tuoi programmi, il tuo CRM, le tue automazioni (n8n, Make, Zapier) e i tuoi assistenti AI (Claude, ChatGPT) usano il tuo account LinkedIn collegato, attraverso di noi: leggono le conversazioni e i collegamenti, cercano persone, inviano messaggi e richieste di collegamento, pubblicano e commentano.

Tre cose da sapere prima di tutto:

1. Un solo account, il tuo. La chiave è legata al tuo account LKDN Autopilot e al tuo account LinkedIn. Non si collegano altri account e non si sceglie un account: la chiave sa già qual è.
2. Un solo budget, condiviso con il pilota automatico. Ogni visita, richiesta di collegamento, messaggio, commento, reazione e post fatto dalle API consuma lo stesso budget giornaliero del pilota automatico, con gli stessi limiti e le stesse pause tra un'azione e l'altra. Se le API usano 5 richieste di collegamento, il pilota automatico ne avrà 5 in meno quel giorno. È così che il tuo account resta al sicuro.
3. Le conversazioni non le conserviamo. Quando leggi una chat dalle API, la leggiamo in quel momento dal tuo account e te la passiamo. Non la salviamo nei nostri archivi né nei nostri log: se ti serve conservarla, la conserva il tuo CRM.

L'accesso alle API si attiva su richiesta, per account: scrivici a info@lkdnautopilot.com.

Indice #

• Iniziare in cinque minuti
• Chiavi e autenticazione
• Limiti e budget condiviso
• Formato delle risposte
• Idempotency-Key
• Modalità simulata
• Endpoint
• Webhook
• Server MCP: Claude, ChatGPT, n8n
• Prompt pronti
• Errori
• Privacy e responsabilità
• Cosa non fa

Iniziare in cinque minuti #

1. Nell'app vai su API e integrazioni (in alto nella pagina iniziale).
2. Crea una chiave: un nome (per esempio "il mio CRM") e cosa può fare, solo lettura oppure lettura e scrittura. La chiave compare una volta sola: copiala e conservala in un posto sicuro.
3. Prova:

curl https://ayuhpqrbmizgsjstmcrt.supabase.co/functions/v1/public-api/v1/me \
  -H "Authorization: Bearer lkdn_sk_LA_TUA_CHIAVE"

La risposta è il tuo profilo, lo stato del collegamento e il piano LinkedIn rilevato:

{
  "data": {
    "id": "per_3mQ8...",
    "name": "Giulia Demo",
    "headline": "Consulente, Demo Consulting Srl",
    "public_identifier": "giulia-demo",
    "linkedin_status": "connected",
    "linkedin_plan": "premium",
    "inmail_credits": 5,
    "simulated": false
  }
}

L'indirizzo base di tutte le chiamate è:

https://ayuhpqrbmizgsjstmcrt.supabase.co/functions/v1/public-api/v1

La specifica OpenAPI completa è in openapi.json: importala in Postman, Insomnia o in un generatore di client.

Chiavi e autenticazione #

Ogni richiesta porta la chiave nell'intestazione:

Authorization: Bearer lkdn_sk_...

• Una chiave ha uno o due permessi: read (leggere) e write (agire: messaggi, inviti, post, commenti, reazioni, visite, webhook). Una chiave di sola lettura che prova ad agire riceve 403 insufficient_scope.
• Puoi avere fino a 5 chiavi attive. Dai una chiave diversa a ogni programma: se una va revocata, gli altri continuano a funzionare.
• La revoca è immediata: la richiesta successiva con quella chiave riceve 401 invalid_api_key.
• Noi conserviamo solo un'impronta della chiave (un hash), mai la chiave stessa: se la perdi, creane una nuova.
• La chiave sta su un server, mai in una pagina web o in un'app nel browser. Le API non rispondono alle chiamate dirette da un browser.

Limiti e budget condiviso #

Il tuo account LinkedIn ha un budget giornaliero, uguale per il pilota automatico e per le API. Lo decidiamo in un solo punto, con le stesse regole: il piano LinkedIn rilevato, il periodo di riscaldamento di un account nuovo, i limiti che hai scelto tu e quelli che possiamo abbassare noi se l'account è a rischio. Le API non possono superarlo, in nessun caso.

Sono i valori predefiniti: quelli del tuo account possono essere più bassi (riscaldamento, piano gratuito, limiti scelti da te). Quelli veri, di oggi, sono sempre in GET /v1/usage, insieme a quanto hai già usato e quanto hanno usato le API.

Altre regole che proteggono l'account:

• Le azioni sono distanziate. Tra un'azione e la successiva sul tuo profilo passano alcuni minuti, con un intervallo casuale, come farebbe una persona. Se chiedi un'azione troppo presto ricevi 429 action_paced con Retry-After in secondi.
• Le azioni verso persone nuove seguono il tuo orario di attività. Visite, richieste di collegamento e InMail partono solo nei giorni e nelle ore che hai scelto nell'app (fuori orario: 429 outside_activity_window). Messaggi nelle conversazioni, commenti, reazioni e post no.
• Le persone che non vanno contattate non si contattano. Chi ha chiesto di non essere contattato, chi hai escluso, chi appartiene alle categorie che non contattiamo (per esempio il network marketing) riceve 403 person_not_contactable, anche dalle API.
• Chi contatti dalle API non lo ricontatta il pilota automatico. La persona diventa tua: il pilota automatico la salta da quel momento.
• Un rifiuto definitivo di LinkedIn resta definitivo. Se LinkedIn non accetta più richieste verso una persona, l'API risponde 422 invitation_not_allowed e non riprova.
• Richieste alle API: al massimo 60 al minuto per chiave e 2000 al giorno per account, letture comprese (429 rate_limited, 429 daily_request_limit).

Ogni 429 ha l'intestazione Retry-After: dopo quanti secondi riprovare. Quando il budget del giorno è finito, Retry-After punta all'apertura del prossimo orario di attività. Un agente AI che riceve un 429 deve fermarsi e dirlo, non riprovare in ciclo.

Formato delle risposte #

Le risposte sono JSON, con nomi in inglese e sempre gli stessi:

• un oggetto: {"data": {...}}
• un elenco: {"data": [...], "page": {"next_cursor": "cur_..." }}; per la pagina successiva passa cursor=cur_...; next_cursor è null all'ultima pagina. I cursori scadono dopo un'ora e valgono solo per l'elenco che li ha dati.
• le date sono ISO 8601 in UTC (2026-10-25T09:30:00.000Z) e finiscono in _at.
• gli id sono opachi e stabili, con un prefisso che dice cosa sono: per_ persona, cnv_ conversazione, msg_ messaggio, inv_ richiesta di collegamento, pst_ post, cmt_ commento, cmp_ azienda, flt_ filtro di ricerca, whk_ webhook. Puoi salvarli nel tuo CRM: la stessa persona ha sempre lo stesso id. Valgono solo per il tuo account.
• dove servono, ci sono anche i riferimenti pubblici di LinkedIn: public_identifier (la parte dopo linkedin.com/in/) e profile_url.
• degree è il grado di collegamento: 1, 2, 3 oppure null (fuori rete o non noto).

Ogni risposta ha l'intestazione X-Request-Id: citala se ci scrivi per un problema.

Gli errori seguono lo standard RFC 9457 (Content-Type: application/problem+json):

{
  "type": "https://lkdnautopilot.com/api-doc/#errori-daily_budget_exhausted",
  "title": "The daily budget for this action is used up, by the autopilot and the API together.",
  "status": 429,
  "code": "daily_budget_exhausted",
  "request_id": "req_9f2c...",
  "retry_after": 52310
}

Il campo da leggere nel codice è code: è stabile e non cambia mai significato. L'elenco completo è in Errori.

Idempotency-Key #

Ogni richiesta che agisce (POST e DELETE, tranne POST /v1/searches, che è una lettura) richiede l'intestazione Idempotency-Key: un valore unico scelto da te, da 8 a 200 caratteri, per esempio un UUID.

curl -X POST https://ayuhpqrbmizgsjstmcrt.supabase.co/functions/v1/public-api/v1/invitations \
  -H "Authorization: Bearer lkdn_sk_..." \
  -H "Idempotency-Key: 6b1f0e5e-2f4a-4c39-9a0e-4d8f2f0a1c11" \
  -H "Content-Type: application/json" \
  -d '{"person_id": "per_3mQ8...", "message": "Ciao Marco, ho letto il tuo post sulla logistica e mi è piaciuto."}'

• Se ripeti la stessa richiesta con la stessa chiave (un timeout, un errore di rete), ricevi la stessa risposta e l'azione non viene ripetuta. La risposta ha Idempotency-Replayed: true.
• La stessa chiave con una richiesta diversa: 422 idempotency_key_reused.
• Se la prima richiesta è ancora in corso: 409 idempotency_in_progress.
• Se la richiesta non ha agito (un 429, un 400, un 409 di stato dell'account), la chiave si libera e puoi riprovare con la stessa.
• Le chiavi si ricordano per 24 ore.

502 action_outcome_unknown vuol dire che LinkedIn non ci ha dato una risposta leggibile e l'azione potrebbe essere partita oppure no. Non riprovare con una chiave nuova: controlla prima (per un messaggio, leggi la conversazione).

Modalità simulata #

Finché il tuo account è in preparazione, le API rispondono con dati simulati (persone di fantasia) e nessuna azione parte davvero: le azioni passano comunque dai limiti e vengono registrate. Le risposte simulate hanno l'intestazione LKDN-Mode: simulated e, per le azioni, "simulated": true. È il modo giusto per costruire e provare un'integrazione senza toccare nessuno.

Endpoint #

Tutti i percorsi sono relativi all'indirizzo base. Lettura: permesso read. Azione: permesso write e Idempotency-Key.

Il tuo account #

GET /v1/me (lettura). Il tuo profilo, linkedin_status (connected, reconnect_required, not_connected), linkedin_plan (free, premium, sales_navigator), i crediti InMail.

GET /v1/usage (lettura). Il budget di oggi, condiviso con il pilota automatico:

{
  "data": {
    "date": "2026-10-25",
    "timezone": "Europe/Rome",
    "linkedin_plan": "premium",
    "invitation_note_available": true,
    "requests": { "today": 41, "per_day": 2000, "per_minute": 60 },
    "budget": {
      "invitations": { "used": 7, "limit": 20, "used_by_api": 2, "weekly_limit": 100 },
      "messages": { "used": 3, "limit": 25, "used_by_api": 3 },
      "total_actions": { "used": 18, "limit": 60 }
    },
    "activity_window": { "open_now": true, "start": "09:00", "end": "18:00", "working_day": true },
    "shared_with_autopilot": true
  }
}

Persone #

GET /v1/people/{id} (lettura). Un profilo: id è un per_... oppure il public_identifier. La persona non viene avvisata. Consuma un "profilo letto". Non restituisce email né telefoni di altre persone.

POST /v1/people/{id}/visits (azione). Visita il profilo: la persona vede che l'hai guardata. Consuma una visita.

GET /v1/people/{id}/posts (lettura). I post recenti della persona. limit fino a 50, cursor.

GET /v1/connections (lettura). I tuoi collegamenti di primo grado, dal più recente. q filtra per nome, limit fino a 200, cursor.

Ricerca #

GET /v1/search/filters?type=location&q=verona (lettura). Trasforma un luogo (type=location) o un settore (type=industry) in un filtro flt_... da usare nella ricerca. Usalo sempre: la ricerca rifiuta un filtro che non viene da qui (400 invalid_filter), perché LinkedIn ignorerebbe in silenzio un filtro sconosciuto e ti darebbe risultati di una ricerca diversa da quella che volevi.

POST /v1/searches (lettura). Cerca persone:

{
  "keywords": "logistica",
  "titles": ["CFO", "direttore finanziario"],
  "locations": ["flt_..."],
  "industries": ["flt_..."],
  "degree": [2, 3],
  "limit": 10
}

Almeno uno tra keywords, titles, locations, industries. limit fino a 10 (fino a 25 con Sales Navigator); ogni risultato consuma un "risultato di ricerca". Per la pagina successiva ripeti la stessa ricerca con cursor. La risposta ha anche page.total_estimate.

Conversazioni #

GET /v1/conversations (lettura). Le tue conversazioni, dalla più recente: type (direct o group), participant_id, kind (message, inmail, sponsored, offer), inbox, unread_count, last_activity_at. unread=true per le sole non lette, limit fino a 100, cursor.

GET /v1/conversations/{id} (lettura). Una conversazione.

GET /v1/conversations/{id}/messages (lettura). I messaggi, dal più recente: text, from_me, sender_id, sent_at, kind, seen, attachments (tipo e nome, senza link). Il testo lo leggiamo dal tuo account in quel momento e non lo conserviamo.

POST /v1/conversations/{id}/messages (azione). Rispondi in una conversazione uno a uno: {"text": "..."} (fino a 8000 caratteri). Le conversazioni di gruppo non sono supportate (422 group_conversation_not_supported).

POST /v1/conversations (azione). Scrivi a una persona: {"person_id": "per_...", "text": "..."}. Funziona con i collegamenti di primo grado (altrimenti 422 not_first_degree). Per un'InMail a chi non è collegato: {"person_id": "per_...", "text": "...", "inmail": true, "subject": "..."}; consuma un'InMail del budget e un credito InMail del tuo piano.

Richieste di collegamento #

GET /v1/invitations?direction=sent (lettura). Le richieste che hai inviato e sono in attesa; direction=received per quelle ricevute.

POST /v1/invitations (azione). {"person_id": "per_...", "message": "..."}. La nota (message, fino a 300 caratteri) non è disponibile su un account LinkedIn gratuito (403 invitation_note_not_available): su quel piano la richiesta parte senza nota. Già collegati: 409 already_connected; richiesta già in attesa: 409 already_invited.

DELETE /v1/invitations/{id} (azione). Ritira una richiesta inviata e ancora in attesa.

Post #

GET /v1/posts/{id} (lettura). Un post: id è un pst_..., un URN di LinkedIn (urn:li:activity:...) o il numero dell'attività.

GET /v1/posts/{id}/comments, GET /v1/posts/{id}/reactions (lettura). Commenti e reazioni.

POST /v1/posts (azione). Pubblica un post sul tuo profilo: {"text": "..."} (fino a 3000 caratteri).

POST /v1/posts/{id}/comments (azione). {"text": "...", "reply_to": "cmt_..."}; reply_to per rispondere a un commento. L'autore del post riceve una notifica.

POST /v1/posts/{id}/reactions (azione). {"type": "like"}; type è uno tra like, celebrate, support, love, insightful, funny.

Aziende #

GET /v1/companies/{id} (lettura). Una pagina aziendale: id è un cmp_... oppure il nome pubblico dopo linkedin.com/company/.

Webhook #

GET /v1/webhooks (lettura), POST /v1/webhooks (azione), DELETE /v1/webhooks/{id} (azione). Vedi Webhook.

Webhook #

Invece di chiedere ogni minuto "ci sono novità?", ti chiamiamo noi. Crea un webhook dall'app (API e integrazioni) oppure con:

curl -X POST https://ayuhpqrbmizgsjstmcrt.supabase.co/functions/v1/public-api/v1/webhooks \
  -H "Authorization: Bearer lkdn_sk_..." -H "Idempotency-Key: $(uuidgen)" -H "Content-Type: application/json" \
  -d '{"url": "https://crm.example.com/hooks/lkdn", "events": ["message.received", "connection.accepted"]}'

La risposta contiene il segreto di firma (whsec_...) una volta sola.

Il corpo della chiamata:

{
  "id": "evt_0b6f1f40000040008000000000000001",
  "type": "message.received",
  "created_at": "2026-10-25T10:00:03.000Z",
  "data": {
    "conversation_id": "cnv_...",
    "message_id": "msg_...",
    "sender_id": "per_...",
    "sent_at": "2026-10-25T10:00:00.000Z"
  }
}

Il testo del messaggio non viaggia nel webhook: leggilo con GET /v1/conversations/{conversation_id}/messages. Così nessun testo resta nelle nostre code di invio.

Ogni chiamata ha le intestazioni LKDN-Event-Id, LKDN-Event-Type e LKDN-Signature: t=<secondi unix>,v1=<firma>. La firma è l'HMAC-SHA256, in esadecimale, della stringa <t>.<corpo esatto> con il tuo segreto. Verificala sempre, e rifiuta una chiamata più vecchia di 5 minuti:

// Node.js
import { createHmac, timingSafeEqual } from 'node:crypto';

export function verify(secret, rawBody, header, now = Math.floor(Date.now() / 1000)) {
  const m = /^t=(\d+),v1=([0-9a-f]{64})$/.exec(header ?? '');
  if (!m || Math.abs(now - Number(m[1])) > 300) return false;
  const expected = createHmac('sha256', secret).update(`${m[1]}.${rawBody}`).digest('hex');
  return timingSafeEqual(Buffer.from(expected), Buffer.from(m[2]));
}

# Python
import hashlib, hmac, re, time

def verify(secret: str, raw_body: str, header: str) -> bool:
    m = re.fullmatch(r"t=(\d+),v1=([0-9a-f]{64})", header or "")
    if not m or abs(time.time() - int(m.group(1))) > 300:
        return False
    expected = hmac.new(secret.encode(), f"{m.group(1)}.{raw_body}".encode(), hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, m.group(2))

Rispondi con un codice 2xx entro 10 secondi. Altrimenti riproviamo dopo 1, 5 e 30 minuti, poi 2, 6, 12 e 24 ore; dopo 8 tentativi l'evento è perso, e dopo 20 eventi persi di fila il webhook si spegne (lo riaccendi dall'app). Un 410 Gone lo spegne subito per quell'evento. Lo stesso evento può arrivare due volte: usa id per riconoscerlo. Accettiamo solo indirizzi https sulla porta 443, mai indirizzi interni o privati, e non seguiamo i redirect.

Server MCP: Claude, ChatGPT, n8n #

Il server MCP espone le stesse funzioni come strumenti per un assistente AI, con la stessa chiave e gli stessi limiti: non esiste un percorso che li salti. Gli strumenti che agiscono lo dicono nella loro descrizione, e chiedono all'assistente di mostrarti il testo esatto e aspettare il tuo sì.

Indirizzo:

https://ayuhpqrbmizgsjstmcrt.supabase.co/functions/v1/mcp

Autenticazione: Authorization: Bearer lkdn_sk_.... Per i programmi che non permettono di impostare un'intestazione esiste la forma con la chiave nell'indirizzo, .../functions/v1/mcp/lkdn_sk_...: trattalo come una password, perché chi ha l'indirizzo ha la chiave. Usa per questo una chiave dedicata, e di sola lettura se all'assistente basta leggere.

Strumenti: get_my_profile, get_usage, get_person, visit_profile, list_person_posts, list_connections, find_search_filters, search_people, list_conversations, get_conversation_messages, send_message, start_conversation, list_invitations, send_invitation, withdraw_invitation, get_post, list_post_comments, list_post_reactions, publish_post, comment_on_post, react_to_post, get_company.

Claude Code #

claude mcp add --transport http lkdn-autopilot \
  https://ayuhpqrbmizgsjstmcrt.supabase.co/functions/v1/mcp \
  --header "Authorization: Bearer lkdn_sk_..."

Claude Desktop #

In Impostazioni, Sviluppatore, Modifica configurazione (claude_desktop_config.json), con il ponte mcp-remote (serve Node.js):

{
  "mcpServers": {
    "lkdn-autopilot": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://ayuhpqrbmizgsjstmcrt.supabase.co/functions/v1/mcp",
               "--header", "Authorization:Bearer ${LKDN_API_KEY}"],
      "env": { "LKDN_API_KEY": "lkdn_sk_..." }
    }
  }
}

Riavvia Claude Desktop: gli strumenti compaiono nel menu degli strumenti.

Claude.ai (connettore personalizzato) #

In Impostazioni, Connettori, Aggiungi connettore personalizzato: come URL usa la forma con la chiave nell'indirizzo, https://ayuhpqrbmizgsjstmcrt.supabase.co/functions/v1/mcp/lkdn_sk_..., e lascia vuoti i campi OAuth. Il connettore personalizzato è disponibile nei piani di Claude che lo prevedono.

ChatGPT #

In Impostazioni, App e connettori, con la modalità sviluppatore attiva: crea un connettore con l'URL nella forma con la chiave nell'indirizzo e autenticazione "nessuna". Gli strumenti che agiscono chiedono conferma prima di partire.

n8n #

Nel nodo MCP Client Tool di un AI Agent: Endpoint https://ayuhpqrbmizgsjstmcrt.supabase.co/functions/v1/mcp, trasporto HTTP Streamable, autenticazione Bearer con la tua chiave. Per un flusso senza AI usa il nodo HTTP Request sulle API REST, con una credenziale "Header Auth" (Authorization = Bearer lkdn_sk_...), e un nodo Webhook come destinazione dei nostri webhook.

Prompt pronti #

Da incollare in Claude o ChatGPT con il server MCP collegato.

Le risposte di oggi

Guarda le mie conversazioni non lette di LinkedIn. Per ognuna dimmi chi è la persona (nome, ruolo, azienda),
cosa mi ha scritto in una riga e se secondo te serve una risposta oggi. Non rispondere a nessuno: proponimi
una bozza di risposta solo per quelle che contano, e aspetta il mio sì su ogni testo.

Preparare un incontro

Leggi il profilo LinkedIn di <nome o link> e i suoi ultimi post. Preparami cinque righe: chi è, di cosa si
occupa adesso, cosa ha scritto di recente, un punto in comune con me e una domanda intelligente da fargli.
Non visitare il profilo con notifica e non scrivergli.

Trovare persone per un segmento

Cerca su LinkedIn titolari e direttori di studi dentistici in Veneto (usa find_search_filters per il luogo).
Mostrami i primi 10 in tabella con nome, ruolo, città e grado di collegamento. Prima di cercare dimmi
quanti risultati di ricerca mi restano oggi (get_usage). Non mandare richieste di collegamento.

Richieste di collegamento con una nota vera

Per ognuna di queste persone <elenco di link>: leggi il profilo, scrivimi una nota di collegamento di massimo
250 caratteri, in italiano, che parli di qualcosa di vero del suo profilo, senza vendere nulla e senza link.
Mostrami tutte le note. Invia solo quelle che approvo, una alla volta, e fermati se il budget del giorno finisce.

Rispondere ai commenti sui miei post

Prendi il mio ultimo post (cercalo tra i post del mio profilo) e leggi i commenti. Per quelli a cui non ho
ancora risposto proponimi una risposta breve e cordiale. Pubblica solo le risposte che approvo.

Il riepilogo della settimana

Dimmi quante richieste di collegamento ho in attesa da più di due settimane e chi sono. Proponimi quali
ritirare. Non ritirarne nessuna senza il mio ok.

Regole che valgono per ogni prompt: l'assistente non deve inventare fatti sulla persona, deve mostrarti ogni testo prima di inviarlo, e quando riceve action_paced, daily_budget_exhausted o outside_activity_window deve fermarsi e dirtelo.

Errori #

Ogni errore ha un code stabile: è un contratto, non cambia mai significato. Leggi il code, non il testo.

Privacy e responsabilità #

• Messaggi in transito. Le conversazioni e i messaggi letti dalle API passano da noi e arrivano a te; non li salviamo nei nostri archivi né nei nostri log. Lo stesso vale per i testi che invii: messaggi, note, commenti e post vanno a LinkedIn e non restano da noi. Del traffico delle API registriamo solo cosa è stato chiesto (il tipo di richiesta, l'esito, la durata), per 90 giorni, e le azioni fatte (che tipo, verso quale persona, quando, senza testo), per 180 giorni, perché servono a far rispettare i limiti.
• Il titolare sei tu. Per i dati delle persone che leggi e contatti sei tu il titolare del trattamento, come per il pilota automatico; noi siamo responsabili del trattamento secondo l'accordo (DPA) che hai accettato. Se conservi le conversazioni nel tuo CRM, quella conservazione è tua.
• Quello che fanno i tuoi programmi lo fa il tuo account. Ogni azione fatta con una tua chiave, da un tuo programma o da un assistente AI che hai collegato, è fatta a tuo nome e sotto la tua responsabilità, verso LinkedIn e verso le persone contattate, come previsto dai Termini di servizio. Tieni le chiavi al sicuro e revoca subito quella che pensi sia finita nelle mani sbagliate.
• I limiti di LinkedIn sono reali. LinkedIn non ama l'uso automatizzato: i nostri limiti esistono per ridurre il rischio, non lo annullano. Il rischio di una limitazione dell'account resta tuo.

Cosa non fa #

• Non collega altri account, non crea e non cancella collegamenti a LinkedIn: il collegamento si fa solo dall'app.
• Non dà accesso libero a LinkedIn: solo le operazioni di questa pagina, ciascuna con i suoi limiti.
• Non supera mai i limiti del tuo account, nemmeno se glielo chiedi.
• Non conserva le tue conversazioni.
• Non lavora con altre piattaforme oltre a LinkedIn.