# AI Ad Creative Intelligence API | 💵$3/1K (`webdata_labs/ai-ad-creative-intelligence-api`) Actor

\[💵 $3.00 / 1K] Turn LinkedIn, TikTok, Meta, or pasted ads into structured hooks, offers, CTAs, audiences, creative patterns, risks, and test ideas using GPT.

- **URL**: https://apify.com/webdata\_labs/ai-ad-creative-intelligence-api.md
- **Developed by:** [WebData Labs](https://apify.com/webdata_labs) (community)
- **Categories:** AI, Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 analyzed ads

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## ✨ AI Ad Creative Intelligence API

**Turn competitor ads into a clear creative strategy — not another spreadsheet of raw copy.**

Analyze LinkedIn, TikTok, Meta, Google, or pasted ad records with GPT. For every ad, the Actor extracts the hook, offer, CTA, funnel stage, audience hypothesis, message angles, creative patterns, strengths, risks, evidence, and concrete experiments your team can run next.

Use it for competitor research, message mining, campaign audits, and creative-testing backlogs. Paste a few ads for an instant audit or connect an existing Apify dataset for batch analysis.

### 🎯 What you get

Every source ad becomes one structured, audit-ready result:

| Output | Why it matters |
|---|---|
| `primaryHook` + `hookType` | See how the ad earns attention. |
| `offer` + `cta` | Compare conversion mechanics across competitors. |
| `funnelStage` | Separate awareness creative from conversion creative. |
| `targetAudience` | Capture evidence-based audience hypotheses. |
| `angles` + `creativePatterns` | Find messages worth adapting across a portfolio. |
| `strengths` + `weaknesses` | Understand what is clear, credible, or missing. |
| `testIdeas` | Turn research directly into an experimentation backlog. |
| `complianceRisks` | Flag quantitative, social-proof, or absolute claims for review. |
| `evidence` + `confidence` | Trace conclusions back to the supplied copy. |
| `longevityDays` | Use first/last-seen dates as an observable longevity signal. |

The run summary also ranks recurring hook types, angles, and CTAs across the whole batch.

> The Actor never invents ROAS, conversions, spend, or verified targeting. Audience and strategy fields are explicitly hypotheses based on the supplied creative.

### 🚀 Quick start

The default input is ready to run. Click **Start** for an immediate example, or paste your own ads:

```json
{
  "ads": [
    {
      "id": "ad-42",
      "platform": "linkedin",
      "advertiser": "Example SaaS",
      "headline": "Stop losing leads after the demo",
      "text": "Automate follow-ups in minutes. Start a free 14-day trial.",
      "cta": "Start free trial",
      "firstSeen": "2026-06-01",
      "lastSeen": "2026-07-15"
    }
  ],
  "analysisGoal": "creative_testing",
  "brandContext": "B2B sales automation for companies with 20-200 employees",
  "maxAds": 25
}
````

For larger workflows, pass `datasetId` instead. Dataset input takes priority over the UI sample and does not require downloading or reshaping the source data first.

### 🔗 Connect your ad datasets

The Actor normalizes common fields automatically, including:

- copy: `text`, `body`, `caption`, `description`, `headline`, `title`;
- CTA: `cta`, `ctaText`, `callToAction`;
- identity: `id`, `adId`, `libraryId`, `advertiser`, `pageName`, `brand`;
- format: `format`, `adFormat`, `creativeType`, `mediaType`;
- provenance: `platform`, `source`, `detailUrl`, `sourceSearchUrl`;
- dates and metrics when supplied.

This makes it suitable as a decision layer after LinkedIn Ads Library, TikTok Creative Center, Meta Ads Library, or another Apify Actor.

### 🧭 Choose the analysis goal

#### 🔍 Competitor research

Compare competitor hooks, offers, proof, CTAs, audiences, and recurring creative patterns.

#### 🧪 Creative testing

Generate specific hook, proof, offer, CTA, and audience-framing variations for an experimentation backlog.

#### 💬 Message mining

Extract repeated pains, outcomes, objections, promises, and social-proof patterns across many ads.

#### 🩺 Campaign audit

Find unclear offers, weak CTAs, funnel mismatches, unsupported claims, missing proof, and compliance-review risks.

### 📦 Example output

```json
{
  "adId": "ad-42",
  "platform": "linkedin",
  "advertiser": "Example SaaS",
  "hookType": "pain avoidance",
  "primaryHook": "Stop losing leads after the demo",
  "offer": "Free 14-day trial",
  "cta": "Start free trial",
  "funnelStage": "conversion",
  "targetAudience": ["sales teams", "revenue operations leaders"],
  "angles": ["lead loss", "CRM admin time", "speed to value"],
  "testIdeas": [
    "Test the lead-loss hook against a CRM time-saving hook",
    "Test proof-first copy before the free-trial offer"
  ],
  "evidence": ["Stop losing leads after the demo", "free 14-day trial"],
  "confidence": 0.74,
  "longevityDays": 44
}
```

### ⚙️ Input reference

| Field | Description |
|---|---|
| `ads` | Inline ad objects for quick tests or small batches. |
| `datasetId` | An Apify dataset to process directly. Takes priority over `ads`. |
| `brandContext` | Product, positioning, audience, or campaign context used to make recommendations more relevant. |
| `analysisGoal` | `competitor_research`, `creative_testing`, `message_mining`, or `campaign_audit`. |
| `maxAds` | Process 1-1,000 ads. Default: 25. |
| `includeOriginalAd` | Include the complete source record for downstream joins and audits. |

### 🛡️ Reliable batch behavior

- Structured JSON Schema keeps output consistent across runs.
- Ad copy is treated as untrusted data, never as model instructions.
- Each GPT request is retried on transient failures.
- A failed record produces an explicit low-confidence fallback instead of disappearing silently.
- Results are streamed to the default dataset in small batches.
- Source evidence is kept short and traceable.

### 💵 Pricing

The launch price is **$3.00 per 1,000 analyzed ads** on Free and Starter plans, with lower unit pricing on larger Apify plans. Platform usage is included.

The default 25-ad run has a maximum analyzed-result charge of **$0.075**. Apify may also display its automatic nominal Actor-start event.

### 🔌 Automation and API

Run the Actor from:

- the Apify Console;
- the Apify REST API or JavaScript/Python client;
- schedules and webhooks;
- Make, Zapier, n8n, or another Actor.

Rows are written to the default dataset. Aggregate hook, angle, CTA, confidence, and fallback statistics are stored in the `OUTPUT` key-value record.

### 🔐 Privacy and responsible use

- Submit only ads and data you are authorized to process.
- Do not include API keys, passwords, customer secrets, or unnecessary personal data.
- `targetAudience` is a creative hypothesis, not access to platform targeting settings.
- `longevityDays` is calculated only when valid first-seen and last-seen dates exist.
- Compliance flags are review prompts, not legal advice.
- Creative analysis does not prove campaign performance or causation.

### ❓ FAQ

#### Does this scrape ad libraries?

No. It analyzes ads you paste or supply through an Apify dataset. Pair it with an ad-library Actor when you need collection plus intelligence.

#### Do users need their own OpenAI key?

No. GPT processing is configured inside the Actor.

#### Can different platforms be mixed in one run?

Yes. Platform and source fields are normalized per record, so one dataset may contain LinkedIn, TikTok, Meta, Google, or custom ads.

#### Why can confidence be low?

Public ad-library cards sometimes contain only a hashtag, short caption, or missing CTA. The Actor lowers confidence rather than filling those gaps with invented facts.

#### What happens when one GPT request fails?

The request is retried. If it still fails, the Actor returns an explicit fallback row with low confidence so batch cardinality and source joins remain intact.

# Actor input Schema

## `ads` (type: `array`):

Ad objects from any platform. Common fields such as text, headline, CTA, advertiser, image/video URL, dates, and metrics are detected automatically.

## `datasetId` (type: `string`):

Optional source dataset. Use output from an ad-library Actor without downloading and re-uploading JSON.

## `brandContext` (type: `string`):

Optional product, target market, positioning, or campaign objective. Improves strategic recommendations.

## `analysisGoal` (type: `string`):

What decision should the analysis support?

## `maxAds` (type: `integer`):

Maximum ads processed in this run.

## `includeOriginalAd` (type: `boolean`):

Keep the full source object in each result for downstream joins.

## Actor input object example

```json
{
  "ads": [
    {
      "id": "demo-1",
      "platform": "linkedin",
      "advertiser": "Northstar CRM",
      "headline": "Stop losing leads after the demo",
      "text": "Sales teams waste hours updating CRM fields. Automate follow-ups in minutes and start a free 14-day trial.",
      "cta": "Start free trial",
      "firstSeen": "2026-06-01",
      "lastSeen": "2026-07-15"
    },
    {
      "id": "demo-2",
      "platform": "tiktok",
      "advertiser": "Glow Labs",
      "text": "POV: your morning routine takes 30 seconds. See why 10,000+ customers switched.",
      "cta": "Shop now",
      "format": "video"
    }
  ],
  "analysisGoal": "competitor_research",
  "maxAds": 25,
  "includeOriginalAd": false
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `testIdeas` (type: `string`):

No description

## `summary` (type: `string`):

No description

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("webdata_labs/ai-ad-creative-intelligence-api").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("webdata_labs/ai-ad-creative-intelligence-api").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 '{}' |
apify call webdata_labs/ai-ad-creative-intelligence-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=webdata_labs/ai-ad-creative-intelligence-api",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AI Ad Creative Intelligence API | 💵$3/1K",
        "description": "[💵 $3.00 / 1K] Turn LinkedIn, TikTok, Meta, or pasted ads into structured hooks, offers, CTAs, audiences, creative patterns, risks, and test ideas using GPT.",
        "version": "0.1",
        "x-build-id": "28VWRwh5nlUv2dOD1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/webdata_labs~ai-ad-creative-intelligence-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-webdata_labs-ai-ad-creative-intelligence-api",
                "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/webdata_labs~ai-ad-creative-intelligence-api/runs": {
            "post": {
                "operationId": "runs-sync-webdata_labs-ai-ad-creative-intelligence-api",
                "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/webdata_labs~ai-ad-creative-intelligence-api/run-sync": {
            "post": {
                "operationId": "run-sync-webdata_labs-ai-ad-creative-intelligence-api",
                "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",
                "properties": {
                    "ads": {
                        "title": "Ads to analyze",
                        "type": "array",
                        "description": "Ad objects from any platform. Common fields such as text, headline, CTA, advertiser, image/video URL, dates, and metrics are detected automatically.",
                        "items": {
                            "type": "object"
                        },
                        "default": [
                            {
                                "id": "demo-1",
                                "platform": "linkedin",
                                "advertiser": "Northstar CRM",
                                "headline": "Stop losing leads after the demo",
                                "text": "Sales teams waste hours updating CRM fields. Automate follow-ups in minutes and start a free 14-day trial.",
                                "cta": "Start free trial",
                                "firstSeen": "2026-06-01",
                                "lastSeen": "2026-07-15"
                            },
                            {
                                "id": "demo-2",
                                "platform": "tiktok",
                                "advertiser": "Glow Labs",
                                "text": "POV: your morning routine takes 30 seconds. See why 10,000+ customers switched.",
                                "cta": "Shop now",
                                "format": "video"
                            }
                        ]
                    },
                    "datasetId": {
                        "title": "Apify dataset ID",
                        "type": "string",
                        "description": "Optional source dataset. Use output from an ad-library Actor without downloading and re-uploading JSON."
                    },
                    "brandContext": {
                        "title": "Brand or campaign context",
                        "type": "string",
                        "description": "Optional product, target market, positioning, or campaign objective. Improves strategic recommendations."
                    },
                    "analysisGoal": {
                        "title": "Analysis goal",
                        "enum": [
                            "competitor_research",
                            "creative_testing",
                            "message_mining",
                            "campaign_audit"
                        ],
                        "type": "string",
                        "description": "What decision should the analysis support?",
                        "default": "competitor_research"
                    },
                    "maxAds": {
                        "title": "Maximum ads",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum ads processed in this run.",
                        "default": 25
                    },
                    "includeOriginalAd": {
                        "title": "Include original ad",
                        "type": "boolean",
                        "description": "Keep the full source object in each result for downstream joins.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```