Linkedin-Ads

This connector is optimized for AI agents. For the data replication connector, see Linkedin Ads.

The Linkedin-Ads agent connector is a Python package that equips AI agents to interact with Linkedin-Ads through strongly typed, well-documented tools. It's ready to use directly in your Python app, in an agent framework, or exposed through an MCP.

Connector for the LinkedIn Ads Marketing API. Provides access to ad accounts, campaigns, campaign groups, creatives, conversions, and ad analytics data. Supports OAuth 2.0 and direct access token authentication. Use this connector to retrieve advertising performance metrics, manage campaign structures, and monitor creative assets across your LinkedIn advertising accounts.

Example prompts

The Linkedin-Ads connector is optimized to handle prompts like these.

List all my LinkedIn ad accounts
Show me all campaigns in my ad account
List all campaign groups
Show me the creatives for my campaigns
List all conversions configured for my ad accounts
Show me account users for my LinkedIn ads accounts
Show me campaign analytics for my LinkedIn ad campaigns
Show me creative analytics for my ad creatives
Which campaigns have the highest click-through rate?
What is the total ad spend across all campaigns this month?
Show me campaigns with status ACTIVE
Which creatives have the most impressions?
Compare campaign performance by cost type

Unsupported prompts

The Linkedin-Ads connector isn't currently able to handle prompts like these.

Create a new campaign
Update campaign budgets
Delete an ad creative
Pause a campaign

Entities and actions

This connector supports the following entities and actions. For more details, see this connector's full reference documentation.

Entity	Actions
Accounts	List, Create, Get, Update, Delete, Context Store Search
Account Users	List, Update, Create, Delete, Context Store Search
Campaigns	List, Create, Get, Update, Delete, Context Store Search
Campaign Groups	List, Create, Get, Update, Delete, Context Store Search
Creatives	List, Create, Get, Update, Delete, Context Store Search
Conversions	List, Create, Get, Update, Context Store Search
Conversion Events	Create
Campaign Conversions	Create, Delete
Ad Campaign Analytics	List, Context Store Search
Ad Creative Analytics	List, Context Store Search
Ad Impression Device Analytics	List, Context Store Search
Ad Member Company Analytics	List, Context Store Search
Ad Member Company Size Analytics	List, Context Store Search
Ad Member Country Analytics	List, Context Store Search
Ad Member Industry Analytics	List, Context Store Search
Ad Member Job Function Analytics	List, Context Store Search
Ad Member Job Title Analytics	List, Context Store Search
Ad Member Region Analytics	List, Context Store Search
Ad Member Seniority Analytics	List, Context Store Search
Lead Forms	List, Context Store Search
Lead Form Responses	List, Context Store Search

Linkedin-Ads API docs

See the official Linkedin-Ads API reference.

Interfaces

Use the Linkedin-Ads connector through the Airbyte Agent CLI, the Python SDK, or the API.

CLI

Install the CLI:

curl -fsSL https://airbyte.ai/install.sh | bash

Authenticate with Airbyte:

airbyte-agent login

Create the connector. The CLI opens the hosted setup flow:

airbyte-agent connectors create --json '{
  "workspace": "<your_workspace_name>",
  "name": "linkedin-ads"
}'

Describe the connector to see its supported entities and actions:

airbyte-agent connectors describe --json '{
  "workspace": "<your_workspace_name>",
  "name": "linkedin-ads"
}'

Execute an action:

airbyte-agent connectors execute --json '{
  "workspace": "<your_workspace_name>",
  "name": "linkedin-ads",
  "entity": "accounts",
  "action": "list"
}'

Python SDK

Installation

uv pip install airbyte-agent-sdk

Usage

Connectors can run in hosted or open source mode.

Hosted

In hosted mode, API credentials are stored securely in Airbyte Agents. You provide your Airbyte credentials instead. If your Airbyte client can access multiple organizations, also set organization_id.

This example assumes you've already authenticated your connector with Airbyte. See Authentication to learn more about authenticating. If you need a step-by-step guide, see the hosted execution tutorial.

