chatgpt-ads-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 chatgpt-ads-mcp contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,274 @@
+# ChatGPT Ads MCP Server
+
+An [MCP](https://modelcontextprotocol.io) server that lets an AI assistant (Claude
+Desktop, Claude Code, or any MCP client) manage your **ChatGPT Ads** campaigns
+through plain conversation. It wraps the official
+[OpenAI Advertiser API](https://developers.openai.com/ads/api-overview), so you
+can say things like *"create a paused campaign with a $500 lifetime budget"* or
+*"show me yesterday's clicks and spend by campaign"* and the assistant calls the
+API for you.
+
+> **You provide:** one API key from ChatGPT Ads Manager.
+> **You get:** full campaign management without touching the dashboard.
+
+---
+
+## What it can do
+
+| Area | Tools |
+| --- | --- |
+| **Campaigns** | `list_campaigns`, `get_campaign`, `create_campaign`, `update_campaign`, `activate_campaign`, `pause_campaign`, `archive_campaign` |
+| **Ad groups** | `list_ad_groups`, `get_ad_group`, `create_ad_group`, `update_ad_group`, `activate_ad_group`, `pause_ad_group`, `archive_ad_group` |
+| **Ads** | `list_ads`, `get_ad`, `create_ad`, `update_ad`, `activate_ad`, `pause_ad`, `archive_ad` |
+| **Creatives** | `upload_creative` (image URL or local file → `file_id`) |
+| **Reporting** | `get_insights` (account / campaign / ad-group / ad level: impressions, clicks, spend, CTR, CPC, CPM) |
+| **Targeting** | `search_locations` (find country/region/DMA IDs by name; use with `include_location_ids` on campaigns) |
+| **Find by name** | `find_campaigns`, `find_ad_groups`, `find_ads` (match by name across all pages — no ID needed) |
+| **Accounts** | `list_accounts`, `get_ad_account` (account name, currency, timezone) |
+
+That's full create-read-update plus the activate / pause / archive lifecycle — 29 tools in total. It supports **multiple ad accounts** from a single server (see below). List tools also accept `fetch_all: true` to return every page at once.
+
+## Documentation
+
+- **[Tool reference](docs/TOOL_REFERENCE.md)** — every tool with its parameters (auto-generated from the server).
+- **[Configuration](docs/CONFIGURATION.md)** — environment variables, single vs. multiple accounts, client setup, security.
+- **[Architecture](docs/ARCHITECTURE.md)** — how the server is structured and why.
+- **[Contributing](CONTRIBUTING.md)** — local setup and how to add a tool.
+- **[Changelog](CHANGELOG.md)** — version history.
+
+---
+
+## Setup (step by step)
+
+You don't need to be technical — just follow these in order.
+
+> **macOS shortcut:** after installing Node.js and downloading this repo, run
+> `bash setup.sh` from the project folder. It installs, builds, asks for your API key,
+> and wires up the Claude Desktop config automatically. The manual steps below are the
+> equivalent for any platform.
+
+### Easiest: run via `npx` (once published to npm)
+
+If the package is published to npm (see [docs/PUBLISHING.md](docs/PUBLISHING.md)), you
+don't need to clone or build anything — point Claude Desktop straight at it:
+
+```json
+{
+  "mcpServers": {
+    "chatgpt-ads": {
+      "command": "npx",
+      "args": ["-y", "chatgpt-ads-mcp"],
+      "env": { "OPENAI_ADS_API_KEY": "sk-ads-..." }
+    }
+  }
+}
+```
+
+`npx` always fetches the latest published version, so you get fixes automatically (no
+re-downloading). The manual build steps below remain available if you prefer running
+from source.
+
+### 1. Get your API key
+
+1. Go to **ChatGPT Ads Manager → Settings → API keys**.
+2. Create a key. Each key is tied to **one ad account**.
+3. Copy it somewhere safe. You'll paste it into the config below — **never** put it
+   in a shared file or commit it to GitHub.
+
+### 2. Install Node.js
+
+If you don't already have it, install **Node.js 18 or newer** from
+[nodejs.org](https://nodejs.org). (This project is tested on Node 22.)
+
+### 3. Download and build this server
+
+In a terminal:
+
+```bash
+git clone https://github.com/codynguyen18/chatgpt-ads-mcp.git
+cd chatgpt-ads-mcp
+npm install
+npm run build
+```
+
+This creates a `dist/` folder containing the runnable server. Note the full path —
+run `pwd` and copy it; you'll need it in the next step.
+
+### 4. Connect it to your AI assistant
+
+**Claude Desktop** — open its config file:
+
+- macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
+- Windows: `%APPDATA%\Claude\claude_desktop_config.json`
+
+Add this (replace the path and the key with your own):
+
+```json
+{
+  "mcpServers": {
+    "chatgpt-ads": {
+      "command": "node",
+      "args": ["/full/path/to/chatgpt-ads-mcp/dist/index.js"],
+      "env": {
+        "OPENAI_ADS_API_KEY": "paste-your-key-here"
+      }
+    }
+  }
+}
+```
+
+Restart Claude Desktop. You should see the ChatGPT Ads tools appear.
+
+**Claude Code** — register it from the project folder:
+
+```bash
+claude mcp add chatgpt-ads --env OPENAI_ADS_API_KEY=paste-your-key-here -- node /full/path/to/chatgpt-ads-mcp/dist/index.js
+```
+
+---
+
+## Multiple ad accounts
+
+One server can manage several ad accounts. Because each API key is tied to one ad
+account, you give each account a **name** and its own key, then tell the assistant
+which one to use ("…in the client-a account").
+
+Set `OPENAI_ADS_ACCOUNTS` to a JSON object of `name: key`, and optionally
+`OPENAI_ADS_DEFAULT_ACCOUNT` for the one to use when you don't say:
+
+```json
+{
+  "mcpServers": {
+    "chatgpt-ads": {
+      "command": "node",
+      "args": ["/full/path/to/chatgpt-ads-mcp/dist/index.js"],
+      "env": {
+        "OPENAI_ADS_ACCOUNTS": "{\"main\":\"sk-ads-aaa\",\"client-a\":\"sk-ads-bbb\",\"client-b\":\"sk-ads-ccc\"}",
+        "OPENAI_ADS_DEFAULT_ACCOUNT": "main"
+      }
+    }
+  }
+}
+```
+
+> The value of `OPENAI_ADS_ACCOUNTS` is JSON **inside a string**, so the inner
+> quotes are escaped with `\"` — copy the shape above and swap in your names/keys.
+
+Then in conversation:
+
+- *"List campaigns in the **client-a** account."*
+- *"Pause everything in **client-b**."*
+- *"Which ad accounts do you have access to?"* → uses `list_accounts`.
+
+If you don't name an account, the assistant uses your default (or, if you only
+configured one, that one). If several are configured with no default, it will ask
+you to pick. A single `OPENAI_ADS_API_KEY` still works and is registered as the
+account named `default`.
+
+---
+
+## Try it
+
+Once connected, just talk to your assistant:
+
+- *"List my active campaigns."*
+- *"Create a paused campaign called 'Summer Launch' with a $500 lifetime budget targeting California and Texas."* (it uses `search_locations`, then `include_location_ids`)
+- *"In that campaign, make an ad group with a $4 max bid."*
+- *"Upload this image https://example.com/banner.png and use it in a new ad titled 'Try it free' linking to https://mysite.com."*
+- *"Pause the ad group named 'Test'."* (it uses `find_ad_groups` to resolve the name, then pauses)
+- *"Show me impressions, clicks, and spend by campaign for the last 7 days."*
+- *"What currency is my ad account in?"* (uses `get_ad_account`)
+
+The assistant picks the right tool and fills in the details.
+
+---
+
+## Good to know
+
+- **Money is in "micros."** The API measures budgets and bids in *micros* of your
+  account currency, where **1,000,000 micros = 1.00** (so $25 = `25000000`). You can
+  just say "$25" in conversation and the assistant converts it — this is only
+  relevant if you read the raw numbers.
+- **Archiving is permanent.** `archive_*` cannot be undone. Pause instead if you
+  only want to stop delivery temporarily.
+- **Real spend.** Activating campaigns/ads can spend real money on a live account.
+  A safe habit: create things as `paused`, review in the dashboard, then activate.
+- **One key per ad account.** Each ChatGPT Ads API key is scoped to a single ad
+  account. To manage several, see **Multiple ad accounts** below.
+
+---
+
+## Configuration
+
+| Environment variable | Required | Description |
+| --- | --- | --- |
+| `OPENAI_ADS_API_KEY` | Yes | Your ChatGPT Ads API key (scoped to one ad account). |
+| `OPENAI_ADS_BASE_URL` | No | Override the API base URL. Defaults to `https://api.ads.openai.com/v1`. |
+
+See `.env.example` for a template.
+
+---
+
+## Troubleshooting
+
+- **"Missing OPENAI_ADS_API_KEY"** — the key isn't reaching the server. Double-check
+  the `env` block in your config and restart the client.
+- **401 / 403 errors** — the key is wrong, revoked, or for a different ad account.
+- **404 errors** — usually the resource ID doesn't exist, or the endpoint isn't
+  available for your account yet.
+- **Tools don't appear** — confirm the `args` path points to the built
+  `dist/index.js` (not `src/`), and that you ran `npm run build`.
+
+---
+
+## For developers
+
+```bash
+npm install      # install dependencies
+npm run build    # compile TypeScript to dist/
+npm run dev      # recompile on change
+npm start        # run the built server (expects OPENAI_ADS_API_KEY in the env)
+npm run docs:tools  # regenerate docs/TOOL_REFERENCE.md from the server
+```
+
+Source layout:
+
+- `src/index.ts` — entry point; loads accounts and starts the stdio server.
+- `src/config.ts` — parses the account configuration from environment variables.
+- `src/client.ts` — multi-account HTTP client over the Advertiser API (auth, query/body, upload, errors).
+- `src/tools.ts` — the 29 MCP tool definitions and their handlers.
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for conventions and how to add a tool, and
+[docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) for the design.
+
+---
+
+## Not included (and why)
+
+OpenAI's Ads platform has two measurement features that are deliberately **out of
+scope** for this server:
+
+- **JavaScript pixel** — browser-side tracking code you paste into your website. It
+  isn't a server API, so it has no place in an MCP server.
+- **Conversions API** — a server-to-server feed for sending conversion events
+  (purchases, sign-ups). It's designed to fire automatically from your backend the
+  moment an event happens, in real time and at volume — not to be triggered by hand
+  through a chat assistant. That logic belongs in your application code. (The only
+  niche fits would be backfilling a test event or logging an offline conversion.)
+
+If you do want a tool for sending the occasional offline/test conversion, it's a
+small addition — open an issue.
+
+## Notes & disclaimer
+
+The OpenAI Advertiser API is new (2026) and still evolving. This server is built
+against the published reference and may need small updates as endpoints change.
+Where the docs are sparse, the create/update tools accept an optional `extra`
+field so the assistant can pass additional raw API fields without a code change.
+
+This is an unofficial, community project and is not affiliated with or endorsed by
+OpenAI.
+
+## License
+
+MIT

package/dist/client.js

@@ -0,0 +1,158 @@
+import { readFile } from "node:fs/promises";
+import { basename } from "node:path";
+const DEFAULT_BASE_URL = "https://api.ads.openai.com/v1";
+/** Error thrown when the Ads API returns a non-2xx response. */
+export class AdsApiError extends Error {
+    status;
+    body;
+    constructor(status, message, body) {
+        super(message);
+        this.name = "AdsApiError";
+        this.status = status;
+        this.body = body;
+    }
+}
+/**
+ * Thin client over the OpenAI Advertiser API.
+ *
+ * Holds one or more ad accounts (each identified by name and backed by its own
+ * API key) and selects the right key per request. Handles auth, query/body
+ * serialization, multipart upload, and error parsing.
+ */
+export class AdsClient {
+    accounts;
+    explicitDefault;
+    baseUrl;
+    rootUrl;
+    constructor(options) {
+        this.accounts = new Map(Object.entries(options.accounts));
+        if (this.accounts.size === 0) {
+            throw new Error("No ad accounts configured.");
+        }
+        if (options.defaultAccount && !this.accounts.has(options.defaultAccount)) {
+            throw new Error(`Default account '${options.defaultAccount}' is not one of the configured accounts: ` +
+                `${this.accountNames().join(", ")}.`);
+        }
+        this.explicitDefault = options.defaultAccount;
+        this.baseUrl = (options.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
+        // Geo lookup is addressed from the v1 root. With the default base this equals
+        // baseUrl; the replace only matters if a caller overrides baseUrl with a /ads suffix.
+        this.rootUrl = this.baseUrl.replace(/\/ads$/, "");
+    }
+    /** Names of all configured ad accounts. */
+    accountNames() {
+        return [...this.accounts.keys()];
+    }
+    /** The account used when none is specified, or undefined if it must be chosen explicitly. */
+    getDefaultAccount() {
+        if (this.explicitDefault)
+            return this.explicitDefault;
+        if (this.accounts.size === 1)
+            return this.accountNames()[0];
+        return undefined;
+    }
+    resolveKey(account) {
+        if (account) {
+            const key = this.accounts.get(account);
+            if (!key) {
+                throw new Error(`Unknown ad account '${account}'. Configured accounts: ${this.accountNames().join(", ")}.`);
+            }
+            return key;
+        }
+        const fallback = this.getDefaultAccount();
+        if (!fallback) {
+            throw new Error(`Multiple ad accounts are configured (${this.accountNames().join(", ")}). ` +
+                "Specify which one with the 'account' parameter, or set a default account.");
+        }
+        return this.accounts.get(fallback);
+    }
+    buildUrl(path, query, root = false) {
+        const url = new URL((root ? this.rootUrl : this.baseUrl) + path);
+        if (query) {
+            for (const [key, value] of Object.entries(query)) {
+                if (value === undefined || value === null)
+                    continue;
+                if (Array.isArray(value)) {
+                    // The Ads API expects repeated array syntax: key[]=a&key[]=b
+                    for (const item of value) {
+                        url.searchParams.append(`${key}[]`, typeof item === "object" ? JSON.stringify(item) : String(item));
+                    }
+                }
+                else if (typeof value === "object") {
+                    url.searchParams.set(key, JSON.stringify(value));
+                }
+                else {
+                    url.searchParams.set(key, String(value));
+                }
+            }
+        }
+        return url.toString();
+    }
+    async parseResponse(res) {
+        const text = await res.text();
+        let data = text;
+        if (text) {
+            try {
+                data = JSON.parse(text);
+            }
+            catch {
+                // Leave as raw text if not JSON.
+            }
+        }
+        if (!res.ok) {
+            throw new AdsApiError(res.status, extractErrorMessage(data, res), data);
+        }
+        return data;
+    }
+    /** Issue a JSON request against the Ads API. */
+    async request(method, path, options = {}) {
+        const apiKey = this.resolveKey(options.account);
+        const url = this.buildUrl(path, options.query, options.root);
+        const headers = {
+            Authorization: `Bearer ${apiKey}`,
+            Accept: "application/json",
+        };
+        let body;
+        if (options.body !== undefined) {
+            headers["Content-Type"] = "application/json";
+            body = JSON.stringify(options.body);
+        }
+        const res = await fetch(url, { method, headers, body });
+        return (await this.parseResponse(res));
+    }
+    /** Upload a creative image from a publicly reachable URL. */
+    async uploadCreativeFromUrl(imageUrl, account) {
+        return this.request("POST", "/upload", { body: { image_url: imageUrl }, account });
+    }
+    /** Upload a creative image from a local file path (multipart/form-data). */
+    async uploadCreativeFromFile(filePath, account) {
+        const apiKey = this.resolveKey(account);
+        const buffer = await readFile(filePath);
+        const form = new FormData();
+        // Node 18+ provides global FormData/Blob.
+        form.append("file", new Blob([buffer]), basename(filePath));
+        const res = await fetch(this.buildUrl("/upload"), {
+            method: "POST",
+            headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json" },
+            body: form,
+        });
+        return this.parseResponse(res);
+    }
+}
+function extractErrorMessage(data, res) {
+    if (data && typeof data === "object") {
+        const err = data.error;
+        if (err && typeof err === "object") {
+            const message = err.message;
+            if (typeof message === "string")
+                return `${res.status} ${res.statusText}: ${message}`;
+        }
+        if (typeof data.message === "string") {
+            return `${res.status} ${res.statusText}: ${data.message}`;
+        }
+    }
+    if (typeof data === "string" && data.trim()) {
+        return `${res.status} ${res.statusText}: ${data.trim()}`;
+    }
+    return `${res.status} ${res.statusText}`;
+}

package/dist/config.js

@@ -0,0 +1,64 @@
+/**
+ * Build the accounts configuration from environment variables:
+ *
+ *   OPENAI_ADS_API_KEY        Single account (registered under the name "default").
+ *   OPENAI_ADS_ACCOUNTS       Multiple accounts as JSON. Either an object
+ *                             { "main": "sk-...", "client-a": "sk-..." }
+ *                             or an array
+ *                             [ { "name": "main", "api_key": "sk-...", "default": true }, ... ].
+ *   OPENAI_ADS_DEFAULT_ACCOUNT  Name of the account to use when `account` is omitted.
+ *
+ * The single and multiple forms can be combined; OPENAI_ADS_API_KEY becomes the
+ * account named "default".
+ */
+export function loadAccountsConfig(env = process.env) {
+    const accounts = {};
+    let defaultFromArray;
+    const single = env.OPENAI_ADS_API_KEY?.trim();
+    if (single) {
+        accounts["default"] = single;
+    }
+    const multi = env.OPENAI_ADS_ACCOUNTS?.trim();
+    if (multi) {
+        let parsed;
+        try {
+            parsed = JSON.parse(multi);
+        }
+        catch {
+            throw new Error('OPENAI_ADS_ACCOUNTS must be valid JSON, e.g. {"main":"sk-...","client-a":"sk-..."}');
+        }
+        if (Array.isArray(parsed)) {
+            for (const entry of parsed) {
+                if (!entry || typeof entry !== "object") {
+                    throw new Error("Each entry in OPENAI_ADS_ACCOUNTS must be an object.");
+                }
+                const name = entry.name;
+                const key = entry.api_key ?? entry.key;
+                if (typeof name !== "string" || typeof key !== "string") {
+                    throw new Error("Each account in OPENAI_ADS_ACCOUNTS needs a 'name' and an 'api_key'.");
+                }
+                accounts[name] = key;
+                if (entry.default === true)
+                    defaultFromArray = name;
+            }
+        }
+        else if (parsed && typeof parsed === "object") {
+            for (const [name, key] of Object.entries(parsed)) {
+                if (typeof key !== "string") {
+                    throw new Error(`Account '${name}' in OPENAI_ADS_ACCOUNTS must map to an API key string.`);
+                }
+                accounts[name] = key;
+            }
+        }
+        else {
+            throw new Error("OPENAI_ADS_ACCOUNTS must be a JSON object or array of accounts.");
+        }
+    }
+    const explicitDefault = env.OPENAI_ADS_DEFAULT_ACCOUNT?.trim();
+    const defaultAccount = explicitDefault || defaultFromArray || (single ? "default" : undefined);
+    if (defaultAccount && !accounts[defaultAccount]) {
+        throw new Error(`OPENAI_ADS_DEFAULT_ACCOUNT '${defaultAccount}' is not one of the configured accounts: ` +
+            `${Object.keys(accounts).join(", ") || "(none)"}.`);
+    }
+    return { accounts, defaultAccount };
+}

package/dist/index.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { AdsClient } from "./client.js";
+import { loadAccountsConfig } from "./config.js";
+import { registerTools } from "./tools.js";
+let config;
+try {
+    config = loadAccountsConfig();
+}
+catch (err) {
+    console.error(`Configuration error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+}
+if (Object.keys(config.accounts).length === 0) {
+    console.error("No ad accounts configured. Set OPENAI_ADS_API_KEY for a single account, " +
+        'or OPENAI_ADS_ACCOUNTS (JSON, e.g. {"main":"sk-...","client-a":"sk-..."}) for several. ' +
+        "Get keys from Ads Manager -> Settings -> API keys (one key per ad account).");
+    process.exit(1);
+}
+const client = new AdsClient({
+    accounts: config.accounts,
+    defaultAccount: config.defaultAccount,
+    baseUrl: process.env.OPENAI_ADS_BASE_URL,
+});
+const server = new McpServer({
+    name: "chatgpt-ads-mcp",
+    version: "0.1.0",
+});
+registerTools(server, client);
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    // Logs must go to stderr; stdout is reserved for the MCP protocol.
+    const names = client.accountNames();
+    console.error(`chatgpt-ads-mcp server running on stdio (${names.length} ad account${names.length === 1 ? "" : "s"}: ${names.join(", ")})`);
+}
+main().catch((err) => {
+    console.error("Fatal error starting chatgpt-ads-mcp:", err);
+    process.exit(1);
+});

package/dist/tools.js

@@ -0,0 +1,645 @@
+import { z } from "zod";
+function jsonResult(data) {
+    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+function errorResult(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { content: [{ type: "text", text: `Error: ${message}` }], isError: true };
+}
+/** Wrap an async handler so thrown errors become tool errors instead of crashes. */
+function safe(fn) {
+    return async (args) => {
+        try {
+            return await fn(args);
+        }
+        catch (err) {
+            return errorResult(err);
+        }
+    };
+}
+/** Selects which configured ad account a tool call targets. Present on every tool. */
+const accountShape = {
+    account: z
+        .string()
+        .optional()
+        .describe("Which ad account to use. Omit if only one account is configured (or to use the default); " +
+        "otherwise the configured account name (run list_accounts to see them)."),
+};
+const paginationShape = {
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(500)
+        .optional()
+        .describe("Max results per page (1-500, default 20)."),
+    after: z.string().optional().describe("Pagination cursor: return results after this ID."),
+    before: z.string().optional().describe("Pagination cursor: return results before this ID."),
+    order: z.enum(["asc", "desc"]).optional().describe("Sort by creation time, ascending or descending."),
+};
+const MICROS_NOTE = "Amounts are in micros of your ad account currency (1,000,000 micros = 1.00, so $25 = 25000000).";
+export function registerTools(server, client) {
+    // ---------------------------------------------------------------------------
+    // Accounts
+    // ---------------------------------------------------------------------------
+    server.registerTool("list_accounts", {
+        title: "List configured ad accounts",
+        description: "Show which ad accounts this server is configured with and which is the default. " +
+            "Pass the returned name as the 'account' parameter on other tools.",
+        inputSchema: {},
+    }, safe(async () => jsonResult({
+        accounts: client.accountNames(),
+        default: client.getDefaultAccount() ?? null,
+    })));
+    server.registerTool("get_ad_account", {
+        title: "Get ad account details",
+        description: "Retrieve metadata for the ad account: display name, currency, timezone, and URLs. " +
+            "Budgets and bids are in micros of this account's currency.",
+        inputSchema: { ...accountShape },
+    }, safe(async (args) => jsonResult(await client.request("GET", "/ad_account", { account: args.account }))));
+    // ---------------------------------------------------------------------------
+    // Campaigns
+    // ---------------------------------------------------------------------------
+    registerList(server, client, {
+        resource: "campaigns",
+        path: "/campaigns",
+        description: "List campaigns in the ad account.",
+    });
+    registerGet(server, client, {
+        resource: "campaign",
+        path: "/campaigns",
+        idParam: "campaign_id",
+    });
+    server.registerTool("create_campaign", {
+        title: "Create campaign",
+        description: `Create a new ChatGPT Ads campaign. ${MICROS_NOTE}`,
+        inputSchema: {
+            ...accountShape,
+            name: z.string().min(3).max(1000).describe("Campaign name (3-1000 characters)."),
+            status: z.enum(["active", "paused"]).describe("Initial status."),
+            daily_budget_micros: z
+                .number()
+                .int()
+                .min(1)
+                .optional()
+                .describe(`Daily budget cap in micros. ${MICROS_NOTE} Provide this and/or lifetime_budget_micros.`),
+            lifetime_budget_micros: z
+                .number()
+                .int()
+                .min(1)
+                .optional()
+                .describe(`Lifetime budget cap in micros. ${MICROS_NOTE} Provide this and/or daily_budget_micros.`),
+            bidding_type: z.string().optional().describe("How bids are charged, e.g. 'clicks'."),
+            description: z.string().optional().describe("Optional internal description."),
+            start_time: z.number().int().optional().describe("Unix timestamp (seconds) for campaign start."),
+            end_time: z.number().int().optional().describe("Unix timestamp (seconds) for campaign end."),
+            target_countries: z
+                .array(z.string())
+                .optional()
+                .describe('ISO country codes to target, e.g. ["US"]. Builds targeting.locations.countries.'),
+            target_location_ids: z
+                .array(z.string())
+                .optional()
+                .describe("Location IDs from search_locations (countries/regions/DMAs) to target. Builds targeting.locations.include."),
+            targeting: z
+                .record(z.any())
+                .optional()
+                .describe('Optional raw targeting object for full control, e.g. { "locations": { "countries": ["US"] } }.'),
+            extra: z
+                .record(z.any())
+                .optional()
+                .describe("Advanced: extra raw fields merged into the request body."),
+        },
+    }, safe(async (args) => {
+        const budget = {};
+        if (args.daily_budget_micros !== undefined)
+            budget.daily_spend_limit_micros = args.daily_budget_micros;
+        if (args.lifetime_budget_micros !== undefined)
+            budget.lifetime_spend_limit_micros = args.lifetime_budget_micros;
+        if (Object.keys(budget).length === 0) {
+            throw new Error("Provide a budget: daily_budget_micros and/or lifetime_budget_micros.");
+        }
+        const body = {
+            name: args.name,
+            status: args.status,
+            budget,
+        };
+        if (args.bidding_type !== undefined)
+            body.bidding_type = args.bidding_type;
+        if (args.description !== undefined)
+            body.description = args.description;
+        if (args.start_time !== undefined)
+            body.start_time = args.start_time;
+        if (args.end_time !== undefined)
+            body.end_time = args.end_time;
+        const targeting = buildTargeting(args.targeting, args.target_countries, args.target_location_ids);
+        if (targeting)
+            body.targeting = targeting;
+        Object.assign(body, args.extra ?? {});
+        return jsonResult(await client.request("POST", "/campaigns", { body, account: args.account }));
+    }));
+    server.registerTool("update_campaign", {
+        title: "Update campaign",
+        description: `Update fields on an existing campaign. Only include the fields you want to change. ${MICROS_NOTE}`,
+        inputSchema: {
+            ...accountShape,
+            campaign_id: z.string().describe("ID of the campaign to update."),
+            name: z.string().min(3).max(1000).optional(),
+            status: z.enum(["active", "paused"]).optional(),
+            description: z.string().nullable().optional().describe("Set to null to clear."),
+            daily_budget_micros: z.number().int().min(1).optional().describe(`Daily budget cap in micros. ${MICROS_NOTE}`),
+            lifetime_budget_micros: z.number().int().min(1).optional().describe(`Lifetime budget cap in micros. ${MICROS_NOTE}`),
+            bidding_type: z.string().optional().describe("How bids are charged, e.g. 'clicks'."),
+            start_time: z.number().int().optional(),
+            end_time: z.number().int().optional(),
+            target_countries: z
+                .array(z.string())
+                .optional()
+                .describe('ISO country codes to target, e.g. ["US"]. Sets targeting.locations.countries.'),
+            target_location_ids: z
+                .array(z.string())
+                .optional()
+                .describe("Location IDs from search_locations to target. Sets targeting.locations.include."),
+            targeting: z.record(z.any()).optional(),
+            extra: z.record(z.any()).optional().describe("Advanced: extra raw fields merged into the request body."),
+        },
+    }, safe(async (args) => {
+        const body = {};
+        if (args.name !== undefined)
+            body.name = args.name;
+        if (args.status !== undefined)
+            body.status = args.status;
+        if (args.description !== undefined)
+            body.description = args.description;
+        if (args.daily_budget_micros !== undefined || args.lifetime_budget_micros !== undefined) {
+            const budget = {};
+            if (args.daily_budget_micros !== undefined)
+                budget.daily_spend_limit_micros = args.daily_budget_micros;
+            if (args.lifetime_budget_micros !== undefined)
+                budget.lifetime_spend_limit_micros = args.lifetime_budget_micros;
+            body.budget = budget;
+        }
+        if (args.bidding_type !== undefined)
+            body.bidding_type = args.bidding_type;
+        if (args.start_time !== undefined)
+            body.start_time = args.start_time;
+        if (args.end_time !== undefined)
+            body.end_time = args.end_time;
+        const targeting = buildTargeting(args.targeting, args.target_countries, args.target_location_ids);
+        if (targeting)
+            body.targeting = targeting;
+        Object.assign(body, args.extra ?? {});
+        return jsonResult(await client.request("POST", `/campaigns/${encodeURIComponent(args.campaign_id)}`, {
+            body,
+            account: args.account,
+        }));
+    }));
+    registerLifecycle(server, client, {
+        resource: "campaign",
+        path: "/campaigns",
+        idParam: "campaign_id",
+    });
+    // ---------------------------------------------------------------------------
+    // Ad groups
+    // ---------------------------------------------------------------------------
+    registerList(server, client, {
+        resource: "ad_groups",
+        path: "/ad_groups",
+        description: "List ad groups. Optionally filter by campaign.",
+        extraShape: {
+            campaign_id: z.string().optional().describe("Filter to ad groups within this campaign."),
+        },
+    });
+    registerGet(server, client, {
+        resource: "ad_group",
+        path: "/ad_groups",
+        idParam: "ad_group_id",
+    });
+    server.registerTool("create_ad_group", {
+        title: "Create ad group",
+        description: `Create an ad group inside a campaign. ${MICROS_NOTE}`,
+        inputSchema: {
+            ...accountShape,
+            campaign_id: z.string().describe("Parent campaign ID."),
+            name: z.string().min(3).max(1000).describe("Ad group name (3-1000 characters)."),
+            status: z.enum(["active", "paused"]).describe("Initial status."),
+            max_bid_micros: z
+                .number()
+                .int()
+                .min(1)
+                .max(100_000_000)
+                .describe(`Maximum bid in micros (1 - 100,000,000). ${MICROS_NOTE}`),
+            billing_event_type: z
+                .enum(["impression"])
+                .default("impression")
+                .describe("How you are billed. Currently only 'impression'."),
+            description: z.string().optional(),
+            context_hints: z
+                .array(z.string())
+                .optional()
+                .describe("Free-form audience or placement hints."),
+            extra: z.record(z.any()).optional().describe("Advanced: extra raw fields merged into the request body."),
+        },
+    }, safe(async (args) => {
+        const body = {
+            campaign_id: args.campaign_id,
+            name: args.name,
+            status: args.status,
+            bidding_config: {
+                billing_event_type: args.billing_event_type ?? "impression",
+                max_bid_micros: args.max_bid_micros,
+            },
+        };
+        if (args.description !== undefined)
+            body.description = args.description;
+        if (args.context_hints !== undefined)
+            body.context_hints = args.context_hints;
+        Object.assign(body, args.extra ?? {});
+        return jsonResult(await client.request("POST", "/ad_groups", { body, account: args.account }));
+    }));
+    server.registerTool("update_ad_group", {
+        title: "Update ad group",
+        description: `Update fields on an existing ad group. Only include the fields you want to change. ${MICROS_NOTE}`,
+        inputSchema: {
+            ...accountShape,
+            ad_group_id: z.string().describe("ID of the ad group to update."),
+            name: z.string().min(3).max(1000).optional(),
+            status: z.enum(["active", "paused"]).optional(),
+            max_bid_micros: z.number().int().min(1).max(100_000_000).optional(),
+            billing_event_type: z.enum(["impression"]).optional(),
+            description: z.string().nullable().optional().describe("Set to null to clear."),
+            context_hints: z.array(z.string()).optional(),
+            extra: z.record(z.any()).optional().describe("Advanced: extra raw fields merged into the request body."),
+        },
+    }, safe(async (args) => {
+        const body = {};
+        if (args.name !== undefined)
+            body.name = args.name;
+        if (args.status !== undefined)
+            body.status = args.status;
+        if (args.description !== undefined)
+            body.description = args.description;
+        if (args.context_hints !== undefined)
+            body.context_hints = args.context_hints;
+        if (args.max_bid_micros !== undefined || args.billing_event_type !== undefined) {
+            const bidding = {};
+            if (args.billing_event_type !== undefined)
+                bidding.billing_event_type = args.billing_event_type;
+            if (args.max_bid_micros !== undefined)
+                bidding.max_bid_micros = args.max_bid_micros;
+            body.bidding_config = bidding;
+        }
+        Object.assign(body, args.extra ?? {});
+        return jsonResult(await client.request("POST", `/ad_groups/${encodeURIComponent(args.ad_group_id)}`, {
+            body,
+            account: args.account,
+        }));
+    }));
+    registerLifecycle(server, client, {
+        resource: "ad_group",
+        path: "/ad_groups",
+        idParam: "ad_group_id",
+    });
+    // ---------------------------------------------------------------------------
+    // Ads
+    // ---------------------------------------------------------------------------
+    registerList(server, client, {
+        resource: "ads",
+        path: "/ads",
+        description: "List ads. Optionally filter by ad group or campaign.",
+        extraShape: {
+            ad_group_id: z.string().optional().describe("Filter to ads within this ad group."),
+            campaign_id: z.string().optional().describe("Filter to ads within this campaign."),
+        },
+    });
+    registerGet(server, client, {
+        resource: "ad",
+        path: "/ads",
+        idParam: "ad_id",
+    });
+    server.registerTool("create_ad", {
+        title: "Create ad",
+        description: "Create an ad inside an ad group. The creative is a 'chat_card' with a short title, body, destination URL, and an image (upload it first with upload_creative to get a file_id).",
+        inputSchema: {
+            ...accountShape,
+            ad_group_id: z.string().describe("Parent ad group ID."),
+            name: z.string().min(3).max(1000).describe("Internal ad name (3-1000 characters)."),
+            title: z.string().min(3).max(50).describe("Creative title shown to users (3-50 characters)."),
+            body: z.string().max(100).describe("Creative body text (max 100 characters)."),
+            target_url: z.string().url().describe("Destination URL the ad links to."),
+            file_id: z.string().describe("Image file_id returned by upload_creative."),
+            status: z.enum(["active", "paused"]).describe("Initial status."),
+            creative_type: z.enum(["chat_card"]).default("chat_card").describe("Creative type. Currently only 'chat_card'."),
+            extra: z.record(z.any()).optional().describe("Advanced: extra raw fields merged into the request body."),
+        },
+    }, safe(async (args) => {
+        const body = {
+            ad_group_id: args.ad_group_id,
+            name: args.name,
+            status: args.status,
+            creative: {
+                type: args.creative_type ?? "chat_card",
+                title: args.title,
+                body: args.body,
+                target_url: args.target_url,
+                file_id: args.file_id,
+            },
+        };
+        Object.assign(body, args.extra ?? {});
+        return jsonResult(await client.request("POST", "/ads", { body, account: args.account }));
+    }));
+    server.registerTool("update_ad", {
+        title: "Update ad",
+        description: "Update an ad. Only include the fields you want to change. If you change any creative field, include all creative fields (title, body, target_url, file_id).",
+        inputSchema: {
+            ...accountShape,
+            ad_id: z.string().describe("ID of the ad to update."),
+            name: z.string().min(3).max(1000).optional(),
+            status: z.enum(["active", "paused"]).optional(),
+            title: z.string().min(3).max(50).optional(),
+            body: z.string().max(100).optional(),
+            target_url: z.string().url().optional(),
+            file_id: z.string().optional(),
+            creative_type: z.enum(["chat_card"]).optional(),
+            extra: z.record(z.any()).optional().describe("Advanced: extra raw fields merged into the request body."),
+        },
+    }, safe(async (args) => {
+        const body = {};
+        if (args.name !== undefined)
+            body.name = args.name;
+        if (args.status !== undefined)
+            body.status = args.status;
+        const creativeKeys = ["title", "body", "target_url", "file_id", "creative_type"];
+        if (creativeKeys.some((k) => args[k] !== undefined)) {
+            const creative = { type: args.creative_type ?? "chat_card" };
+            if (args.title !== undefined)
+                creative.title = args.title;
+            if (args.body !== undefined)
+                creative.body = args.body;
+            if (args.target_url !== undefined)
+                creative.target_url = args.target_url;
+            if (args.file_id !== undefined)
+                creative.file_id = args.file_id;
+            body.creative = creative;
+        }
+        Object.assign(body, args.extra ?? {});
+        return jsonResult(await client.request("POST", `/ads/${encodeURIComponent(args.ad_id)}`, {
+            body,
+            account: args.account,
+        }));
+    }));
+    registerLifecycle(server, client, {
+        resource: "ad",
+        path: "/ads",
+        idParam: "ad_id",
+    });
+    // ---------------------------------------------------------------------------
+    // Targeting
+    // ---------------------------------------------------------------------------
+    server.registerTool("search_locations", {
+        title: "Search targeting locations",
+        description: "Look up geographic targeting locations (country, region, or DMA) by name and get their IDs. " +
+            "For country targeting, use the ISO code directly via target_countries; use this for region/DMA ids in a raw targeting object.",
+        inputSchema: {
+            ...accountShape,
+            q: z.string().describe("Location name to search for, e.g. 'California' or 'United Kingdom'."),
+            limit: z.number().int().min(1).max(100).optional().describe("Max results to return."),
+        },
+    }, safe(async (args) => jsonResult(await client.request("GET", "/geo_lookup/search", {
+        query: { q: args.q, limit: args.limit },
+        account: args.account,
+        root: true,
+    }))));
+    // ---------------------------------------------------------------------------
+    // Find by name (lists across all pages and filters client-side)
+    // ---------------------------------------------------------------------------
+    registerFind(server, client, { resource: "campaigns", path: "/campaigns" });
+    registerFind(server, client, {
+        resource: "ad_groups",
+        path: "/ad_groups",
+        extraShape: {
+            campaign_id: z.string().optional().describe("Limit the search to this campaign."),
+        },
+    });
+    registerFind(server, client, {
+        resource: "ads",
+        path: "/ads",
+        extraShape: {
+            ad_group_id: z.string().optional().describe("Limit the search to this ad group."),
+            campaign_id: z.string().optional().describe("Limit the search to this campaign."),
+        },
+    });
+    // ---------------------------------------------------------------------------
+    // Creatives (file upload)
+    // ---------------------------------------------------------------------------
+    server.registerTool("upload_creative", {
+        title: "Upload creative image",
+        description: "Upload an image to use in an ad creative. Provide either image_url (a publicly reachable URL) or file_path (a local file). Returns a file_id to pass to create_ad.",
+        inputSchema: {
+            ...accountShape,
+            image_url: z.string().url().optional().describe("Publicly reachable image URL."),
+            file_path: z.string().optional().describe("Absolute path to a local image file (e.g. PNG)."),
+        },
+    }, safe(async (args) => {
+        if (!args.image_url && !args.file_path) {
+            throw new Error("Provide either image_url or file_path.");
+        }
+        const data = args.image_url
+            ? await client.uploadCreativeFromUrl(args.image_url, args.account)
+            : await client.uploadCreativeFromFile(args.file_path, args.account);
+        return jsonResult(data);
+    }));
+    // ---------------------------------------------------------------------------
+    // Insights / reporting
+    // ---------------------------------------------------------------------------
+    server.registerTool("get_insights", {
+        title: "Get insights / reporting",
+        description: "Retrieve performance metrics. Returns impressions, clicks, spend, ctr, cpc, cpm by default (override with fields). Choose a level: 'account' (whole ad account), or 'campaign' / 'ad_group' / 'ad' (provide the matching id). Daily breakdown by default; set time_granularity 'none' for totals.",
+        inputSchema: {
+            ...accountShape,
+            level: z.enum(["account", "campaign", "ad_group", "ad"]).describe("Aggregation level."),
+            id: z
+                .string()
+                .optional()
+                .describe("Required for campaign/ad_group/ad levels: the resource ID. Omit for 'account'."),
+            since: z.string().optional().describe("Start date, YYYY-MM-DD."),
+            until: z.string().optional().describe("End date, YYYY-MM-DD."),
+            time_granularity: z.enum(["daily", "none"]).optional().describe("Break results down daily, or return totals."),
+            fields: z
+                .array(z.string())
+                .optional()
+                .describe("Metrics to return. Defaults to ['impressions','clicks','spend','ctr','cpc','cpm']. The API returns only impressions unless fields are requested."),
+            limit: z.number().int().min(1).max(10_000).optional().describe("Results per page (1-10,000)."),
+            sort: z.string().optional().describe("Sort expression, e.g. 'spend desc'."),
+            filters: z.any().optional().describe("Advanced filter expression(s)."),
+            after: z.string().optional().describe("Pagination cursor."),
+            before: z.string().optional().describe("Pagination cursor."),
+        },
+    }, safe(async (args) => {
+        let path;
+        switch (args.level) {
+            case "account":
+                path = "/ad_account/insights";
+                break;
+            case "campaign":
+                path = `/campaigns/${encodeURIComponent(requireId(args.id, "campaign"))}/insights`;
+                break;
+            case "ad_group":
+                path = `/ad_groups/${encodeURIComponent(requireId(args.id, "ad_group"))}/insights`;
+                break;
+            case "ad":
+                path = `/ads/${encodeURIComponent(requireId(args.id, "ad"))}/insights`;
+                break;
+            default:
+                throw new Error(`Unknown level: ${args.level}`);
+        }
+        const query = {
+            fields: args.fields ?? ["impressions", "clicks", "spend", "ctr", "cpc", "cpm"],
+        };
+        if (args.since)
+            query.start_date = args.since;
+        if (args.until)
+            query.end_date = args.until;
+        if (args.time_granularity)
+            query.time_granularity = args.time_granularity;
+        if (args.limit)
+            query.limit = args.limit;
+        if (args.sort)
+            query.sort = args.sort;
+        if (args.filters)
+            query.filters = args.filters;
+        if (args.after)
+            query.after = args.after;
+        if (args.before)
+            query.before = args.before;
+        return jsonResult(await client.request("GET", path, { query, account: args.account }));
+    }));
+}
+// -----------------------------------------------------------------------------
+// Generic helpers
+// -----------------------------------------------------------------------------
+function requireId(id, level) {
+    if (!id)
+        throw new Error(`'id' is required when level is '${level}'.`);
+    return id;
+}
+function registerList(server, client, opts) {
+    server.registerTool(`list_${opts.resource}`, {
+        title: `List ${opts.resource.replace(/_/g, " ")}`,
+        description: opts.description,
+        inputSchema: {
+            ...accountShape,
+            ...paginationShape,
+            fetch_all: z
+                .boolean()
+                .optional()
+                .describe("Fetch ALL pages and return the combined list (ignores limit/cursors)."),
+            ...(opts.extraShape ?? {}),
+        },
+    }, safe(async (args) => {
+        const { account, fetch_all, ...query } = args;
+        if (fetch_all) {
+            const items = await listAll(client, opts.path, query, account);
+            return jsonResult({ count: items.length, data: items });
+        }
+        return jsonResult(await client.request("GET", opts.path, { query, account }));
+    }));
+}
+/** Merge a raw targeting object with a convenience list of country codes. */
+function buildTargeting(targeting, countries, locationIds) {
+    const hasCountries = !!(countries && countries.length);
+    const hasIds = !!(locationIds && locationIds.length);
+    if (!targeting && !hasCountries && !hasIds)
+        return undefined;
+    const result = targeting ? { ...targeting } : {};
+    if (hasCountries || hasIds) {
+        const locations = result.locations && typeof result.locations === "object"
+            ? { ...result.locations }
+            : {};
+        if (hasCountries)
+            locations.countries = countries;
+        if (hasIds)
+            locations.include = locationIds.map((id) => ({ id }));
+        result.locations = locations;
+    }
+    return result;
+}
+/** Follow pagination cursors and return every item across all pages. */
+async function listAll(client, path, query, account) {
+    const items = [];
+    let after;
+    for (let page = 0; page < 100; page++) {
+        const res = await client.request("GET", path, {
+            query: { ...query, limit: 500, after },
+            account,
+        });
+        const data = Array.isArray(res?.data) ? res.data : Array.isArray(res) ? res : [];
+        items.push(...data);
+        if (res?.has_more !== true)
+            break;
+        after = res?.last_id ?? data[data.length - 1]?.id;
+        if (!after)
+            break;
+    }
+    return items;
+}
+function registerFind(server, client, opts) {
+    const label = opts.resource.replace(/_/g, " ");
+    server.registerTool(`find_${opts.resource}`, {
+        title: `Find ${label} by name`,
+        description: `Find ${label} whose name matches a search string (case-insensitive). Scans all pages and ` +
+            "filters client-side — useful when you know a name but not an ID.",
+        inputSchema: {
+            ...accountShape,
+            name: z.string().describe("Name (or part of a name) to match, case-insensitive."),
+            exact: z
+                .boolean()
+                .optional()
+                .describe("Require an exact (case-insensitive) match instead of a substring match."),
+            ...(opts.extraShape ?? {}),
+        },
+    }, safe(async (args) => {
+        const { account, name, exact, ...filter } = args;
+        const items = await listAll(client, opts.path, filter, account);
+        const needle = String(name).toLowerCase();
+        const matches = items.filter((it) => {
+            const itemName = String(it?.name ?? "").toLowerCase();
+            return exact ? itemName === needle : itemName.includes(needle);
+        });
+        return jsonResult({ count: matches.length, matches });
+    }));
+}
+function registerGet(server, client, opts) {
+    server.registerTool(`get_${opts.resource}`, {
+        title: `Get ${opts.resource.replace(/_/g, " ")}`,
+        description: `Retrieve a single ${opts.resource.replace(/_/g, " ")} by ID.`,
+        inputSchema: {
+            ...accountShape,
+            [opts.idParam]: z.string().describe(`ID of the ${opts.resource.replace(/_/g, " ")}.`),
+        },
+    }, safe(async (args) => jsonResult(await client.request("GET", `${opts.path}/${encodeURIComponent(args[opts.idParam])}`, {
+        account: args.account,
+    }))));
+}
+function registerLifecycle(server, client, opts) {
+    const label = opts.resource.replace(/_/g, " ");
+    const actions = [
+        { action: "activate", verb: "Activate (resume delivery for)" },
+        { action: "pause", verb: "Pause delivery for" },
+        {
+            action: "archive",
+            verb: "Archive",
+            warn: " WARNING: archiving is permanent and cannot be undone.",
+        },
+    ];
+    for (const { action, verb, warn } of actions) {
+        server.registerTool(`${action}_${opts.resource}`, {
+            title: `${action[0].toUpperCase()}${action.slice(1)} ${label}`,
+            description: `${verb} a ${label}.${warn ?? ""}`,
+            inputSchema: {
+                ...accountShape,
+                [opts.idParam]: z.string().describe(`ID of the ${label}.`),
+            },
+        }, safe(async (args) => jsonResult(await client.request("POST", `${opts.path}/${encodeURIComponent(args[opts.idParam])}/${action}`, { account: args.account }))));
+    }
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "chatgpt-ads-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for the OpenAI ChatGPT Ads (Advertiser) API — manage campaigns, ad groups, ads, creatives, and reporting from any MCP client.",
+  "type": "module",
+  "bin": {
+    "chatgpt-ads-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsc --watch",
+    "docs:tools": "node scripts/gen-tool-reference.mjs",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "openai",
+    "chatgpt",
+    "ads",
+    "advertising"
+  ],
+  "author": "codynguyen18",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/codynguyen18/chatgpt-ads-mcp.git"
+  },
+  "homepage": "https://github.com/codynguyen18/chatgpt-ads-mcp#readme",
+  "bugs": {
+    "url": "https://github.com/codynguyen18/chatgpt-ads-mcp/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "typescript": "^5.5.4"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}