Skip to content
Agentic FabriqGet a demo
All integrations

La Growth Machine

BUSINESS · CRM & SUPPORT

Outreach audiences, campaigns, their messages, leads, and statistics in the account they connected.

Connect La Growth Machine with Fabriq Developer

Your user pastes their La Growth Machine credential on a page Agentic Fabriq hosts, so it never reaches your backend and never becomes one shared key across all of your users. Same call as OAuth, one more argument.

from af_sdk import AgenticFabriq

af = AgenticFabriq()                      # reads AF_APP_ID / AF_APP_SECRET

url = await af.initiate_connection(request, provider="la_growth_machine", method="api_key")
return redirect(url)                      # an AF-hosted page, not yours

async with await af.for_user(request) as session:
    tools = await session.get_tools()     # only what this user granted

Provider names are surfaces, not vendors, and the authoritative list is the capabilities endpoint rather than any page including this one — an unknown name returns 400 with the valid list. Fabriq Developer is free to start and needs no provider paperwork. Start free or read the quickstart.

Connecting La Growth Machine in practice

La Growth Machine will not create a lead without a valid email address even when the whole point of the call is to have LGM enrich one, and its documented workaround is to post a placeholder address and let enrichment replace it later. The API is also plan-gated — "The API is available starting from the Pro plan" — and LGM’s own examples put the key in the query string as `?apikey=`, with `x-api-key` offered as the header alternative.

Scopes that draw scrutiny

  • External API key One key per workspace, generated under All settings → Integrations & API → API. There are no scopes: the same key creates leads into campaigns and reads campaign statistics.

Who has to approve

Not an admin consent flow, but a plan gate: Basic accounts get email and LinkedIn connection only, and API access starts at Pro. The key is minted inside the workspace settings, so whoever administers the LGM workspace controls whether an integration can exist at all.

Worth knowing

  • A lead needs one of these combinations or creation fails: audience plus proEmail, or persoEmail, or linkedinUrl, or twitter, or firstName plus lastName plus companyUrl or companyName.
  • The API host is apiv2.lagrowthmachine.com, not the app domain — for example POST https://apiv2.lagrowthmachine.com/flow/leads and GET /flow/campaigns/:campaignId/stats.
  • Passing the key as `?apikey=` (the form the docs lead with) puts the credential into request logs and any Referer header; the `x-api-key` header is the safer equivalent.
  • API call logs live in the same Integrations & API tab as the key, which is the only place to see what an integration actually sent.

Checked against Using the La Growth Machine API (2026-09-29)

Acts as the person, not as itself

Each user connects their own account. Every call carries both identities — the agent and the person it is acting for — so the agent can never reach past what that individual can already do.

Credentials never touch the agent

Tokens live in the vault and attach server-side at call time. The agent holds a session, not a secret, and revoking access does not mean rotating a key.

Every call on the record

Who asked, which agent acted, which action ran, and the verdict that let it through — one audit trail across every integration, not one per vendor.

What an agent can do

Each action is granted on its own. An agent allowed to read is not thereby allowed to write, and the scope beside each row is what the acting user must have connected for it to run at all.

la_growth_machine_delete_inboxwebhooks_by_webhookidWRITE

Delete one webhook registration by id. There is no undo and no pause: delivery stops immediately, the events that occur while it is gone are not replayed when a replacement is created, and the replacement carries a NEW id that anything referring to the old one will not match. The only destructive tool on this surface via DELETE /inboxWebhooks/{webhookId}

api
la_growth_machine_get_audiencesREAD

Every audience in the workspace with its id and name. The id a campaign's `audienceId` setting takes, and the one the audience detail and lead listings take via GET /audiences

api
la_growth_machine_get_audiences_by_audienceid_detailREAD

Read one audience by its 24-character hex id: its name, how many leads it holds and how it was built via GET /audiences/{audienceId}/detail

api
la_growth_machine_get_audiences_by_audienceid_leadsREAD

Page through the leads in one audience with `skip` and `limit` (1 to 100, 25 by default). Returns the lead ids the lead log, conversation, enrichment and inbox tools take via GET /audiences/{audienceId}/leads

api
la_growth_machine_get_campaignsREAD

Page through this workspace's campaigns -- id, name and status for each -- with `skip` and `limit` (25 per page maximum). The campaign id every other campaign tool takes comes from here via GET /campaigns

api
la_growth_machine_get_campaigns_by_campaignidREAD

Read one campaign by id: its name, its status and the audience and identities it runs on. List campaigns is what mints the id via GET /campaigns/{campaignId}

api
la_growth_machine_get_campaigns_by_campaignid_messagesREAD

Read the message templates a campaign sends at each step of its sequence. `campaignId` is a 24-character hex ObjectId. Read-only: editing a sequence is a La Growth Machine UI action, not an API call via GET /campaigns/{campaignId}/messages

api
la_growth_machine_get_campaigns_by_campaignid_statsREAD