The connect() factory returns a fully typed LinkedinAdsConnector and reads AIRBYTE_CLIENT_ID / AIRBYTE_CLIENT_SECRET from the environment:

The recommended pattern is build_connector_tools, which gives the agent three tools bound to this connector: inspect_connector, read_skill_docs, and execute. The agent can inspect the connector, read only the skill-doc section it needs, and then execute:

inspect_connector() -> read_skill_docs() -> read_skill_docs(section="...") -> execute(entity, action, params)

Pydantic AI
LangChain
OpenAI Agents
FastMCP

Pydantic AI
from airbyte_agent_sdk import build_connector_tools
from pydantic_ai import Agent
from airbyte_agent_sdk import connect
from airbyte_agent_sdk.connectors.linkedin_ads import LinkedinAdsConnector

connector = connect("linkedin-ads", workspace_name="<your_workspace_name>")

tools = build_connector_tools(connector, framework="pydantic_ai")
agent = Agent("openai:gpt-4o", tools=tools.as_list())

LangChain
from airbyte_agent_sdk import build_connector_tools
from langchain_core.tools import StructuredTool
from airbyte_agent_sdk import connect
from airbyte_agent_sdk.connectors.linkedin_ads import LinkedinAdsConnector

connector = connect("linkedin-ads", workspace_name="<your_workspace_name>")

tools = build_connector_tools(connector, framework="langchain")
langchain_tools = [
    StructuredTool.from_function(
        coroutine=tool,
        name=tool.__name__,
        description=tool.__doc__,
    )
    for tool in tools.as_list()
]

OpenAI Agents
from airbyte_agent_sdk import build_connector_tools
from agents import Agent, function_tool
from airbyte_agent_sdk import connect
from airbyte_agent_sdk.connectors.linkedin_ads import LinkedinAdsConnector

connector = connect("linkedin-ads", workspace_name="<your_workspace_name>")

tools = build_connector_tools(connector, framework="openai_agents")
openai_tools = [function_tool(tool, strict_mode=False) for tool in tools.as_list()]

agent = Agent(name="Linkedin-Ads Assistant", tools=openai_tools)

FastMCP
from airbyte_agent_sdk import build_connector_tools
from fastmcp import FastMCP
from airbyte_agent_sdk import connect
from airbyte_agent_sdk.connectors.linkedin_ads import LinkedinAdsConnector

connector = connect("linkedin-ads", workspace_name="<your_workspace_name>")

mcp = FastMCP("Linkedin-Ads Agent")

for tool in build_connector_tools(connector, framework="mcp").as_list():
    mcp.tool(tool)

Legacy alternatives

These examples are kept for existing integrations. For new agents, use build_connector_tools above. The legacy LinkedinAdsConnector.tool_utils pattern loads the connector's full generated catalog into one broad execute tool description instead of letting the agent read skill docs on demand.

Pydantic AI
LangChain
OpenAI Agents
FastMCP

Pydantic AI
from pydantic_ai import Agent
from airbyte_agent_sdk import connect
from airbyte_agent_sdk.connectors.linkedin_ads import LinkedinAdsConnector

connector = connect("linkedin-ads", workspace_name="<your_workspace_name>")

agent = Agent("openai:gpt-4o")

@agent.tool_plain
@LinkedinAdsConnector.tool_utils
async def linkedin_ads_execute(entity: str, action: str, params: dict | None = None):
    return await connector.execute(entity, action, params or {})

LangChain
from langchain_core.tools import tool
from airbyte_agent_sdk import connect
from airbyte_agent_sdk.connectors.linkedin_ads import LinkedinAdsConnector

connector = connect("linkedin-ads", workspace_name="<your_workspace_name>")

@tool
@LinkedinAdsConnector.tool_utils
async def linkedin_ads_execute(entity: str, action: str, params: dict | None = None):
    """Execute Linkedin-Ads connector operations."""
    result = await connector.execute(entity, action, params or {})
    # connector.execute returns a Pydantic envelope for typed actions; fall back to raw data otherwise.
    return result.model_dump(mode="json") if hasattr(result, "model_dump") else result

