# LinkedIn Ads Library Scraper (`s-r/linkedin-ads-library`) Actor

Scrape LinkedIn's Ad Library for company ads — get ad type, body text, headlines, images, advertiser logo, and ad detail deeplinks. B2B competitor ad spy.

- **URL**: https://apify.com/s-r/linkedin-ads-library.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 2 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 ad scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Free LinkedIn Ad Library Scraper — B2B Competitor Ad Spy

The free LinkedIn Ad Library scraper built for **B2B competitor ad
spy**. Search any company on LinkedIn's official Ad Library and get the
full ad — type, body text, headline, content images, advertiser logo,
and detail deeplinks — as clean JSON.

The only practical free alternative to paid SaaS B2B ad-spy tools that
charge $99-$499/month for the same data.

### What you get

- Ad ID + deeplink to LinkedIn's ad detail page
- Advertiser company name + logo
- Ad type — Single Image, Video, Carousel, Document, Article
- Body text + headline
- Content image URLs (filters out profile / logo thumbnails)
- For person-promoted ads: person name + person title
- Total ad count for the search (from LinkedIn's own counter)
- Country + date-range filtering

### Why scrape the LinkedIn Ad Library

LinkedIn's Ad Library is publicly accessible at `/ad-library/search`,
but the page is server-side rendered with no public API. To
programmatically pull LinkedIn ads at scale you have to scrape the HTML
and parse the markup — which changes every few months.

This Actor handles the parsing for you and ships ready-to-use structured
JSON. No LinkedIn login, no Sales Navigator subscription, no
Marketing-Partner-API access required.

### Input

| Field | Default | Description |
|---|---|---|
| `search` | required | Company name or keyword |
| `country` | all | ISO 2-letter country code (filter the search results) |
| `date_range` | all | `last_30_days` / `this_month` / `this_year` / `last_year` |
| `sort` | `NEWEST` | `NEWEST` or `OLDEST` |

### Use cases

- **B2B competitor ad spy** — the cheapest way to track what your B2B
  competitors are advertising on LinkedIn
- **SaaS / agency / consulting creative intelligence** — what's working
  in your niche right now
- **ABM monitoring** — which competitors are running ads to your target
  account industries
- **Personal brand / thought-leadership tracking** — LinkedIn shows
  person-level promoted posts; this scrapes those too
- **Competitive content research** — Document Ads and Article Ads reveal
  what gated assets competitors are pushing

### Output (sample)

```json
{
  "ad_id": "1384570116",
  "deeplink": "https://www.linkedin.com/ad-library/detail/1384570116",
  "advertiser_name": "Asana",
  "ad_type": "Single Image Ad",
  "body_text": "Danone drives impact and innovation with Asana.",
  "headline": "Get your team aligned",
  "images": ["https://media.licdn.com/dms/image/v2/D5610AQ…"],
  "advertiser_logo": "https://media.licdn.com/dms/image/v2/D4E0BAQ…",
  "country": "US",
  "date_range": "all",
  "sort": "NEWEST",
  "total_ads_in_search": 24
}
````

### Limits

- LinkedIn returns roughly 25 ads per search-result page; the Actor
  returns whatever's on the first page — use `total_ads_in_search` to
  know what you're missing
- LinkedIn rate-limits aggressively — if a run returns zero items, wait
  10-30 minutes before retrying with the same query
- HTML parsing is fragile to LinkedIn redesigns — open an issue if a
  layout change breaks parsing

### Related Actors — Free Ad Spy Suite

Pair this actor with the rest of the suite for full cross-platform competitor ad intelligence:

- **[Free Facebook Ad Library Scraper](https://apify.com/s-r/meta-ads-library)** — every active Meta ad for any brand or page
- **[Free TikTok Ad Library Scraper](https://apify.com/s-r/tiktok-ads-library)** — TikTok competitor ads with video URLs and dates
- **[Free Google Ads Transparency Scraper](https://apify.com/s-r/google-ads-transparency)** — every ad an advertiser ran on Google Search, YouTube, Display, Shopping

Run all four on the same competitor and you have the complete picture
of what they're advertising across every major surface.

# Actor input Schema

## `search` (type: `string`):

Company name or keyword to search (e.g. "coolblue", "hubspot"). Required.

## `country` (type: `string`):

ISO 2-letter country code (e.g. NL, US, DE). Leave blank for all countries.

## `date_range` (type: `string`):

Limit results by recency.

## `sort` (type: `string`):

Order results by recency.

## Actor input object example

```json
{
  "search": "hubspot",
  "date_range": "",
  "sort": "NEWEST"
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "search": "hubspot"
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/linkedin-ads-library").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "search": "hubspot" }

# Run the Actor and wait for it to finish
run = client.actor("s-r/linkedin-ads-library").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "search": "hubspot"
}' |
apify call s-r/linkedin-ads-library --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=s-r/linkedin-ads-library",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Ads Library Scraper",
        "description": "Scrape LinkedIn's Ad Library for company ads — get ad type, body text, headlines, images, advertiser logo, and ad detail deeplinks. B2B competitor ad spy.",
        "version": "0.1",
        "x-build-id": "ELXtykIE6jLmM5cRt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/s-r~linkedin-ads-library/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-s-r-linkedin-ads-library",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/s-r~linkedin-ads-library/runs": {
            "post": {
                "operationId": "runs-sync-s-r-linkedin-ads-library",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/s-r~linkedin-ads-library/run-sync": {
            "post": {
                "operationId": "run-sync-s-r-linkedin-ads-library",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "search"
                ],
                "properties": {
                    "search": {
                        "title": "Company / keyword",
                        "type": "string",
                        "description": "Company name or keyword to search (e.g. \"coolblue\", \"hubspot\"). Required."
                    },
                    "country": {
                        "title": "Country",
                        "pattern": "^([a-zA-Z]{2})?$",
                        "type": "string",
                        "description": "ISO 2-letter country code (e.g. NL, US, DE). Leave blank for all countries."
                    },
                    "date_range": {
                        "title": "Date range",
                        "enum": [
                            "",
                            "last_30_days",
                            "this_month",
                            "this_year",
                            "last_year"
                        ],
                        "type": "string",
                        "description": "Limit results by recency.",
                        "default": ""
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "NEWEST",
                            "OLDEST"
                        ],
                        "type": "string",
                        "description": "Order results by recency.",
                        "default": "NEWEST"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