Aggregate performance for one campaign across LinkedIn, email and Twitter: how many leads were contacted, replied, bounced and converted. The whole-campaign counterpart to List a campaign's leads with their statistics via GET /campaigns/{campaignId}/stats

api
la_growth_machine_get_campaigns_by_campaignid_statsleadsREAD

Per-LEAD performance inside one campaign, cursor-paginated BY LEAD ID rather than by offset: pass the last id you saw as `getLeadsAfter`, or walk backwards with `getLeadsBefore`. Returns the lead ids the lead and inbox tools take via GET /campaigns/{campaignId}/statsleads

api
la_growth_machine_get_conversations_by_conversationid_messagesREAD

The messages in one conversation, by its 24-character hex id. PAGE-numbered rather than cursored: `page` starts at 0. Search conversations and List a lead's conversations are what mint the id via GET /conversations/{conversationId}/messages

api
la_growth_machine_get_conversations_searchREAD

Search the inbox: free text in `q` plus filters for identity, lead, audience and campaign ids, conversation `status`, the last message's type, status and date range, call-completion dates, and the `leadReplied`, `unsubscribed`, `favourite` and `read` flags. Cursor-paginated -- pass the last cursor back as `searchAfter` -- and sortable with `sortField` / `sortDirection` via GET /conversations/search

api
la_growth_machine_get_creditsREAD

The workspace's remaining enrichment credits. Read this before Enrich a lead, which spends 1 credit on LINKEDIN_ENRICH and 5 on EMAIL_ENRICH or FULL_ENRICH, and before any loop that enriches a list via GET /credits

api
la_growth_machine_get_inboxwebhooksREAD

The inbox-event webhook registrations on this workspace, with the ids Delete an inbox webhook takes via GET /inboxWebhooks

api
la_growth_machine_get_leads_by_leadid_conversationsREAD

The conversation threads held with one lead, optionally narrowed to one `identityId`. Returns the conversation ids the message listing and the archive, snooze and note tools take via GET /leads/{leadId}/conversations

api
la_growth_machine_get_leads_by_leadid_logsREAD

Every action La Growth Machine has taken for one lead -- visits, connection requests, messages, emails, enrichments -- optionally narrowed to one `identityId` and paged with `skip` and `limit` (1 to 100). `leadId` is a 24-character hex ObjectId via GET /leads/{leadId}/logs

api
la_growth_machine_get_leads_enrich_by_enrichrequestidREAD

Read back one enrichment by the id Enrich a lead returned. This is the second half of `mode: polling`; nothing is charged again for reading it via GET /leads/enrich/{enrichRequestId}

api
la_growth_machine_get_membersREAD

Every member of the workspace this API key belongs to, and the source of the `memberId` that Send a LinkedIn message to a lead requires. La Growth Machine designates this as the call to check a key with, so it is the cheapest read on the surface and the one this integration probes a pasted key against via GET /members

api
la_growth_machine_post_audiencesWRITE

Fill an audience from a LinkedIn search, Sales Navigator search or post URL. `audience` names an EXISTING audience or creates a new one, so the same call both creates and extends; `identityId` must be a connected LinkedIn identity with its widget open. `autoImport` keeps pulling new matches in afterwards and `excludeContactedLeads` skips leads already contacted. Leads that land here become contactable by every campaign using that audience. Sent as form-urlencoded, unlike Create an empty audience via POST /audiences

api
la_growth_machine_post_audiences_createWRITE

Create a named, empty audience (1-100 characters) to fill later. The JSON-bodied sibling of Import a LinkedIn search into an audience, which is form-urlencoded and populates one at the same time via POST /audiences/create

api
la_growth_machine_post_campaigns_by_campaignid_settingsWRITE

Change a live campaign's configuration: rename it, assign its `audienceId` (only while the campaign is READY and has never started), or switch auto-enrichment, HubSpot sync, Pipedrive sync, skip-already-contacted, ignore-emoji-only-replies and out-of-office rescheduling on or off. SEVERAL FIELDS HAVE A STATE PRECONDITION -- the CRM toggles need a PAUSED campaign and the two rules need READY or PAUSED -- and the call is refused rather than queued when it is not met. Sent as form-urlencoded via POST /campaigns/{campaignId}/settings

api
la_growth_machine_post_campaigns_by_campaignid_statusWRITE

THIS ONE REACHES REAL PEOPLE. `RUNNING` resumes a paused campaign and La Growth Machine starts sending its connection requests, LinkedIn messages and emails to the leads in its audience, from the customer's own accounts; `PAUSED` stops it. Those are the only two values the field accepts. The toggle is reversible, but messages the campaign has already sent cannot be recalled -- pausing stops what has not gone out yet, not what has. Sent as form-urlencoded via POST /campaigns/{campaignId}/status

api
la_growth_machine_post_crm_searchREAD

