Automate LinkedIn Ads Management with AI

Get read access to the Marketing API

This is the part everyone gets stuck on, so here is the exact sequence in the LinkedIn Developer Portal. Do the steps in order: one of them (granting the account) fails silently rather than with an error, and it is the reason most first attempts read nothing.

• Create an app at linkedin.com/developers/apps, linked to your company Page. The Page has to verify the app before any product request is reviewable, so you need admin on the Page or someone who has it.
• Open the app's Products tab and request the Advertising API. Approval lands you on the Development tier, which is read-only reporting, enough for everything up to the write step.
• Grant your ad account to the app: Products, then Advertising API, then View Ad Accounts, and add your ad account ID explicitly. Skip this and the token authenticates fine but returns zero ad accounts.
• Give the authenticating member a Campaign Manager role on the account (ACCOUNT_MANAGER, CAMPAIGN_MANAGER, or VIEWER). The token inherits the member's permissions, not the app's, so a member with no role reads nothing.
• Generate a token at linkedin.com/developers/tools/oauth/token-generator with the r_ads and r_ads_reporting scopes. That is the whole scope set for reading.
• Note the 60-day clock. Development-tier tokens last 60 days with no programmatic refresh, so set a reminder to regenerate and record the expiry, so your fetcher refuses to run past it instead of dying mid-pull on a confusing 401.

# Paste the token from the generator, then run this once.
export TOKEN="<your token>"

curl -s -H "Authorization: Bearer $TOKEN" \
  -H "LinkedIn-Version: 202607" \
  -H "X-Restli-Protocol-Version: 2.0.0" \
  "https://api.linkedin.com/rest/adAccountUsers?q=authenticatedUser"

# "elements": [ {...} ]  -> good, the account is granted and readable.
# "elements": []         -> the ad account was never granted to the app. Redo step 3.

Pull the account by layer

Pull the account by day at three grains: per campaign and ad set for spend and clicks, per ad for creative and dwell, and a cumulative pass for reach, frequency, and audience penetration, which LinkedIn only computes cumulatively, so it is null on every daily row. The API caps at twenty metric fields per request, so split the pull across calls rather than trying to grab everything at once.

Do not stop at the account grain. A single blended account CPC is the one number that cannot answer a real question, because it averages your cold layer, your retargeting layer, and any agency spend into one meaningless figure. Pull at ad-set grain so the agent can split them, and reconcile total spend back to the account so you know nothing was dropped.

• Per campaign and ad set: spend and clicks, the base for the layer analysis
• Per ad: creative performance and dwell time
• Cumulative (timeGranularity ALL): reach, frequency, and audience penetration

Make the agent categorize before it counts

This is the step that separates a trustworthy recommendation from a plausible-looking one. Have the agent read the layer off the campaign-group name prefix before it looks at a single metric: a cold prospecting layer, a capture layer, a retargeting layer, and everything else including agency programs. Test the retargeting prefix before the bare capture prefix, or every retargeting group collapses into capture and both layer averages move. Keep agency spend in its own bucket; folding it into your cold layer drags that CPC down and makes the owned program look better than it is.

Do the same for format, because two of them are not really LinkedIn formats. Thought Leader Ads report as a standard update and Connected TV reports as a single video, and the account tells them apart by the ad-set name. Each format is judged on a different metric: Conversation Ads on sends, video on completion rate, CTV on nothing clickable at all. Compute true CPC over the clickable formats only. Leave a video or a CTV ad set in the CPC math and you turn a whole layer's cost-per-click into noise.

Bake these rules into the agent's instructions once, in one place. If the layer or format logic changes, it changes everywhere at once, so the weekly analysis, the dashboard, and the executed changes never disagree about what a campaign is.

• Layer from the campaign-group name (cold / capture / retargeting / other), retargeting matched first
• Agency spend kept in its own bucket, never folded into the owned layers
• Format from the ad-set field, with Thought Leader Ads and CTV matched by name
• The valid metric per format (sends, completion rate, clicks) chosen before judging
• True CPC computed over clickable formats only, spend reconciled to the account

Run the analysis that proposes changes

Point the agent at your positioning and ICP first, then at the tail of a running insights log so it knows what has already been tried and flagged. Now it builds per-layer tables week over week, flags anything that moved more than twenty percent, and drills to the ad on the anomalies. The output is not prose. It is a ranked list of proposed changes, each written as an executable action with the evidence attached: 'pause ad set X, spend N with zero clickable conversions three weeks running,' 'raise the daily budget on retargeting group Y by twenty percent, converting under target CPL and pacing out by noon.'

Have it append the analysis to the insights log and never rewrite prior weeks. The log is the account's memory: it is what stops the agent from re-proposing a change you already rejected, and it is the first thing you read when a number looks wrong. This one API path also catches things a manual export misses, like a campaign group that is paused at the group level while its ad sets keep spending, which quietly under-counts your weekly spend until something reads the account directly.