OpenAI Agents
from agents import Agent, function_tool
from airbyte_agent_sdk import connect
from airbyte_agent_sdk.connectors.linkedin_ads import LinkedinAdsConnector

connector = connect("linkedin-ads", workspace_name="<your_workspace_name>")

# strict_mode=False because `params: dict` is permissive and the default strict
# JSON schema rejects objects with additionalProperties.
@function_tool(strict_mode=False)
@LinkedinAdsConnector.tool_utils(framework="openai_agents")
async def linkedin_ads_execute(entity: str, action: str, params: dict | None = None):
    """Execute Linkedin-Ads connector operations."""
    result = await connector.execute(entity, action, params or {})
    return result.model_dump(mode="json") if hasattr(result, "model_dump") else result

agent = Agent(name="Linkedin-Ads Assistant", tools=[linkedin_ads_execute])

FastMCP
from fastmcp import FastMCP
from airbyte_agent_sdk import connect
from airbyte_agent_sdk.connectors.linkedin_ads import LinkedinAdsConnector

connector = connect("linkedin-ads", workspace_name="<your_workspace_name>")

mcp = FastMCP("Linkedin-Ads Agent")

@mcp.tool
@LinkedinAdsConnector.tool_utils
async def linkedin_ads_execute(entity: str, action: str, params: dict | None = None):
    """Execute Linkedin-Ads connector operations."""
    result = await connector.execute(entity, action, params or {})
    return result.model_dump(mode="json") if hasattr(result, "model_dump") else result