A READ THAT USES POST, because its criteria travel in a body: look a lead up in the workspace's CRM by `email`, `proEmail` or `persoEmail`, or by `firstname` narrowed with lastname, company name or LinkedIn URL. At least one of those is required. Nothing is written, nothing is enriched and no credit is spent via POST /crm/search

api
la_growth_machine_post_inbox_conversations_archiveWRITE

Move a conversation out of the active inbox, addressed by `conversationId` or by the lead's `email`. Nothing is deleted and Unarchive a conversation is the exact inverse via POST /inbox/conversations/archive

api
la_growth_machine_post_inbox_conversations_noteWRITE

Write the internal note on a conversation, addressed by `conversationId` or by lead, campaign, identity, email or LinkedIn URL. `mode: append` adds to what is there; `mode: replace` OVERWRITES IT and the previous text is not recoverable, so prefer append unless a replacement is meant. The note is internal to the workspace and is never sent to the lead via POST /inbox/conversations/note

api
la_growth_machine_post_inbox_conversations_snoozeWRITE

Hide a conversation until `snoozeUntil` (an ISO-8601 date-time), at which point it returns to the inbox by itself. Reversible before then with Unsnooze a conversation via POST /inbox/conversations/snooze

api
la_growth_machine_post_inbox_conversations_unarchiveWRITE

Bring an archived conversation back into the active inbox, addressed by `conversationId` or by the lead's `email`. The inverse of Archive a conversation via POST /inbox/conversations/unarchive

api
la_growth_machine_post_inbox_conversations_unsnoozeWRITE

Bring a snoozed conversation back now rather than waiting for its `snoozeUntil`, addressed by `conversationId` or by the lead's `linkedinUrl` via POST /inbox/conversations/unsnooze

api
la_growth_machine_post_inbox_emailWRITE

SENDS A REAL EMAIL FROM THE CUSTOMER'S OWN MAILBOX TO A REAL PERSON, and it cannot be recalled. `identityId` names the sending email identity and `message` must carry BOTH an `html` and a `text` body; name the recipient with `leadId` or `leadEmail`, and either continue a thread (`replyInLastThread`, or `replyToMessageId` for a specific message) or give a `subject`. `cc` and `bcc` are comma-separated lists, and every address on them receives the mail too via POST /inbox/email

api
la_growth_machine_post_inbox_linkedinWRITE

SENDS A REAL LINKEDIN MESSAGE FROM THE CUSTOMER'S OWN ACCOUNT TO A REAL PERSON, and it cannot be recalled -- LinkedIn offers no way to unsend a message. `identityId` names the LinkedIn identity that sends and `memberId` the member performing it (List workspace members); name the recipient with `leadId` or `linkedinUrl`, and supply `message` text or an `audioUrl` pointing at a hosted MP3 voice note -- at least one of the two. `attachments` takes file URLs, and `source` must be one of api, make, n8n or zapier via POST /inbox/linkedin

api
la_growth_machine_post_inboxwebhooksWRITE

Register a publicly reachable https `url` that La Growth Machine POSTs every inbox message to, under a `name`, optionally filtered to named `campaigns` (omit the list and it receives every campaign's messages). THE URL IS A DESTINATION FOR THE CUSTOMER'S OWN CONVERSATION CONTENT, so point it only at a service they control; it must answer POST with 200 OK via POST /inboxWebhooks

api
la_growth_machine_post_leads_enrichWRITE

SPENDS THE WORKSPACE'S CREDITS on every call: EMAIL_ENRICH costs 5 and is the only type that works without a `leadId` (firstname plus lastname is enough), LINKEDIN_ENRICH costs 1 and requires one, FULL_ENRICH costs 5 and requires one. `mode` is `polling` by default -- the response carries an id to read back with Get an enrichment result -- or `sync`, or `webhook` with an https `webhookUrl`. Read the balance with Get the credit balance before running these in bulk via POST /leads/enrich

api
la_growth_machine_post_leads_statusWRITE

Move one lead to a named status inside a campaign, identifying them by `leadId` or by email, LinkedIn URL, CRM id or name. THE STATUS VOCABULARY IS CLOSED and the value is written verbatim into the customer's own database, so send one of the documented statuses and never an invented one: PAUSED, RESUME, STOPPED, CONVERTED, SUBSCRIBED, UNSUBSCRIBED, NOT_ACTIVATED, ALREADY_EQUIPPED, ENRICHED, CONTACTED, CANNOT_CONTACT, COMPLETED_WITHOUT_REPLY, TO_QUALIFY, OUT_OF_OFFICE, WRONG_TIMING, CALL_BOOKED, INTERESTED, NOT_INTERESTED, WRONG_TARGET, NEGOTIATING, READY_TO_BUY. STOPPED and UNSUBSCRIBED end further outreach to that lead. `campaign` is required. Sent as form-urlencoded via POST /leads/status

api

Put La Growth Machine behind one governed endpoint.

Same permissions, same audit trail, whatever else you connect next.