Keep the proposals decisive and machine-actionable: an object type, an ID, a field, a target value, and a one-line reason. The agent branches on the structured part; you read the reason. A recommendation with no reason gets ignored the first time it is wrong.

Put the whole pass on a schedule with a Claude Code routine set to Monday morning. It fires on its own, pulls the fresh data, runs the layer analysis, appends the dated entry to the insights log, and drops the ranked pending-actions list in place, all before you open your laptop. The weekly trigger stops being a thing a human has to remember, which matters because a busy week is exactly when the manual version gets skipped and a losing ad set keeps spending.

Get write access and set the guardrails

Reading is a read-only API tier. Writing to the account is a separate approval: a LinkedIn Developer Support application, plus a screen recording of your app creating or editing a campaign through the API, to promote the app to Standard tier and add the rw_ads scope. It is the one thing standing between a dashboard that watches and a loop that acts, and it is worth the paperwork, because the read-only version is where recommendations go to rot.

Before the agent writes a single field, set the guardrails in code, not in good intentions. A hard cap on how far any one change can move a budget or a bid without a second confirmation, so a fat-fingered proposal cannot torch a month. A dry-run mode that prints exactly what would change and touches nothing. And an explicit status list on every write, or a paused-but-spending object vanishes from the name map and comes back unnamed. These are the seatbelts. Install them before you turn the key.

Keep the writes idempotent and logged. Every executed change appends to the same insights log as the reads, with the before value, the after value, and the reason, so the account has one honest record of not just what it observed but what it changed and why.

• Open a LinkedIn Developer Support ticket requesting Standard tier for the app (Development tier is read-only).
• Attach a screen recording of your app creating or editing a campaign through the API. This is the actual gate, so record it once against a throwaway draft campaign.
• On approval the app moves to Standard tier and the rw_ads scope unlocks. Regenerate the token with r_ads, r_ads_reporting, and rw_ads.

Approve in one line, let the agent execute

This is the whole point of the build. You read the ranked list over coffee, approve the ones you agree with, strike the ones you do not, and edit a number before it goes if you want to. Your entire job in the loop is a keystroke per decision, not forty minutes of clicking through Campaign Manager. The human stays in the loop exactly where judgment belongs and nowhere it does not.

On approval, the agent executes each change through the API and confirms it back: bids and budgets move to the numbers you approved, inside the caps; a losing ad set is paused the moment you sign off, not the following Sunday; a new campaign ships from a template the agent filled from the brief, launched as a draft or paused and waiting for the same one-line approval before it goes live; an audience is edited against the exact segment definitions the analysis already resolved, so the audience you tune is the one the report was talking about, not your best guess from memory.

The launch step is where the agent earns its keep most, because the tedious part, the ad-set scaffolding and the naming that the whole layer and format classification depends on, is the part it is best at and you are worst at. Let it build the structure and hand you the go-live decision.

Propose LinkedIn ad account changes for approval. Use ONLY the pulled data and the insights log.

Window: {{START}} to {{END}}
Layer + format classification: already applied
Insights log tail: {{RECENT_DECISIONS}}

Return a JSON array of actions only:
[{
  "object": "campaign|ad_set|ad",
  "id": "<urn>",
  "field": "status|dailyBudget|bid|audience",
  "from": "<current value>",
  "to": "<proposed value>",
  "reason": "<one sentence citing the metric and the layer>"
}]

Rules:
- Judge each object on the valid metric for its format (Conversation on sends, video on completion rate, CTV never on clicks). Never propose on a misleading metric.
- Do NOT re-propose anything the insights log shows was already rejected.
- No single 'to' may move a budget or bid more than {{CAP}}% from 'from'. If the data warrants more, split it and say so in the reason.
- Every action needs a reason a human can approve on in one glance. No reason, no action.

Watch execution lag, not just performance

The metric that proves this build worked is not CPC. It is execution lag: the time between a decision and the click that enacts it. That was the real recurring cost in the account, the days a condemned ad set kept spending while its death sat in a log. Once the loop is live, that gap collapses from about six days to the same morning: the ad set the system condemns on Monday is paused Monday, not the following Sunday. Watch it like a performance number, because the day it creeps back up is the day the loop has quietly broken.

Protect the read side too. The token lasts sixty days and the development tier has no programmatic refresh, so somebody rotates it by hand, and it lives in more than one place: the local fetcher, and any hosted endpoint or scheduled job that reads the account. Miss one and the failure is partial and quiet by design, the spend chart keeps working while the detail view goes dark. When a number looks wrong, check the token first, then the dedupe key, then whether agency spend leaked into a layer.

Audit the changes the agent did not propose, on a schedule. A loser it never flagged is the invisible cost, the same shape as the mis-scored lead nobody hears about. The paper trail in the insights log is what lets you go looking: read what it changed, what it left alone, and why, and tighten the rubric where its judgment and yours diverge.