Or pass credentials explicitly (equivalent, useful when you're not loading them from the environment):

Pydantic AI
LangChain
OpenAI Agents
FastMCP

Pydantic AI
from airbyte_agent_sdk import build_connector_tools
from pydantic_ai import Agent
from airbyte_agent_sdk.connectors.linkedin_ads import LinkedinAdsConnector
from airbyte_agent_sdk.types import AirbyteAuthConfig

connector = LinkedinAdsConnector(
    auth_config=AirbyteAuthConfig(
        workspace_name="<your_workspace_name>",
        organization_id="<your_organization_id>",  # Optional for multi-org clients
        airbyte_client_id="<your-client-id>",
        airbyte_client_secret="<your-client-secret>"
    )
)

tools = build_connector_tools(connector, framework="pydantic_ai")
agent = Agent("openai:gpt-4o", tools=tools.as_list())

LangChain
from airbyte_agent_sdk import build_connector_tools
from langchain_core.tools import StructuredTool
from airbyte_agent_sdk.connectors.linkedin_ads import LinkedinAdsConnector
from airbyte_agent_sdk.types import AirbyteAuthConfig

connector = LinkedinAdsConnector(
    auth_config=AirbyteAuthConfig(
        workspace_name="<your_workspace_name>",
        organization_id="<your_organization_id>",  # Optional for multi-org clients
        airbyte_client_id="<your-client-id>",
        airbyte_client_secret="<your-client-secret>"
    )
)

tools = build_connector_tools(connector, framework="langchain")
langchain_tools = [
    StructuredTool.from_function(
        coroutine=tool,
        name=tool.__name__,
        description=tool.__doc__,
    )
    for tool in tools.as_list()
]

OpenAI Agents
from airbyte_agent_sdk import build_connector_tools
from agents import Agent, function_tool
from airbyte_agent_sdk.connectors.linkedin_ads import LinkedinAdsConnector
from airbyte_agent_sdk.types import AirbyteAuthConfig

connector = LinkedinAdsConnector(
    auth_config=AirbyteAuthConfig(
        workspace_name="<your_workspace_name>",
        organization_id="<your_organization_id>",  # Optional for multi-org clients
        airbyte_client_id="<your-client-id>",
        airbyte_client_secret="<your-client-secret>"
    )
)

tools = build_connector_tools(connector, framework="openai_agents")
openai_tools = [function_tool(tool, strict_mode=False) for tool in tools.as_list()]

agent = Agent(name="Linkedin-Ads Assistant", tools=openai_tools)

FastMCP
from airbyte_agent_sdk import build_connector_tools
from fastmcp import FastMCP
from airbyte_agent_sdk.connectors.linkedin_ads import LinkedinAdsConnector
from airbyte_agent_sdk.types import AirbyteAuthConfig

connector = LinkedinAdsConnector(
    auth_config=AirbyteAuthConfig(
        workspace_name="<your_workspace_name>",
        organization_id="<your_organization_id>",  # Optional for multi-org clients
        airbyte_client_id="<your-client-id>",
        airbyte_client_secret="<your-client-secret>"
    )
)

mcp = FastMCP("Linkedin-Ads Agent")

for tool in build_connector_tools(connector, framework="mcp").as_list():
    mcp.tool(tool)

Open source

In open source mode, you provide API credentials directly to the connector.

inspect_connector() -> read_skill_docs() -> read_skill_docs(section="...") -> execute(entity, action, params)

Pydantic AI
LangChain
OpenAI Agents
FastMCP

Pydantic AI
from airbyte_agent_sdk import build_connector_tools
from pydantic_ai import Agent
from airbyte_agent_sdk.connectors.linkedin_ads import LinkedinAdsConnector
from airbyte_agent_sdk.connectors.linkedin_ads.models import LinkedinAdsAccessTokenAuthenticationAuthConfig

connector = LinkedinAdsConnector(
    auth_config=LinkedinAdsAccessTokenAuthenticationAuthConfig(
        access_token="<The access token generated for your developer application>"
    )
)

tools = build_connector_tools(connector, framework="pydantic_ai")
agent = Agent("openai:gpt-4o", tools=tools.as_list())

LangChain
from airbyte_agent_sdk import build_connector_tools
from langchain_core.tools import StructuredTool
from airbyte_agent_sdk.connectors.linkedin_ads import LinkedinAdsConnector
from airbyte_agent_sdk.connectors.linkedin_ads.models import LinkedinAdsAccessTokenAuthenticationAuthConfig

connector = LinkedinAdsConnector(
    auth_config=LinkedinAdsAccessTokenAuthenticationAuthConfig(
        access_token="<The access token generated for your developer application>"
    )
)

tools = build_connector_tools(connector, framework="langchain")
langchain_tools = [
    StructuredTool.from_function(
        coroutine=tool,
        name=tool.__name__,
        description=tool.__doc__,
    )
    for tool in tools.as_list()
]

OpenAI Agents
from airbyte_agent_sdk import build_connector_tools
from agents import Agent, function_tool
from airbyte_agent_sdk.connectors.linkedin_ads import LinkedinAdsConnector
from airbyte_agent_sdk.connectors.linkedin_ads.models import LinkedinAdsAccessTokenAuthenticationAuthConfig

connector = LinkedinAdsConnector(
    auth_config=LinkedinAdsAccessTokenAuthenticationAuthConfig(
        access_token="<The access token generated for your developer application>"
    )
)

tools = build_connector_tools(connector, framework="openai_agents")
openai_tools = [function_tool(tool, strict_mode=False) for tool in tools.as_list()]

agent = Agent(name="Linkedin-Ads Assistant", tools=openai_tools)

FastMCP
from airbyte_agent_sdk import build_connector_tools
from fastmcp import FastMCP
from airbyte_agent_sdk.connectors.linkedin_ads import LinkedinAdsConnector
from airbyte_agent_sdk.connectors.linkedin_ads.models import LinkedinAdsAccessTokenAuthenticationAuthConfig

connector = LinkedinAdsConnector(
    auth_config=LinkedinAdsAccessTokenAuthenticationAuthConfig(
        access_token="<The access token generated for your developer application>"
    )
)

mcp = FastMCP("Linkedin-Ads Agent")

for tool in build_connector_tools(connector, framework="mcp").as_list():
    mcp.tool(tool)

Legacy alternatives

Pydantic AI
LangChain
OpenAI Agents
FastMCP

Pydantic AI
from pydantic_ai import Agent
from airbyte_agent_sdk.connectors.linkedin_ads import LinkedinAdsConnector
from airbyte_agent_sdk.connectors.linkedin_ads.models import LinkedinAdsAccessTokenAuthenticationAuthConfig

connector = LinkedinAdsConnector(
    auth_config=LinkedinAdsAccessTokenAuthenticationAuthConfig(
        access_token="<The access token generated for your developer application>"
    )
)

agent = Agent("openai:gpt-4o")

@agent.tool_plain
@LinkedinAdsConnector.tool_utils
async def linkedin_ads_execute(entity: str, action: str, params: dict | None = None):
    return await connector.execute(entity, action, params or {})

LangChain
from langchain_core.tools import tool
from airbyte_agent_sdk.connectors.linkedin_ads import LinkedinAdsConnector
from airbyte_agent_sdk.connectors.linkedin_ads.models import LinkedinAdsAccessTokenAuthenticationAuthConfig

connector = LinkedinAdsConnector(
    auth_config=LinkedinAdsAccessTokenAuthenticationAuthConfig(
        access_token="<The access token generated for your developer application>"
    )
)

@tool
@LinkedinAdsConnector.tool_utils
async def linkedin_ads_execute(entity: str, action: str, params: dict | None = None):
    """Execute Linkedin-Ads connector operations."""
    result = await connector.execute(entity, action, params or {})
    # connector.execute returns a Pydantic envelope for typed actions; fall back to raw data otherwise.
    return result.model_dump(mode="json") if hasattr(result, "model_dump") else result

OpenAI Agents
from agents import Agent, function_tool
from airbyte_agent_sdk.connectors.linkedin_ads import LinkedinAdsConnector
from airbyte_agent_sdk.connectors.linkedin_ads.models import LinkedinAdsAccessTokenAuthenticationAuthConfig

connector = LinkedinAdsConnector(
    auth_config=LinkedinAdsAccessTokenAuthenticationAuthConfig(
        access_token="<The access token generated for your developer application>"
    )
)

# strict_mode=False because `params: dict` is permissive and the default strict
# JSON schema rejects objects with additionalProperties.
@function_tool(strict_mode=False)
@LinkedinAdsConnector.tool_utils(framework="openai_agents")
async def linkedin_ads_execute(entity: str, action: str, params: dict | None = None):
    """Execute Linkedin-Ads connector operations."""
    result = await connector.execute(entity, action, params or {})
    return result.model_dump(mode="json") if hasattr(result, "model_dump") else result

agent = Agent(name="Linkedin-Ads Assistant", tools=[linkedin_ads_execute])

FastMCP
from fastmcp import FastMCP
from airbyte_agent_sdk.connectors.linkedin_ads import LinkedinAdsConnector
from airbyte_agent_sdk.connectors.linkedin_ads.models import LinkedinAdsAccessTokenAuthenticationAuthConfig

connector = LinkedinAdsConnector(
    auth_config=LinkedinAdsAccessTokenAuthenticationAuthConfig(
        access_token="<The access token generated for your developer application>"
    )
)

mcp = FastMCP("Linkedin-Ads Agent")

@mcp.tool
@LinkedinAdsConnector.tool_utils
async def linkedin_ads_execute(entity: str, action: str, params: dict | None = None):
    """Execute Linkedin-Ads connector operations."""
    result = await connector.execute(entity, action, params or {})
    return result.model_dump(mode="json") if hasattr(result, "model_dump") else result

Authentication

For all authentication options, see the connector's authentication documentation.

IP allow list

If your organization restricts access to specific IPs, add the Airbyte Agents IP addresses to your allow list.

Version information

Connector version: 1.2.0

Example prompts​

Unsupported prompts​

Entities and actions​

Linkedin-Ads API docs​

Interfaces​

CLI​

Python SDK​

Installation​

Usage​

Hosted​

Legacy alternatives​

Open source​

Legacy alternatives​

Authentication​

IP allow list​

Version information​

Example prompts

Unsupported prompts

Entities and actions

Linkedin-Ads API docs

Interfaces

CLI

Python SDK

Installation

Usage

Hosted

Legacy alternatives

Open source

Legacy alternatives

Authentication

IP allow list

Version information