# Getting Started with Panxo

#### Integrations

Panxo provides multiple integration options for web supply partners:

* [<mark style="color:$primary;">**Prebid.js Adapter**</mark><mark style="color:$primary;">:</mark>](/integrations/prebid.js)  Our Prebid Adapter provides a simple integration for IA Display supply
* [<mark style="color:$primary;">**Prebid Server:**</mark> ](/integrations/prebid-server) Our Prebid Server Adapter provides a simple integration for IA Display supply
* [**OpenRTB 2.5**](/integrations/openrtb-2.5): We also support generic OpenRTB 2.5, for supply partners using other S2S Solutions
* [Sticky Native](/integrations/native): Sticky Native is a direct integration method to shows premium native ad formats only to AI users

#### Dashboard & Reporting

Our dashboard & reporting API allow for simple and transparent reporting. Learn more:

* [Dashboard](/dashboard-and-reporting/dashboard)
* [Reporting API](/dashboard-and-reporting/reporting-api)<br>


# For Publishers

Your site already has AI-influenced visitors. They arrive with higher intent, consume content faster, and convert at premium rates. The problem is your current ad stack cannot see them.

Panxo makes them visible, segments them by conversational intent, and connects them to premium demand.

***

## The Opportunity

Every day, millions of users research products, compare services, and explore topics through AI assistants like ChatGPT, Perplexity, Claude, and Gemini. Then they visit publisher sites to take action.

These visitors are different:

* **They arrive with intent** -- the AI conversation pre-qualified their interest
* **They behave differently** -- shorter sessions, focused consumption, faster decisions
* **They are invisible** -- traditional analytics and ad stacks classify them as generic traffic

{% hint style="info" %}
Panxo does not just detect direct AI referrals. Our AI Extended Reach technology identifies users who interacted with AI assistants **before** arriving at your site -- even through organic search, social, or direct navigation. Your real AI audience is significantly larger than referrer data suggests.
{% endhint %}

***

## How Panxo Works

### AI Extended Reach

Traditional detection relies on referrer headers. That only captures a fraction of AI-influenced visits.

Panxo's detection layer identifies users who used AI assistants **before** arriving -- regardless of how they navigate to your site. This expands your monetizable AI audience far beyond direct referral traffic.

### Sequoia ID by Panxo

Every AI-influenced visitor receives a **Sequoia ID** -- a privacy-compliant identifier that maps:

| Signal               | Description                                                         |
| -------------------- | ------------------------------------------------------------------- |
| **Identity**         | Persistent, first-party ID across sessions and pageviews            |
| **Research context** | Topics, comparisons, and purchase signals from the AI conversation  |
| **Intent score**     | Commercial intent rating based on conversational depth and behavior |

Sequoia ID powers the audience graph that advertisers bid against. Higher intent scores command higher CPMs.

### Real-Time Data Enrichment

For publishers running Prebid.js, our RTD module (`panxoRtdProvider`) enriches every bid request in real time:

* AI audience segments injected into `ortb2.user.data`
* Intent signals added to `ortb2.site.ext`
* No external scripts needed -- runs inside your Prebid build

Advertisers see enriched requests with Sequoia ID data and bid accordingly.

### Premium Demand Activation

Enriched impressions flow into curated private marketplace deals. Panxo connects AI-qualified inventory to advertisers who specifically target high-intent, AI-influenced audiences.

The result: CPMs that reflect the true value of the visitor's intent, not just the page context.

***

## Integration Methods

{% tabs %}
{% tab title="Prebid.js (Recommended)" %}
For publishers running header bidding. Two modules, zero external scripts.

| Module             | Function                                                        |
| ------------------ | --------------------------------------------------------------- |
| `panxoRtdProvider` | Detects AI visitors, enriches bid requests with Sequoia ID data |
| `panxoBidAdapter`  | Receives premium bids from Panxo demand                         |

**Build:**

```bash
gulp build --modules=panxoBidAdapter,rtdModule,panxoRtdProvider
```

**Configure:**

```javascript
pbjs.setConfig({
  realTimeData: {
    dataProviders: [{
      name: 'panxo',
      params: { siteId: 'YOUR_SITE_ID' }
    }]
  }
});

// Required for Prebid v10+
pbjs.bidderSettings = {
  panxo: { storageAllowed: true }
};
```

**Add to your ad units:**

```javascript
bids: [{
  bidder: 'panxo',
  params: {
    propertyKey: 'your-property-key'
  }
}]
```

{% hint style="success" %}
No external scripts needed. Both modules run entirely inside your Prebid.js build.
{% endhint %}

Full technical reference: [Prebid.js Integration Guide](broken://pages/217e3cbe05ac35ac5af96f74734d1cd35598e9a9)
{% endtab %}

{% tab title="Sticky Native (Quick Start)" %}
For publishers who want zero-configuration monetization. One script tag -- Panxo handles detection, ad serving, and optimization automatically.

```html
<script async src="https://cdn.panxo.ai/o/YOUR_HASH"></script>
```

Available via:

* Direct script integration
* Google Tag Manager
* WordPress plugin ([wordpress.org/plugins/panxo-ai-monetization](https://wordpress.org/plugins/panxo-ai-monetization/))

{% hint style="info" %}
Get your script URL from [Dashboard > Settings > Integration](https://app.panxo.ai/).
{% endhint %}
{% endtab %}
{% endtabs %}

### Comparison

|                  | Prebid.js                             | Sticky Native                      |
| ---------------- | ------------------------------------- | ---------------------------------- |
| Setup complexity | Medium (Prebid build)                 | Low (one tag)                      |
| External scripts | None                                  | One script                         |
| Format control   | Your ad units, your layout            | Panxo-managed formats              |
| CPM potential    | Highest (header bidding competition)  | High (direct + PMP)                |
| Best for         | Publishers with existing Prebid setup | Quick deployment, non-Prebid sites |

***

## What Makes AI Traffic Different

Understanding why AI-influenced visitors require a different monetization approach:

|                         | Traditional Visitors        | AI-Influenced Visitors                |
| ----------------------- | --------------------------- | ------------------------------------- |
| **Intent**              | Browsing, discovery         | Pre-researched, high-intent           |
| **Session length**      | Longer, multi-page          | Shorter, focused                      |
| **Behavior**            | Scroll, explore             | Targeted consumption                  |
| **Monetization window** | Multiple impressions        | First impression matters              |
| **Retargeting**         | Cookie-based, multi-session | Single session, no cookies needed     |
| **Ad relevance**        | Page context only           | Conversational context + page context |

{% hint style="warning" %}
AI sessions are shorter and intent decays fast. Traditional lazy-loading and multi-impression strategies underperform. Panxo's formats and bidding are designed for this reality.
{% endhint %}

***

## Performance

| Metric            | Value                            |
| ----------------- | -------------------------------- |
| Average RPM       | $30+                             |
| Average fill rate | 86%                              |
| Setup time        | Under 5 minutes                  |
| CLS impact        | Zero (all formats CLS-compliant) |
| LCP impact        | None (async loading)             |

Performance varies by geography, content vertical, and AI traffic share.

***

## Privacy and Compliance

Panxo is designed for a cookieless, privacy-first environment.

| Standard          | Support                                       |
| ----------------- | --------------------------------------------- |
| IAB TCF 2.0       | Registered -- Global Vendor List ID: **1527** |
| GDPR              | Consent string passed in all bid requests     |
| CCPA / US Privacy | USP string supported                          |
| GPP               | Global Privacy Platform supported             |
| COPPA             | Child-directed content flags respected        |

Additional guarantees:

* **No third-party cookies** -- Sequoia ID uses first-party signals only
* **No device fingerprinting** -- detection is behavioral and contextual
* **Opt-out support** -- users can opt out at any time

***

## Ads.txt

Required for programmatic verification. Your unique lines are generated automatically in your dashboard.

```
#PanxoAI
panxo.ai, YOUR_PANXO_ID, DIRECT
bidgx.com, YOUR_BIDGX_ID, DIRECT
kntxy.com, YOUR_KNXTY_ID, DIRECT
rubiconproject.com, 27034, RESELLER, 0bfd66d529a55807
themediagrid.com, FNG4LA, RESELLER, 35d5010d7789b49d
pubmatic.com, 166733, RESELLER, 5d62403b186f2ace
smartadserver.com, 5397, RESELLER, 060d053dcf45cbf3
xandr.com, 17781, RESELLER
```

{% hint style="info" %}
Additional reseller lines may be included depending on your demand configuration. Copy the full block from **Dashboard > Settings > Ads.txt**.
{% endhint %}

***

## Requirements

* Website with original, meaningful content
* Ads.txt implementation
* Compliance with Panxo content policies

***

## Get Started

{% stepper %}
{% step %}

### Apply

Apply at [panxo.com/publishers](https://panxo.ai/publishers) or contact [publishers@panxo.](mailto:publishers@panxo.ai)com
{% endstep %}

{% step %}

### Receive credentials

Receive your `siteId` and integration credentials
{% endstep %}

{% step %}

### Choose integration

Choose your integration method (Prebid or Sticky Native)
{% endstep %}

{% step %}

### Go live

Go live and start monetizing AI-influenced visitors
{% endstep %}
{% endstepper %}

***

## Resources

| Resource                    | Link                                                                               |
| --------------------------- | ---------------------------------------------------------------------------------- |
| Publisher Dashboard         | [app.panxo.com](https://app.panxo.com)                                             |
| Prebid.js Integration Guide | [Technical documentation](broken://pages/217e3cbe05ac35ac5af96f74734d1cd35598e9a9) |
| Platform Status             | [status.panxo.com](https://status.panxo.com)                                       |
| Publisher Partnerships      | <publishers@panxo.com>                                                             |
| Technical Support           | <tech@panxo.com>                                                                   |


# For Advertisers


# For Agencies


# Prebid.js

Panxo enables publishers to monetize AI-influenced audiences through Prebid.js header bidding. Two modules work together inside your existing Prebid build.

{% hint style="info" %}
<https://docs.prebid.org/dev-docs/bidders/panxo.html> ( Min supported version: 10.25.00 )

<https://docs.prebid.org/dev-docs/modules/panxoRtdProvider.html> ( Min supported version: 10.25.00 )
{% endhint %}

***

## Architecture

```
┌─────────────────────────────────────────────────────┐
│                    Prebid.js                         │
│                                                     │
│  ┌─────────────────────┐  ┌──────────────────────┐  │
│  │  panxoRtdProvider    │  │  panxoBidAdapter      │  │
│  │                     │  │                      │  │
│  │  - Detect AI visit  │──│  - Send enriched     │  │
│  │  - Score intent     │  │    bid request       │  │
│  │  - Enrich ortb2     │  │  - Return premium    │  │
│  │                     │  │    bid               │  │
│  └─────────────────────┘  └──────────────────────┘  │
└─────────────────────────────────────────────────────┘
```

| Module             | Purpose                                                                                      |
| ------------------ | -------------------------------------------------------------------------------------------- |
| `panxoRtdProvider` | Detects AI-influenced visitors. Enriches bid requests with audience signals and intent data. |
| `panxoBidAdapter`  | Sends enriched requests to Panxo demand. Returns premium bids for qualified impressions.     |

***

## Prerequisites

| Requirement   | Details                                                |
| ------------- | ------------------------------------------------------ |
| Panxo account | Register at [app.panxo.com](https://app.panxo.com)     |
| `siteId`      | Found in Dashboard > Integrations - Prebid.js          |
| `propertyKey` | Found in Dashboard > Integrations - Prebid.js          |
| `ads.txt`     | Required lines shown in Dashboard > Settings > Ads.txt |

***

## Installation

### Option A: Build from source

```bash
gulp build --modules=panxoBidAdapter,rtdModule,panxoRtdProvider
```

Include alongside your other modules:

```bash
gulp build --modules=panxoBidAdapter,rtdModule,panxoRtdProvider,appnexusBidAdapter,rubiconBidAdapter,...
```

### Option B: Pre-built bundle

```html
<script async src="https://assets.panxostack.com/prebid/prebid-panxo.js"></script>
```

{% hint style="info" %}
The pre-built bundle includes both the RTD module and bid adapter.
{% endhint %}

***

## Configuration

### RTD Module

```javascript
pbjs.setConfig({
  realTimeData: {
    dataProviders: [{
      name: 'panxo',
      params: {
        siteId: 'YOUR_SITE_ID'
      }
    }]
  }
});
```

{% stepper %}
{% step %}

### Detection

Detects whether the current visitor has been influenced by AI assistants
{% endstep %}

{% step %}

### Intent scoring

Scores conversational intent based on session signals
{% endstep %}

{% step %}

### ortb2.user.data enrichment

Enriches `ortb2.user.data` with AI audience segments
{% endstep %}

{% step %}

### ortb2.site.ext enrichment

Enriches `ortb2.site.ext` with traffic classification signals
{% endstep %}
{% endstepper %}

No manual data passing is required. The module handles all enrichment internally.

### Bid Adapter

```javascript
var adUnits = [{
  code: 'ad-slot-1',
  mediaTypes: {
    banner: {
      sizes: [[300, 250], [728, 90], [320, 50]]
    }
  },
  bids: [{
    bidder: 'panxo',
    params: {
      propertyKey: 'your-property-key'
    }
  }]
}];
```

### Storage Access (Prebid v10+)

Required for Prebid.js version 10 and above:

```javascript
pbjs.bidderSettings = {
  panxo: {
    storageAllowed: true
  }
};
```

***

## Bid Parameters

| Parameter     | Type     | Required | Default | Description                                                        |
| ------------- | -------- | -------- | ------- | ------------------------------------------------------------------ |
| `propertyKey` | `string` | Yes      | --      | Property key from Panxo dashboard                                  |
| `floor`       | `number` | No       | `0`     | Minimum CPM floor in USD. Overrides Prebid floor module if higher. |

***

## Full Implementation Example

```html
<!DOCTYPE html>
<html>
<head>
  <!-- Prebid.js with Panxo modules -->
  <script async src="prebid.js"></script>

  <script>
    var pbjs = pbjs || {};
    pbjs.que = pbjs.que || [];

    pbjs.que.push(function() {

      // --- Panxo RTD Module ---
      pbjs.setConfig({
        realTimeData: {
          dataProviders: [{
            name: 'panxo',
            params: { siteId: 'YOUR_SITE_ID' }
          }]
        }
      });

      // --- Storage access (Prebid v10+) ---
      pbjs.bidderSettings = {
        panxo: { storageAllowed: true }
      };

      // --- Ad units ---
      pbjs.addAdUnits([{
        code: 'banner-ad',
        mediaTypes: {
          banner: { sizes: [[300, 250], [728, 90]] }
        },
        bids: [
          {
            bidder: 'panxo',
            params: { propertyKey: 'your-property-key' }
          }
          // Add your other bidders here
        ]
      }]);

      // --- Request bids ---
      pbjs.requestBids({
        timeout: 2000,
        bidsBackHandler: function() {
          // Your existing ad rendering logic
        }
      });
    });
  </script>
</head>
<body>
  <div id="banner-ad"></div>
</body>
</html>
```

***

## Alternative: Standalone Signal Script

For publishers **not using Prebid.js**, or who prefer external detection before Prebid loads:

```html
<script async src="https://cdn.panxo-sys.com/o/YOUR_ENDPOINT_KEY"></script>
```

The Signal script sets `panxo_uid` in `localStorage`. The bid adapter reads it automatically. This method does **not** require the RTD module.

|                   | RTD Module             | Signal Script           |
| ----------------- | ---------------------- | ----------------------- |
| External script   | No                     | Yes                     |
| Detection method  | Inside Prebid pipeline | Before Prebid loads     |
| Intent enrichment | Automatic via `ortb2`  | Via `localStorage`      |
| Best for          | Prebid publishers      | GTM / non-Prebid setups |

***

## Privacy & Consent

### IAB TCF Registration

**Global Vendor List ID: 1527**

Panxo is registered with IAB Europe Transparency and Consent Framework. If you use a CMP, ensure Vendor ID `1527` is included in your vendor list.

### Supported Frameworks

| Framework         | Support                                                          |
| ----------------- | ---------------------------------------------------------------- |
| GDPR / TCF 2.0    | Consent string passed via `user.ext.consent` and `regs.ext.gdpr` |
| CCPA / US Privacy | USP string passed via `regs.ext.us_privacy`                      |
| GPP               | Supported via `regs.ext.gpp` and `regs.ext.gpp_sid`              |
| COPPA             | Child-directed content flags respected via `regs.coppa`          |

### Consent Management Configuration

```javascript
pbjs.setConfig({
  consentManagement: {
    gdpr: {
      cmpApi: 'iab',
      timeout: 8000,
      defaultGdprScope: true
    },
    usp: {
      cmpApi: 'iab',
      timeout: 1000
    }
  }
});
```

***

## User Sync

Pixel-based user sync. Enable in your Prebid configuration:

```javascript
pbjs.setConfig({
  userSync: {
    filterSettings: {
      pixel: {
        bidders: ['panxo'],
        filter: 'include'
      }
    }
  }
});
```

***

## First Party Data

The adapter reads FPD from the standard `ortb2` config:

```javascript
pbjs.setConfig({
  ortb2: {
    site: {
      name: 'Example Site',
      cat: ['IAB1'],
      content: { keywords: 'technology, ai' }
    },
    user: {
      data: [{
        name: 'example-data-provider',
        segment: [{ id: 'segment-1' }]
      }]
    }
  }
});
```

RTD-enriched data merges with any existing FPD configuration.

***

## Supply Chain (schain)

Supply chain information is passed automatically when configured:

```javascript
pbjs.setConfig({
  schain: {
    validation: 'relaxed',
    config: {
      ver: '1.0',
      complete: 1,
      nodes: [{
        asi: 'publisher-domain.com',
        sid: '12345',
        hp: 1
      }]
    }
  }
});
```

***

## Floor Prices

Compatible with the Prebid Price Floors Module:

```javascript
pbjs.setConfig({
  floors: {
    enforcement: { floorDeals: true },
    data: {
      default: 0.50,
      schema: { fields: ['mediaType'] },
      values: { 'banner': 0.50 }
    }
  }
});
```

The `floor` bid parameter takes precedence if higher than the floor module value.

***

## Supported Media Types

| Type   | Status      |
| ------ | ----------- |
| Banner | Supported   |
| Video  | Coming soon |
| Native | Coming soon |

***

## Response Specification

| Field              | Value                                 |
| ------------------ | ------------------------------------- |
| Revenue type       | Net                                   |
| TTL                | 300 seconds                           |
| Currency           | USD                                   |
| Safeframes         | Supported                             |
| Deal support       | Yes                                   |
| Advertiser domains | Available in `meta.advertiserDomains` |

***

## Troubleshooting

### No bids received

{% stepper %}
{% step %}

### Check Prebid build

Ensure both `panxoRtdProvider` and `panxoBidAdapter` are included
{% endstep %}

{% step %}

### Verify credentials

Confirm `siteId` and `propertyKey` match your dashboard
{% endstep %}

{% step %}

### Check ads.txt

Must include all required Panxo lines
{% endstep %}

{% step %}

### Expected behavior

Panxo only bids on AI-influenced impressions, not every request
{% endstep %}
{% endstepper %}

### RTD module not loading

```bash
# Verify the module is in your build
gulp build --modules=panxoBidAdapter,rtdModule,panxoRtdProvider
```

Both `rtdModule` (Prebid core) and `panxoRtdProvider` must be included.

### Low fill rate

This is expected. Panxo targets AI-influenced visitors specifically. Fill rate depends on your AI traffic share, typically 5-25% of total visits. This segment is growing \~200% year over year.

***

## Support

| Resource               | URL                                     |
| ---------------------- | --------------------------------------- |
| Dashboard              | [app.panxo.ai](https://app.panxo.ai/)   |
| Documentation          | [docs.panxo.ai](https://docs.panxo.ai/) |
| Technical support      | <tech@panxo.ai>                         |
| Publisher partnerships | <publishers@panxo.ai>                   |

***

Panxo Prebid.js Integration v2.0 -- Last updated: February 2026


# Prebid Server

Panxo supports server-side bidding through Prebid Server (PBS). This allows publishers running PBS instances to include Panxo in their server-side auctions alongside client-side Prebid.js.

## Requirements

* **Prebid Server** with the Panxo adapter enabled
* **Panxo RTD Module** configured in Prebid.js on the client side
* A valid `propertyKey` from your Panxo dashboard

{% hint style="warning" %}
The Panxo RTD module (`panxoRtdProvider`) must be running on the client side even when using Prebid Server. The RTD module detects AI-referred traffic and injects classification signals that the server-side adapter requires to participate in the auction. Without it, Panxo will not bid.
{% endhint %}

## Prebid Server Configuration

Add the Panxo adapter to your Prebid Server configuration:

```yaml
adapters:
  panxo:
    endpoint: "https://panxo-sys.com/openrtb/2.5/bid"
```

## Prebid.js Setup

{% stepper %}
{% step %}

### Build Prebid.js with required modules

Include `panxoRtdProvider` and `prebidServerBidAdapter` in your Prebid.js build:

```bash
gulp build --modules=rtdModule,panxoRtdProvider,prebidServerBidAdapter,...
```

{% endstep %}

{% step %}

### Configure RTD module and S2S

```javascript
pbjs.setConfig({
    realTimeData: {
        auctionDelay: 300,
        dataProviders: [{
            name: 'panxo',
            waitForIt: true,
            params: {
                siteId: 'your-site-id'
            }
        }]
    },
    s2sConfig: {
        accountId: 'your-pbs-account',
        bidders: ['panxo'],
        defaultVendor: 'your-pbs-vendor',
        timeout: 500
    }
});

var adUnits = [{
    code: 'banner-ad',
    mediaTypes: {
        banner: {
            sizes: [[300, 250], [728, 90]]
        }
    },
    bids: [{
        bidder: 'panxo',
        params: {
            propertyKey: 'your-property-key'
        }
    }]
}];
```

{% endstep %}
{% endstepper %}

## Bid Parameters

| Name          | Scope    | Description                              | Example          | Type     |
| ------------- | -------- | ---------------------------------------- | ---------------- | -------- |
| `propertyKey` | required | Property identifier from Panxo dashboard | `'abc123def456'` | `string` |

## User Sync

Panxo supports redirect-based user sync through Prebid Server. Ensure user syncing is enabled in your PBS configuration for the Panxo adapter.

For client-side Prebid.js, configure pixel sync:

```javascript
pbjs.setConfig({
    userSync: {
        filterSettings: {
            pixel: {
                bidders: ['panxo'],
                filter: 'include'
            }
        }
    }
});
```

## Supported Features

| Feature               | Support           |
| --------------------- | ----------------- |
| Media Types           | Banner            |
| Platforms             | Site (no app)     |
| GDPR / TCF 2.2        | Yes (GVL ID 1527) |
| USP / CCPA            | Yes               |
| GPP                   | Yes               |
| COPPA                 | Yes               |
| Supply Chain (schain) | Yes               |
| Price Floors          | Yes               |
| First Party Data      | Yes               |
| Safeframes            | Yes               |
| Deals                 | Yes               |

## Bid Response

* **Currency**: USD
* **Net Revenue**: Yes
* **TTL**: 300 seconds (5 minutes)
* **Advertiser Domains**: Available in `meta.advertiserDomains`

## How to Get Started

1. Register at [app.panxo.ai](https://app.panxo.ai/) to obtain your `siteId` and `propertyKey`
2. Configure the RTD module in Prebid.js with your `siteId`
3. Add `panxo` to your Prebid Server adapter list
4. Add `panxo` bids to your ad units with your `propertyKey`
5. Verify traffic in your Panxo dashboard


# Google Tag Manager + Ad Manager

This guide is for publishers who serve ads through Google Ad Manager and do not run their own Prebid wrapper. If you already run Prebid.js on the page, do not use this integration; write to <tech@panxo.ai> and we will set up the standard Panxo Prebid integration (bid adapter plus RTD Module) inside your existing wrapper.

**What Panxo is.** Panxo brings new advertising demand for AI-influenced audiences: visitors who arrive at your site from assistants such as ChatGPT, Perplexity, Claude or Gemini, or who show signals of having been influenced by them. That demand is delivered through the standard Prebid stack: a bid adapter and the Panxo RTD Module, the same technology used by our publishers who run their own Prebid.

**What changes on your site.** Two things, and nothing else:

1. A Custom HTML tag in Google Tag Manager (once per container). That tag activates the Panxo RTD Module on the page.
2. A set of Price Priority line items in Google Ad Manager, created by your ad ops team following this guide (or set up by us, see Annex B).

{% hint style="success" %}
**No-risk guarantees.** Your current ads, your existing Ad Manager configuration and your page load times stay exactly the same. Panxo competes inside Ad Manager as one more demand source: it only wins a slot when its price beats the rest. Panxo never calls refresh: we do not trigger, advance or repeat any ad call; we only leave key-values ready for the ad calls your page already makes. If Panxo does not bid or does not respond, absolutely nothing happens; the page behaves as it does today.
{% endhint %}

### Prerequisites

Before starting, make sure you have:

1. **A Panxo account.** Your publisher account, with your domain added as a property. If you do not have an account yet, write to <publishers@panxo.ai>.
2. **Per-domain activation by Panxo.** Each domain has two distinct identifiers in the Panxo dashboard: the RTD Module siteId and the bid adapter propertyKey. They are different values; the RTD siteId is not the propertyKey. You do not paste either of them into Google Tag Manager (Panxo configures both server-side when the domain is activated), but confirm that both appear in your dashboard, under Integrations, before requesting activation. To activate a domain, write to <publishers@panxo.ai>.
3. **Your ads.txt lines.** The dashboard shows the exact ads.txt lines for each domain (the three DIRECT IDs are unique per domain). They go live in Step 5.

{% hint style="warning" %}
**Network currency.** The rates and buckets in this guide are defined in USD. Line item rates and price buckets are always defined in the currency of your Ad Manager network. If your network operates in USD, everything in this guide applies as-is. If your network operates in any other currency, contact Panxo (<tech@panxo.ai>) before creating any line items: we adapt the buckets and send you the equivalent table in your currency. Do not create line items with the USD values on a network that does not operate in USD.
{% endhint %}

#### Consent (GDPR territories)

The Panxo RTD Module applies geo-scoped consent gating: consent requirements are enforced according to the visitor's territory.

* **Domains with traffic from GDPR territories.** Panxo enables Prebid's consentManagement module (TCF 2.x) server-side for that domain; the Google Tag Manager tag does not change. Panxo is registered with the IAB TCF under **GVL ID 1527**: add vendor 1527 to your CMP's vendor list so that consent for Panxo is collected and passed correctly. Without vendor 1527 in the CMP, TCF consent for Panxo is never granted and Panxo does not bid in those territories.
* **Domains outside GDPR territories** (for example LatAm or the United States) need no CMP for this integration. US privacy is handled separately through GPP/USP passthrough; it requires no configuration on your side.

### How it works

The six steps, in ad ops language:

1. **Activation.** The Google Tag Manager tag activates the Panxo RTD Module on the page. Loading is asynchronous and does not interfere with the loading of your ads.
2. **Detection.** The RTD Module detects whether the visit is AI-influenced. Panxo only participates on those visits.
3. **Parallel auction.** Panxo requests prices from its own demand while the page keeps working normally. No existing ad call is blocked, delayed or conditioned.
4. **Key-values.** The auction result is translated into key-values (`hb_pb`, `hb_adid`, `hb_bidder`, `hb_size`) that are applied to the Google Ad Manager slots. The next ad call your page fires (the first load if the auction arrived in time, a lazy-load or a refresh cycle) carries them automatically.
5. **Competition in Ad Manager.** The Panxo line item matching the bid price competes in Price Priority against the rest of your demand. It wins only if Panxo's price is higher.
6. **Render.** If the Panxo line item wins, the universal creative renders the Panxo ad in that slot. If it does not win, or Panxo did not bid, exactly what would have been served without Panxo is served.

### Step 1: the tag in Google Tag Manager

Create a **Custom HTML** tag with this content, exactly as it appears here:

```html
<script>
  (function () {
    var s = document.createElement('script');
    s.async = true;
    s.src = 'https://assets.panxostack.com/prebid/gtm-loader.js';
    document.head.appendChild(s);
  })();
</script>
```

Tag configuration:

* **Type:** Custom HTML.
* **Trigger:** All Pages.
* **Priorities or sequencing:** none. There is no need to configure firing priority or ordering relative to other tags.

The tag is **identical for every domain and every container**. Nothing is customized per domain: the tag carries no identifiers, and Panxo resolves your domain's configuration server-side.

**Domain activation is controlled server-side by Panxo.** Pasting the tag in the container of a domain that has not been activated yet is safe and inert: the RTD Module does nothing on that domain until Panxo activates it, and in that state it generates no calls or activity of any kind on the page. To activate a domain, write to <publishers@panxo.ai>.

### Step 2: key-values in Ad Manager

In Google Ad Manager, go to **Inventory > Key-values** and create these four keys, all of type **dynamic**:

```
hb_pb
hb_adid
hb_bidder
hb_size
```

| Key-value   | Type    | Purpose                                                          |
| ----------- | ------- | ---------------------------------------------------------------- |
| `hb_pb`     | Dynamic | Bid price (bucket). This is the targeting key for the line items |
| `hb_adid`   | Dynamic | Identifier of the winning ad; the creative uses it to render     |
| `hb_bidder` | Dynamic | Identifies Panxo demand (`panxo`) in targeting                   |
| `hb_size`   | Dynamic | Size of the winning ad; the creative uses it                     |

{% hint style="warning" %}
**Do not create `hb_format` or `hb_env`.** The creative in Step 4 also references `hb_format` and `hb_env`. Those two **must not be created** as key-values: they are standard creative macros that resolve empty for display without affecting the render.
{% endhint %}

### Step 3: order and line items

The rates below are in USD. If your network does not operate in USD, stop here and contact Panxo first (see the network currency note in Prerequisites).

If you operate several domains on the same Ad Manager network, a single set of line items serves all of them. If a domain uses a different network, the same set is replicated on that network.

#### Structure

Create an advertiser of type **Ad network**, named:

```
Panxo
```

Under it, create an order named:

```
Panxo Header Bidding
```

* **Line items:** type **Price Priority**, **no end date**, **unlimited** delivery. One per price bucket; each line item's rate is the bucket value.
* **Targeting per line item:** `hb_pb` = the bucket value **AND** `hb_bidder` = `panxo` (both conditions at once). Including `hb_bidder=panxo` guarantees these line items only capture Panxo demand.
* **Inventory:** run of network (the whole network).

#### The per-line-item pattern (explained once)

All 25 line items follow the same pattern; only the bucket value changes from row to row. Replace `X.XX` with the bucket value from the table below.

Line item name:

```
Panxo HB X.XX
```

Rate (CPM):

```
X.XX
```

Targeting (both conditions at once):

```
hb_pb = X.XX AND hb_bidder = panxo
```

The `hb_bidder` targeting value is always:

```
panxo
```

#### Recommended creation flow

Create the first line item in full (for example the 0.50 one), verify targeting, rate, type and delivery, and from there **duplicate and adjust**: in each copy only the name, the rate and the `hb_pb` value change. Annex B describes how to automate the creation of the 25 line items.

#### Full bucket table (25 line items)

All with type Price Priority, no end date, unlimited delivery, run of network inventory and targeting `hb_pb` = table value **AND** `hb_bidder` = `panxo`.

| Line item (suggested name) | `hb_pb` targeting | Rate (CPM) |
| -------------------------- | ----------------- | ---------- |
| Panxo HB 0.50              | 0.50              | 0.50       |
| Panxo HB 1.00              | 1.00              | 1.00       |
| Panxo HB 1.50              | 1.50              | 1.50       |
| Panxo HB 2.00              | 2.00              | 2.00       |
| Panxo HB 2.50              | 2.50              | 2.50       |
| Panxo HB 3.00              | 3.00              | 3.00       |
| Panxo HB 3.50              | 3.50              | 3.50       |
| Panxo HB 4.00              | 4.00              | 4.00       |
| Panxo HB 4.50              | 4.50              | 4.50       |
| Panxo HB 5.00              | 5.00              | 5.00       |
| Panxo HB 5.50              | 5.50              | 5.50       |
| Panxo HB 6.00              | 6.00              | 6.00       |
| Panxo HB 6.50              | 6.50              | 6.50       |
| Panxo HB 7.00              | 7.00              | 7.00       |
| Panxo HB 7.50              | 7.50              | 7.50       |
| Panxo HB 8.00              | 8.00              | 8.00       |
| Panxo HB 8.50              | 8.50              | 8.50       |
| Panxo HB 9.00              | 9.00              | 9.00       |
| Panxo HB 9.50              | 9.50              | 9.50       |
| Panxo HB 10.00             | 10.00             | 10.00      |
| Panxo HB 11.00             | 11.00             | 11.00      |
| Panxo HB 12.00             | 12.00             | 12.00      |
| Panxo HB 13.00             | 13.00             | 13.00      |
| Panxo HB 14.00             | 14.00             | 14.00      |
| Panxo HB 15.00             | 15.00             | 15.00      |

In total: 20 line items from 0.50 to 10.00 in 0.50 steps, plus 5 line items from 11.00 to 15.00 in 1.00 steps.

**Note on bucket boundaries:** bids between 10.00 and 10.99 fall into the 10.00 bucket (which is why there are no intermediate buckets in that range), and a bid of 15.00 or more emits 15.00. Below 0.50 there is no row: the bid is safely lost (it emits hb\_pb=0.00, a value no line item targets, and your current demand serves as usual). In practice this does not happen, because Panxo's effective floor is $3.

#### Note for the finance team

The line item rate **only decides competition inside Ad Manager**: it is the price with which the Panxo bid competes against the rest of your demand. The actual payment is calculated from Panxo reporting and settled on NET-45 terms, as with any Prebid partner. The revenue Ad Manager reports for these line items **is not the invoice amount**; the billing figure always comes from Panxo reporting.

### Step 4: the creative

Create **one creative of type Third party (Custom creative)** with this code, exactly as it appears here:

```html
<script src="https://cdn.jsdelivr.net/npm/prebid-universal-creative@1.17.2/dist/creative.js"></script>
<!-- Version pinned on purpose: this runs inside the partner's live GAM creatives; @latest could break renders without warning. Bump deliberately. -->
<script>
  var ucTagData = {};
  ucTagData.adServerDomain = "";
  ucTagData.pubUrl = "%%PATTERN:url%%";
  ucTagData.adId = "%%PATTERN:hb_adid%%";
  ucTagData.mediaType = "%%PATTERN:hb_format%%";
  ucTagData.env = "%%PATTERN:hb_env%%";
  ucTagData.size = "%%PATTERN:hb_size%%";
  ucTagData.hbPb = "%%PATTERN:hb_pb%%";
  try { ucTag.renderAd(document, ucTagData); } catch (e) {}
</script>
```

This is Prebid's standard universal creative. The version is pinned on purpose (the comment in the code explains it): this code runs inside your production creatives, and a floating version could break renders without warning.

Configuration:

* **Declared size:** 1x1, with **size overrides** for the eight sizes below.
* **Association:** the creative is associated with **all** the line items from Step 3, with **5 instances per line item** (5 copies of the same creative associated with each line item).

Size overrides:

```
300x250, 728x90, 320x50, 320x100, 300x600, 160x600, 970x250, 970x90
```

**Why 5 instances:** pages often request several slots in a single Ad Manager call (single request). In that mode, the same price bucket can win several slots in the same call (for example, several 300x250s on a homepage). Each simultaneous win needs its own creative instance; with only one, the additional slots would silently fall through to lower-priority demand.

### Step 5: ads.txt

Add these lines to the `ads.txt` file of **each domain**:

```
#PanxoAI
panxo.ai, YOUR_PANXO_ID, DIRECT
bidgx.com, YOUR_BIDGX_ID, DIRECT
kntxy.com, YOUR_KNXTY_ID, DIRECT
rubiconproject.com, 27034, RESELLER, 0bfd66d529a55807
themediagrid.com, FNG4LA, RESELLER, 35d5010d7789b49d
pubmatic.com, 166733, RESELLER, 5d62403b186f2ace
smartadserver.com, 5397, RESELLER, 060d053dcf45cbf3
xandr.com, 17781, RESELLER
```

* The IDs on the first three lines (DIRECT) are **unique per domain**; replace the placeholders with the values shown in your Panxo dashboard, under Integrations, for that domain. The RESELLER lines are fixed and go in as-is on every domain.
* **Verification is automatic:** our system checks ads.txt files daily. As soon as it detects the lines on a domain, monetization for that domain activates on its own. There is nothing to notify us about and nothing else to do.

### Step 6: go-live verification (checklist)

With the tag published, the line items and the creative created and the ads.txt in place, verify in this order:

1. **GTM Preview.** In the container's Preview mode, confirm that the Custom HTML tag fires on All Pages without errors.
2. **Console with `?pbjs_debug=true`.** Open any page of the activated domain adding `?pbjs_debug=true` to the URL and check the browser console. What to look for: messages with the `[panxo-gtm]` prefix (RTD Module activity) and the standard Prebid log showing the auctions and the bids received from the `panxo` bidder on AI-influenced visits.
3. **Google Publisher Console.** Open the Google Publisher Console (for example adding `?google_console=1` to the URL and pressing Ctrl+F10, or running `googletag.openConsole()` in the browser console) and check that the slots show the `hb_pb`, `hb_adid`, `hb_bidder` and `hb_size` key-values when there was a bid.
4. **Request to securepubads.** In the browser's Network tab, locate the call to `securepubads.g.doubleclick.net` and confirm that the `prev_scp` parameter contains `hb_pb=` (and `hb_bidder=panxo`) for the slots with a bid. That parameter carries the per-slot targeting: if `hb_pb` appears there, the key-values are reaching Ad Manager.
5. **Delivery in Ad Manager.** On the line item matching the observed bucket, use delivery diagnostics (Delivery diagnostics / Troubleshoot) to confirm that the line item receives impressions and competes. Remember that volume will be low at first: only AI-influenced traffic participates.

### Frequently asked questions

**Fill on the Panxo line items is low. Is that normal?**

Yes, and it is the expected behavior. Panxo does not bid on all traffic: we only bid on AI-influenced visits, typically 5-25% of total visits depending on each site's profile. The rest of the impressions keeps going entirely to your current demand. Panxo's value is in the price of those visits, not in the volume.

**What happens if Panxo does not respond or goes down?**

Nothing, zero impact. If Panxo does not bid, does not respond in time or the service fails completely, no key-values are applied and Ad Manager serves exactly what it would have served without Panxo. There is no scenario in which a Panxo failure affects the delivery of your ads.

**Does it affect page load speed or performance?**

No. The Panxo RTD Module loads asynchronously, the auction runs in parallel and never blocks or delays your ads. In addition, Panxo never calls refresh: we do not trigger, advance or repeat any ad call; we only leave key-values ready for the ad calls your page already makes.

**How is the integration turned off if needed?**

With a notice to Panxo (<tech@panxo.ai>). Deactivation happens on our side, server-side, and takes effect in under 5 minutes, without touching Google Tag Manager or Ad Manager. The tag can stay published: with the domain deactivated it is completely inert.

### Annex A: first-impression coverage (optional, phase 2)

By design, in phase 1 Panxo never delays anything: if the auction does not arrive before the first ad call, the Panxo bid competes starting with the next refresh or lazy-load. For first-impression slots there is an optional phase 2 that is **not a go-live requirement** and requires coordination with whoever controls the first ad call on your pages (your ad management vendor or your own setup).

The RTD Module exposes `window.panxo.firstAuction`: a promise that **always resolves, at most at 800 ms, no matter what** (a completed auction, a timeout or any error all resolve it; it never hangs). Your first ad call can wait for it:

```js
// Before firing the first ad batch:
var waitForPanxo = (window.panxo && window.panxo.firstAuction) || Promise.resolve();
waitForPanxo.then(function () {
  launchFirstAdBatch(); // your existing function that fires the first ad call
});
```

The result is **first-impression coverage bounded by the 800 ms budget**: when the auction arrives within the budget, the first impression already competes with the Panxo bid; when the connection is slow and it does not arrive, the promise resolves at the deadline and that page behaves as in phase 1. The worst possible case is a single wait of 800 ms before the first ad batch; there are never additional waits.

If you want to activate this phase, write to us and we coordinate the details.

### Annex B: line item automation

Creating 25 line items by hand is perfectly viable with the duplicate-and-adjust flow from Step 3, but there are two alternatives:

1. **Prebid's Line Item Manager.** Open source tool from the Prebid project that automatically generates the line items and the creatives via the Google Ad Manager API: <https://github.com/prebid/line-item-manager>. It is configured with the buckets from the Step 3 table and creates the whole set in minutes.
2. **We set it up for you.** If you grant us trafficker access to your network (or Ad Manager API credentials), our team creates the order, the 25 line items and the creatives, and leaves everything ready for your review and approval. It is the fastest path and has no cost for you.

### Contact

* **Technical support and integration:** <tech@panxo.ai>
* **Partnerships and commercial matters:** <publishers@panxo.ai>


# OpenRTB 2.5

Quick guide for publishers to configure Panxo as a demand partner in their SSP.

## Before You Start

You need:

* Your **Panxo Property Key** (get it from your Panxo dashboard)
* Admin access to your SSP platform

***

## General Steps (All SSPs)

{% stepper %}
{% step %}

### Log into your SSP admin panel

Open your SSP's admin interface.
{% endstep %}

{% step %}

### Find the demand partner settings

Look for sections named "External Demand", "Demand Partners", or "Third Party Bidders".
{% endstep %}

{% step %}

### Add a new bidder/partner

Click "Add New" or "Add Bidder".
{% endstep %}

{% step %}

### Enter Panxo configuration

Fill in the following fields:

| Field               | Value                                                 |
| ------------------- | ----------------------------------------------------- |
| **Name**            | Panxo                                                 |
| **Bid Endpoint**    | `https://panxo-sys.com/openrtb/2.5/bid?key=YOUR_KEY`  |
| **Cookie Sync URL** | `https://panxo-sys.com/usersync?redir={REDIRECT_URL}` |
| **Protocol**        | OpenRTB 2.5                                           |
| **Timeout**         | 500ms (or your preference)                            |
| {% endstep %}       |                                                       |

{% step %}

### Enable the partner

Enable/activate the partner in your SSP.
{% endstep %}

{% step %}

### Test with a sample page

Verify the integration on a test page.
{% endstep %}
{% endstepper %}

***

## SSP-Specific Instructions

### Xandr (Microsoft)

{% stepper %}
{% step %}
Go to Network > Partners > Bidders and click "New Bidder".
{% endstep %}

{% step %}
Fill in:

* Name: `Panxo`
* Bid URI: `https://panxo-sys.com/openrtb/2.5/bid?key=YOUR_KEY`
  {% endstep %}

{% step %}
Under User Sync:

* URL: `https://panxo-sys.com/usersync?redir=$REDIRECT_URL`
* Type: Redirect
  {% endstep %}

{% step %}
Save and enable.
{% endstep %}
{% endstepper %}

***

### Magnite

{% stepper %}
{% step %}
Go to Partners > Demand and click "Add Partner".
{% endstep %}

{% step %}
If Panxo is not in the list, click "Request New Partner".
{% endstep %}

{% step %}
Provide:

* Partner Name: Panxo
* Endpoint: `https://panxo-sys.com/openrtb/2.5/bid?key=YOUR_KEY`
* Cookie Sync: `https://panxo-sys.com/usersync?redir={redirectUrl}`
  {% endstep %}

{% step %}
Magnite will approve and add it to your account.
{% endstep %}
{% endstepper %}

***

### PubMatic

{% stepper %}
{% step %}
Go to Inventory > Demand Partners and click "Add Demand Partner".
{% endstep %}

{% step %}
Select "Custom RTB" if available and enter:

* Name: Panxo
* Endpoint: `https://panxo-sys.com/openrtb/2.5/bid?key=YOUR_KEY`
  {% endstep %}

{% step %}
If custom RTB is not available, contact PubMatic support to add Panxo.
{% endstep %}
{% endstepper %}

***

### Google Ad Manager (GAM)

For GAM with Open Bidding:

* Go to Delivery > Yield Groups
* Under Yield Partners, look for Panxo
* If not listed, contact your Google representative to enable Panxo

For GAM with Prebid.js:

* See Prebid adapter documentation (coming soon)

***

### Adserver.online

{% stepper %}
{% step %}
Go to SSP > RTB Endpoints and click "Add Endpoint".
{% endstep %}

{% step %}
Enter:

* Name: Panxo
* Endpoint URL: `https://panxo-sys.com/openrtb/2.5/bid?key=YOUR_KEY`
* QPS Limit: 1000 (or as needed)
* Timeout: 700ms
  {% endstep %}

{% step %}
Under Cookie Matching:

* Our sync URL: `https://panxo-sys.com/usersync?redir={redirectUrlEnc}`
  {% endstep %}

{% step %}
Save and enable.
{% endstep %}
{% endstepper %}

***

## Verification

After setup, verify the integration:

{% stepper %}
{% step %}

### Check Cookie Sync

Open your browser console and look for requests to:

```
https://panxo-sys.com/usersync...
```

{% endstep %}

{% step %}

### Check Bid Requests

In your SSP logs or debug mode, verify:

* Bid requests are being sent to Panxo
* `user.buyeruid` is included in requests
* Responses are received (200 or 204)
  {% endstep %}

{% step %}

### Test with AI Traffic

1. Visit your site from an AI assistant (ChatGPT, Perplexity, etc.)
2. Check your Panxo dashboard for signals
3. Verify bids are being submitted
   {% endstep %}
   {% endstepper %}

***

## Troubleshooting

### Panxo not in partner list

{% stepper %}
{% step %}
Contact your SSP support.
{% endstep %}

{% step %}
Send them the [SSP Integration Guide](broken://pages/a691d1d533f293cf6522b94e60d0baabcc2593ef).
{% endstep %}

{% step %}
They will add Panxo to your available partners.
{% endstep %}
{% endstepper %}

### No bids received

Check:

* Cookie sync is working (check browser network tab)
* `user.buyeruid` is being sent
* Your property key is correct
* The domain matches what's registered in Panxo

<details>

<summary>204 (No Content) responses — why this can happen</summary>

This is normal when:

* User hasn't been synced yet
* User is not from AI traffic
* No matching campaigns

</details>

***

## Need Help?

Contact Panxo support:

* Email: <support@panxo.ai>
* Dashboard: <https://app.panxo.ai>

***

Last Updated: January 2026


# Native

Sticky Native is Panxo's direct integration method. Install a script on your site and Panxo automatically detects AI traffic and serves native ad formats. No SSP or ad server required.

## How It Works

{% stepper %}
{% step %}

### Overview

The Panxo script runs on every pageview and analyzes the visit in real-time.
{% endstep %}

{% step %}
If the visitor was referred by an AI assistant (ChatGPT, Perplexity, Claude, Gemini, etc.), the script requests an ad from Panxo.
{% endstep %}

{% step %}
A native ad format renders on the page (sticky banner, announcement bar, smart corner, or content pause).
{% endstep %}

{% step %}
If the visitor is human, the script does nothing — your existing ads are unaffected.
{% endstep %}
{% endstepper %}

## Integration

{% stepper %}
{% step %}

### Install the script

Get your unique script tag from your dashboard at [app.panxo.ai](https://app.panxo.ai/) → **Settings → Integration**.

{% tabs %}
{% tab title="Google Tag Manager" %}

1. Create a new **Custom HTML** tag
2. Paste your script:

{% code title="GTM - Custom HTML" %}

```html
<script async src="https://cdn.panxo.ai/o/{YOUR_HASH}"></script>
```

{% endcode %}

3. Set trigger to **All Pages** (Page View)
4. Test in Preview mode — look for `[Panxo]` in the browser console
5. Publish
   {% endtab %}

{% tab title="Direct Script" %}
Add to your `<head>`:

{% code title="Direct script" %}

```html
<head>
  <script async src="https://cdn.panxo.ai/o/{YOUR_HASH}"></script>
</head>
```

{% endcode %}
{% endtab %}

{% tab title="WordPress" %}

1. **Plugins → Add New** → search **"Panxo AI Monetization"**
2. Install and activate
3. Done — the plugin handles script injection and ads.txt automatically
   {% endtab %}
   {% endtabs %}

The `async` attribute ensures the script never blocks page rendering.
{% endstep %}

{% step %}

### Configure ads.txt

Append these lines to your `ads.txt` file. Get the exact lines with your unique IDs from **Settings → Ads.txt** in your dashboard.

```
#PanxoAI
panxo.ai, YOUR_PANXO_ID, DIRECT
bidgx.com, YOUR_BIDGX_ID, DIRECT
kntxy.com, YOUR_KNTXY_ID, DIRECT
rubiconproject.com, 27034, RESELLER, 0bfd66d529a55807
themediagrid.com, FNG4LA, RESELLER, 35d5010d7789b49d
pubmatic.com, 166733, RESELLER, 5d62403b186f2ace
smartadserver.com, 5397, RESELLER, 060d053dcf45cbf3
xandr.com, 17781, RESELLER
```

The `DIRECT` IDs are unique per property — copy them from the dashboard. The `RESELLER` lines are the same for all publishers.

{% hint style="info" %}
WordPress plugin manages ads.txt automatically. Skip this step if you use the plugin.
{% endhint %}
{% endstep %}

{% step %}

### Verify

In your dashboard, click **Verify**. Panxo checks that the script loads and ads.txt is correct. Verification runs every 6 hours and completes within 24 hours.
{% endstep %}
{% endstepper %}

## Ad Formats

All formats are native cards containing: image, title, description, advertiser badge, and CTA button. Enable/disable each format from your dashboard. All achieve **CLS = 0**.

### Sticky Banner

Fixed card in the bottom-right corner of the viewport (320px wide).

* Collapsed: Thumbnail + title + CTA button (80px height)
* Expanded: Full image + advertiser badge + title + description + CTA button
* Trigger: Expands when user scrolls 200px. Auto-collapses after 5s. Dismissible.
* CLS: Uses `position: fixed` — no layout shift.

### Announcement Bar

Full-width bar at the top of the viewport.

* Collapsed: Logo + title + subtitle + "Learn More" button
* Expanded: Image + advertiser badge + title + description + CTA button (expands on hover)
* CLS: Reserves a placeholder at page load — no layout shift on expand/collapse.

### Smart Corner

Floating card in the bottom-right corner (260px wide).

* Collapsed: Small pill with logo + title + arrow icon
* Expanded: Full native card with image + advertiser badge + title + description + CTA button
* Trigger: Expands on hover or scroll.
* CLS: Uses `position: fixed` — no layout shift.

### Content Pause

Inline native card inserted between content blocks.

* Creative: Image + title + description + "Sponsored" label
* Trigger: Appears after the user pauses scrolling multiple times.
* CLS: Invisible placeholder reserved at page load — no layout shift when the card appears.

## Technical Specs

|                     |                                               |
| ------------------- | --------------------------------------------- |
| **Size**            | \~20 KB gzipped (104 KB raw)                  |
| **CDN**             | Cloudflare with Brotli/Gzip                   |
| **Load time**       | < 50ms from edge                              |
| **Loading**         | Async, non-blocking                           |
| **CLS / LCP / FID** | Zero impact                                   |
| **Browsers**        | Chrome 60+, Firefox 55+, Safari 11+, Edge 79+ |

## Troubleshooting

| Problem                     | Solution                                                                                                                   |
| --------------------------- | -------------------------------------------------------------------------------------------------------------------------- |
| Script not loading          | Check browser console for errors. Verify URL matches dashboard. Disable ad blocker.                                        |
| No ads appearing            | Expected for human traffic. Panxo only shows ads to AI-referred visits. Check ads.txt is verified and formats are enabled. |
| Ads.txt verification failed | File must be at `https://yourdomain.com/ads.txt`. Copy lines from dashboard to avoid typos. Allow 24h.                     |


# Signal ( oRTB/Native )

## Google Tag Manager (Recommended)

{% hint style="success" %}
**Recommended Integration Method**\
GTM integration requires no code changes to your website and allows easy enable/disable without deployments.
{% endhint %}

### Setup Steps

{% stepper %}
{% step %}

### Get Your Script from Dashboard

* Log into your Panxo dashboard at `app.panxo.ai`
* Navigate to **Settings → Integration**
* Copy your integration script (format: `<script async src="https://cdn.panxo.ai/o/{hash}"></script>`)

{% hint style="info" %}
**Your Script:**\
Each property receives a unique hash-based script URL. This hash is automatically generated and displayed in your dashboard. Simply copy the complete script tag.
{% endhint %}
{% endstep %}

{% step %}

### Create GTM Tag

In Google Tag Manager, create a new **Custom HTML** tag and paste your script:

{% code title="Custom HTML (example)" %}

```html
<script async src="https://cdn.panxo.ai/o/6c6cfb20039e1773"></script>
```

{% endcode %}

Example Script Format:

| Component | Description                         | Example                                   |
| --------- | ----------------------------------- | ----------------------------------------- |
| **URL**   | Hash-based script URL               | `https://cdn.panxo.ai/o/6c6cfb20039e1773` |
| **Hash**  | Unique identifier for your property | `6c6cfb20039e1773`                        |

{% hint style="warning" %}
**Important:** Use the exact script provided in your dashboard. Each property has a unique hash that cannot be shared or reused.
{% endhint %}
{% endstep %}

{% step %}

### Configure Trigger

* Set trigger to fire on **"All Pages"** or specific pages
* Use **"Page View"** trigger type
  {% endstep %}

{% step %}

### Test & Publish

* Use GTM Preview mode to verify script loads
* Publish container when ready
  {% endstep %}
  {% endstepper %}

### Verification

{% hint style="info" %}
**Verification Checklist:**

* Script appears in Network tab as `/o/{hash}` (e.g., `/o/6c6cfb20039e1773`)
* Dashboard shows "Script Verified" status in real-time (verification happens immediately after script integration)
  {% endhint %}

***

## Direct Script Integration

**When to Use:**

* If you don't use GTM
* Need more control over script placement
* WordPress sites (consider plugin instead)

### Setup

Add to your `<head>` section using the script from your dashboard:

{% code title="Example (head)" %}

```html
<head>
  <!-- Other head content -->
  <script async src="https://cdn.panxo.ai/o/6c6cfb20039e1773"></script>
</head>
```

{% endcode %}

{% hint style="warning" %}
**Important Notes:**

* Use the exact script provided in your dashboard (Settings → Integration)
* Each property has a unique hash-based URL
* Place in `<head>` for early detection
* `async` attribute ensures non-blocking load
* Script auto-initializes when DOM is ready
  {% endhint %}

***

## WordPress Plugin

**When to Use:**

* WordPress-powered sites
* Want automatic `ads.txt` management
* Prefer plugin-based integration
* Zero-configuration setup

### Installation

{% stepper %}
{% step %}
Go to **WordPress admin → Plugins → Add New**
{% endstep %}

{% step %}
Search for **"Panxo AI Monetization"**
{% endstep %}

{% step %}
Click **"Install Now"** and **"Activate"**
{% endstep %}
{% endstepper %}

**Plugin URL:** [WordPress.org Plugin Directory](https://wordpress.org/plugins/panxo-ai-monetization/)

### Automatic Configuration

{% hint style="success" %}
**Zero-Configuration Setup**\
The plugin handles everything automatically. Setup completes in less than 1 minute.
{% endhint %}

**What the Plugin Does Automatically:**

* Registers your WordPress site with Panxo
* Creates your property
* Integrates the Panxo script into `<head>`
* Updates your `ads.txt` file with required entries
* Begins the learning process

### Verification

* Dashboard shows **"Script Verified"** and **"Ads.txt Verified"** when complete
* Monitor learning phase progress from WordPress dashboard

***

## Prebid.js / OpenRTB Integration

**When to Use:**

* Already using Prebid.js for header bidding
* Want Panxo to compete in your existing auction
* Running a multi-SSP setup
* Direct OpenRTB integration

{% hint style="info" %}
**Best For:** Publishers with existing Prebid infrastructure who want to add AI traffic monetization to their demand stack.
{% endhint %}

### Prerequisites

From your Panxo Dashboard (Settings > OpenRTB/Prebid):

1. **Endpoint Key** - A unique hash for your property (e.g., `06dc70992da98be6`)
2. **Signal Script URL** - `https://cdn.panxo-sys.com/o/{ENDPOINT_KEY}`

{% hint style="warning" %}
**Important Domain:** For Prebid/OpenRTB, use `cdn.panxo-sys.com` (NOT cdn.panxo.ai). This is required for proper cookie syncing.
{% endhint %}

### Steps

{% stepper %}
{% step %}

### Install Signal Script

The Signal script **must load before** Prebid.js:

{% code title="head (signal + prebid)" %}

```html
<head>
  <!-- Panxo Signal Script - MUST load before Prebid -->
  <script async src="https://cdn.panxo-sys.com/o/YOUR_ENDPOINT_KEY"></script>
  
  <!-- Prebid.js -->
  <script async src="prebid.js"></script>
</head>
```

{% endcode %}

The Signal script:

* Creates user identity (`panxo_uid`) in localStorage
* Detects AI-referred traffic
* Enables Panxo to bid on your inventory
  {% endstep %}

{% step %}

### Configure Prebid Ad Unit

{% code title="adUnits example" %}

```javascript
var adUnits = [{
  code: 'ad-slot-1',
  mediaTypes: {
    banner: {
      sizes: [[300, 250], [728, 90], [320, 50]]
    }
  },
  bids: [{
    bidder: 'panxo',
    params: {
      propertyKey: '06dc70992da98be6'  // Your endpoint key (same hash as Signal script)
    }
  }]
}];
```

{% endcode %}
{% endstep %}

{% step %}

### Initialize Prebid

{% code title="Prebid initialization" %}

```javascript
var pbjs = pbjs || {};
pbjs.que = pbjs.que || [];

pbjs.que.push(function() {
  pbjs.addAdUnits(adUnits);
  
  pbjs.requestBids({
    timeout: 2000,
    bidsBackHandler: function() {
      var winner = pbjs.getHighestCpmBids('ad-slot-1')[0];
      if (winner) {
        renderAd(winner);
      }
    }
  });
});

function renderAd(bid) {
  var container = document.getElementById('ad-slot-1');
  var iframe = document.createElement('iframe');
  iframe.width = bid.width;
  iframe.height = bid.height;
  iframe.frameBorder = '0';
  container.appendChild(iframe);
  iframe.contentWindow.document.open();
  iframe.contentWindow.document.write(bid.ad);
  iframe.contentWindow.document.close();
}
```

{% endcode %}
{% endstep %}
{% endstepper %}

### Bid Parameters

| Parameter     | Required | Description                                       |
| ------------- | -------- | ------------------------------------------------- |
| `propertyKey` | Yes      | Your endpoint key hash (e.g., `06dc70992da98be6`) |
| `floor`       | No       | Minimum CPM in USD                                |

### How Bidding Works

{% hint style="info" %}
**AI-Only Bidding**\
Panxo only bids when AI traffic is detected. You'll only receive bids for users coming from ChatGPT, Perplexity, Claude, etc.
{% endhint %}

1. Signal script loads and creates `panxo_uid` in localStorage
2. Signal script detects if user came from AI and stores signal
3. Prebid requests bids from all configured bidders
4. Panxo adapter reads `panxo_uid` and sends OpenRTB request
5. Panxo server checks if user has AI signal and returns bid
6. If Panxo wins auction, ad is displayed

### Expected Performance

| Metric    | Typical Value          |
| --------- | ---------------------- |
| CPM       | $5 - $15               |
| Fill Rate | 5-15% of total traffic |

{% hint style="success" %}
**Why Low Fill Rate is Normal**\
Panxo targets only AI traffic (typically 5-15% of visits). This focused approach delivers premium CPMs without affecting your other demand sources.
{% endhint %}

### Full Example

{% code title="Full example (HTML)" %}

```html
<!DOCTYPE html>
<html>
<head>
  <!-- 1. Panxo Signal Script (MUST load first) -->
  <script async src="https://cdn.panxo-sys.com/o/06dc70992da98be6"></script>
  
  <!-- 2. Prebid.js -->
  <script async src="prebid.js"></script>
  
  <script>
    var pbjs = pbjs || {};
    pbjs.que = pbjs.que || [];
    
    pbjs.que.push(function() {
      pbjs.addAdUnits([{
        code: 'banner-ad',
        mediaTypes: { banner: { sizes: [[300, 250], [728, 90]] } },
        bids: [{
          bidder: 'panxo',
          params: { propertyKey: '06dc70992da98be6' }
        }]
      }]);
      
      pbjs.requestBids({
        timeout: 2000,
        bidsBackHandler: function() {
          var winner = pbjs.getHighestCpmBids('banner-ad')[0];
          if (winner) {
            var container = document.getElementById('banner-ad');
            var iframe = document.createElement('iframe');
            iframe.width = winner.width;
            iframe.height = winner.height;
            iframe.frameBorder = '0';
            container.appendChild(iframe);
            iframe.contentWindow.document.open();
            iframe.contentWindow.document.write(winner.ad);
            iframe.contentWindow.document.close();
          }
        }
      });
    });
  </script>
</head>
<body>
  <div id="banner-ad"></div>
</body>
</html>
```

{% endcode %}

### Testing

Enable Prebid debug mode:

{% code title="Enable debug" %}

```javascript
pbjs.setConfig({ debug: true });
```

{% endcode %}

Check browser console for:

* `Panxo: Sending bid request` - Request sent
* `Panxo: Bid received` - Bid returned
* `Panxo: User ID not found` - Signal script not loaded

Verify Signal script:

{% code title="Check panxo\_uid" %}

```javascript
console.log(localStorage.getItem('panxo_uid'));
// Should show: "d9433353-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
```

{% endcode %}

### Troubleshooting

<details>

<summary>No bids received?</summary>

1. Verify Signal script URL uses `cdn.panxo-sys.com` (NOT cdn.panxo.ai)
2. Check localStorage for `panxo_uid` (DevTools > Application > Local Storage)
3. Verify endpoint key matches between Signal script and Prebid params
4. Panxo only bids if user has AI signal (came from AI recently)

</details>

<details>

<summary>Low fill rate?</summary>

* This is expected - Panxo only bids on AI-referred traffic
* Check AI traffic percentage in your Panxo dashboard

</details>

<details>

<summary>Need help?</summary>

* Email: <support@panxo.ai>
* Dashboard: app.panxo.ai

</details>


# SSP Managed Accounts

Technical documentation for SSPs to integrate Panxo as an external demand partner.

***

## 1. Company Information

| Field                 | Value                            |
| --------------------- | -------------------------------- |
| **Company Name**      | Panxo                            |
| **Platform Type**     | DSP (Demand-Side Platform)       |
| **Specialization**    | AI-referred traffic monetization |
| **Website**           | <https://panxo.ai>               |
| **Technical Contact** | <tech@panxo.ai>                  |

***

## 2. OpenRTB Endpoint

| Field               | Value                                                      |
| ------------------- | ---------------------------------------------------------- |
| **Endpoint URL**    | `https://panxo-sys.com/openrtb/2.5/bid?key={PROPERTY_KEY}` |
| **Protocol**        | OpenRTB 2.5                                                |
| **Method**          | POST                                                       |
| **Content-Type**    | application/json                                           |
| **Response Format** | OpenRTB 2.5 JSON                                           |

### Endpoint Parameters

| Parameter | Required | Description                                              |
| --------- | -------- | -------------------------------------------------------- |
| `key`     | Yes      | Unique property key provided by Panxo for each publisher |

### Example Endpoint

```
https://panxo-sys.com/openrtb/2.5/bid?key=abc123xyz
```

***

## 3. Cookie Sync (User Sync)

Cookie synchronization is **required** for Panxo to identify users and provide relevant bids.

| Field               | Value                                                 |
| ------------------- | ----------------------------------------------------- |
| **Sync URL**        | `https://panxo-sys.com/usersync?redir={REDIRECT_URL}` |
| **Cookie Name**     | `_psid`                                               |
| **Cookie Domain**   | `.panxo-sys.com`                                      |
| **Cookie Duration** | 1 year                                                |
| **Sync Type**       | Redirect (image pixel)                                |

### Sync URL Parameters

| Parameter | Description                                                               |
| --------- | ------------------------------------------------------------------------- |
| `redir`   | URL-encoded redirect URL. Panxo will append `uid={PANXO_UID}` to this URL |

### Example Sync Flow

{% stepper %}
{% step %}
SSP calls:

`https://panxo-sys.com/usersync?redir=https%3A%2F%2Fssp.example.com%2Fsync%3Fdsp%3Dpanxo%26uid%3D`
{% endstep %}

{% step %}
Panxo redirects to:

`https://ssp.example.com/sync?dsp=panxo&uid=abc123-def456-...`
{% endstep %}

{% step %}
SSP stores mapping:

`panxo_uid = abc123-def456-...`
{% endstep %}

{% step %}
In bid requests, SSP sends:

`user.buyeruid = abc123-def456-...`
{% endstep %}
{% endstepper %}

### Alternative Sync Endpoint

For SSPs that support iframe-based sync:

```
https://panxo-sys.com/usersync/iframe?callback={CALLBACK_URL}
```

***

## 4. Bid Request Requirements

### Required Fields

| Field                        | Description                          |
| ---------------------------- | ------------------------------------ |
| `id`                         | Unique bid request ID                |
| `imp[]`                      | At least one impression object       |
| `imp[].id`                   | Impression ID                        |
| `imp[].banner`               | Banner object (required for display) |
| `site.domain` or `site.page` | Domain where ad will be shown        |
| `user.buyeruid`              | **Panxo user ID from cookie sync**   |

### Recommended Fields

| Field                   | Description                                |
| ----------------------- | ------------------------------------------ |
| `tmax`                  | Maximum response time (ms). Default: 500ms |
| `device.ua`             | User agent string                          |
| `device.ip`             | User IP address                            |
| `device.geo`            | Geographic information                     |
| `imp[].bidfloor`        | Floor price in CPM                         |
| `imp[].banner.format[]` | Array of accepted sizes                    |

### Supported Banner Sizes

| Size    | Description         |
| ------- | ------------------- |
| 300x250 | Medium Rectangle    |
| 728x90  | Leaderboard         |
| 160x600 | Wide Skyscraper     |
| 300x600 | Half Page           |
| 320x50  | Mobile Banner       |
| 320x100 | Large Mobile Banner |

### Example Bid Request

```json
{
  "id": "req-12345",
  "imp": [{
    "id": "imp-1",
    "banner": {
      "format": [
        {"w": 300, "h": 250},
        {"w": 728, "h": 90}
      ]
    },
    "bidfloor": 0.50
  }],
  "site": {
    "domain": "example.com",
    "page": "https://example.com/article/123"
  },
  "device": {
    "ua": "Mozilla/5.0...",
    "ip": "203.0.113.50",
    "geo": {
      "country": "USA"
    }
  },
  "user": {
    "buyeruid": "abc123-def456-789xyz"
  },
  "tmax": 500
}
```

***

## 5. Bid Response Format

### Response Codes

| Code | Description         |
| ---- | ------------------- |
| 200  | Bid submitted       |
| 204  | No bid (no content) |

### Response Fields

| Field                     | Description                |
| ------------------------- | -------------------------- |
| `id`                      | Echo of bid request ID     |
| `seatbid[].seat`          | Always "panxo"             |
| `seatbid[].bid[].id`      | Unique bid ID              |
| `seatbid[].bid[].impid`   | Impression ID being bid on |
| `seatbid[].bid[].price`   | Bid price in CPM (USD)     |
| `seatbid[].bid[].adm`     | Ad markup (HTML)           |
| `seatbid[].bid[].adomain` | Advertiser domain(s)       |
| `seatbid[].bid[].w`       | Creative width             |
| `seatbid[].bid[].h`       | Creative height            |
| `seatbid[].bid[].nurl`    | Win notification URL       |
| `seatbid[].bid[].lurl`    | Loss notification URL      |

### Example Bid Response

```json
{
  "id": "req-12345",
  "seatbid": [{
    "seat": "panxo",
    "bid": [{
      "id": "bid-abc123",
      "impid": "imp-1",
      "price": 2.50,
      "adm": "<div><!-- ad markup --></div>",
      "adomain": ["advertiser.com"],
      "w": 300,
      "h": 250,
      "nurl": "https://panxo-sys.com/win?b=bid-abc123&p=${AUCTION_PRICE}",
      "lurl": "https://panxo-sys.com/loss?b=bid-abc123&r=${AUCTION_LOSS}"
    }]
  }],
  "cur": "USD"
}
```

***

## 6. Notification URLs

### Win Notification

Called when Panxo's bid wins the auction.

| Field      | Value                               |
| ---------- | ----------------------------------- |
| **URL**    | Provided in `bid.nurl`              |
| **Method** | GET                                 |
| **Macros** | `${AUCTION_PRICE}` - clearing price |

### Loss Notification

Called when Panxo's bid loses.

| Field      | Value                                |
| ---------- | ------------------------------------ |
| **URL**    | Provided in `bid.lurl`               |
| **Method** | GET                                  |
| **Macros** | `${AUCTION_LOSS}` - loss reason code |

### Impression Tracking

Embedded in ad markup. Fires when ad is rendered.

### Click Tracking

Embedded in ad markup. Redirects through Panxo tracking before landing page.

***

## 7. Technical Requirements

### Latency

| Metric                    | Value                 |
| ------------------------- | --------------------- |
| **Target Response Time**  | < 100ms               |
| **Maximum Response Time** | Respects `tmax` field |
| **Default Timeout**       | 500ms                 |

### Infrastructure

| Aspect           | Details                          |
| ---------------- | -------------------------------- |
| **Hosting**      | Cloudflare Workers (global edge) |
| **Availability** | 99.9% uptime SLA                 |
| **TLS**          | TLS 1.2+ required                |
| **Compression**  | gzip supported                   |

### Rate Limits

No rate limits. Infrastructure scales automatically.

***

## 8. Supported Features

| Feature                   | Support |
| ------------------------- | ------- |
| Banner Display            | Yes     |
| Video                     | Planned |
| Native                    | Planned |
| Private Marketplace (PMP) | No      |
| First-Price Auction       | Yes     |
| Second-Price Auction      | Yes     |
| GDPR (TCF 2.0)            | Yes     |
| CCPA (US Privacy)         | Yes     |
| GPP                       | Yes     |

***

## 9. Privacy & Compliance

### Data Usage

* User IDs are used solely for frequency capping and ad targeting
* No personal data is stored beyond session
* Full GDPR and CCPA compliance

### Blocked Content

Panxo does not serve ads for:

* Adult content
* Illegal products
* Malware or deceptive content
* Weapons or ammunition

### Creative Policies

* All creatives are pre-approved
* No auto-play audio
* No pop-ups or pop-unders
* No malicious redirects

***

## 10. Testing

### Test Mode

Send `test: 1` in bid request to enable test mode. Test bids will not be charged.

### Health Check

```
GET https://panxo-sys.com/health
```

Response:

```json
{
  "status": "healthy",
  "service": "panxo-ortb",
  "timestamp": "2026-01-17T12:00:00Z"
}
```

### Sample Test Request

```bash
curl -X POST "https://panxo-sys.com/openrtb/2.5/bid?key=test123" \
  -H "Content-Type: application/json" \
  -d '{
    "id": "test-request-1",
    "test": 1,
    "imp": [{
      "id": "imp-1",
      "banner": {"w": 300, "h": 250}
    }],
    "site": {"domain": "test.example.com"},
    "user": {"buyeruid": "test-user-123"},
    "tmax": 500
  }'
```

***

## 11. Contact

| Type                     | Contact           |
| ------------------------ | ----------------- |
| **Technical Support**    | <tech@panxo.ai>   |
| **Business Development** | <sales@panxo.ai>  |
| **Emergency**            | <oncall@panxo.ai> |

***

## Appendix A: SSP-Specific Configuration

### For Xandr

{% stepper %}
{% step %}
Go to **Demand Partners** > **Add External Bidder**
{% endstep %}

{% step %}
Enter:

* Bidder Name: `Panxo`
* Bid URI: `https://panxo-sys.com/openrtb/2.5/bid?key={YOUR_KEY}`
* User Sync URL: `https://panxo-sys.com/usersync?redir={REDIRECT_URL_ENC}`
  {% endstep %}

{% step %}
Enable `buyeruid` passthrough
{% endstep %}
{% endstepper %}

### For Magnite

{% stepper %}
{% step %}
Go to **Partners** > **Add Demand Partner**
{% endstep %}

{% step %}
Enter:

* Partner Name: `Panxo`
* Endpoint: `https://panxo-sys.com/openrtb/2.5/bid?key={YOUR_KEY}`
* Cookie Sync: `https://panxo-sys.com/usersync?redir={redirectUrl}`
  {% endstep %}

{% step %}
Supported formats: Banner
{% endstep %}
{% endstepper %}

### For PubMatic

Contact Panxo for PubMatic-specific integration instructions.

### For Google Ad Manager (Open Bidding)

Panxo is available as an Open Bidding partner. Contact Google for enablement.

***

## Appendix B: Troubleshooting

<details>

<summary>No bids received</summary>

Verify user.buyeruid is being sent (requires cookie sync)Check that site.domain matches the registered propertyVerify the key parameter is correctEnsure requested sizes are supported

</details>

<details>

<summary>204 responses</summary>

Normal behavior when:

* User is not synced (`user.buyeruid` missing)
* No campaigns match the inventory
* Floor price is too high
* No AI signal detected for user

</details>

<details>

<summary>Cookie sync not working</summary>

Verify redirect URL is properly encodedCheck that SSP is calling the sync URL on page loadEnsure third-party cookies are not blocked

</details>

***

*Document Version: 1.0*\
*Last Updated: January 2026*


# Ads.txt

We require the following ads.txt entries:

```
#PanxoAI
panxo.ai, YOUR_PANXO_ID, DIRECT
bidgx.com, YOUR_BIDGX_ID, DIRECT
kntxy.com, YOUR_KNXTY_ID, DIRECT
rubiconproject.com, 27034, RESELLER, 0bfd66d529a55807
themediagrid.com, FNG4LA, RESELLER, 35d5010d7789b49d
pubmatic.com, 166733, RESELLER, 5d62403b186f2ace
smartadserver.com, 5397, RESELLER, 060d053dcf45cbf3
xandr.com, 17781, RESELLER
```

<br>


# Dashboard

The Panxo dashboard provides a simple interface to view & download reports. The dashboard pulls data from the [Reporting API](/#dashboard-and-reporting), so any information available here is also available through the API.

### Accessing the Dashboard

You can register for a dashboard user account any time at [app.panxo.ai](https://app.panxo.ai)

Once you have registered, our team will link your user profile to your publisher account, so you can see any existing performance data, as well as manage sub accounts & access your API Key.

<br>


# Ad Blocking

Our dashboard allows you to block creatives via four OpenRTB specified attributes:

1. Advertiser Domain Blocks (badv)
2. Ad Category Blocks (bcat)
3. Creative Attribute Blocks (battr)
4. Creative ID (crid) Blocks

These can applied per-domain or account-wide.

### Per-domain Blocking

Log into your dashboard and click "Settings" in the top menu. Then go to **Ad Blocks & Controls**:

1. On the left, type in the name of the website you are blocking ads on, e.g. "newsfinance.com" (this is the publisher site). Click "Add Publisher Site". This will reveal a box or dropdown on the right.
2. On the right, select categories to block for that publisher (under "Ad Category Blocks"), or add advertiser domains ("adomains") under "Advertiser Domain Blocks".

### Account-wide Blocks

You can also implement account-wide blocks by going to **Account > Ad Settings & Blocks**. These blocks will be combined with the blocks defined per-domain:


# Reporting API

description: Access your revenue, traffic, and performance data programmatically via the Panxo Reporting API.

## Reporting API

The Reporting API gives publishers programmatic access to their revenue and traffic data. Use it to build custom dashboards, automate reporting, or integrate Panxo metrics into your existing analytics stack.

***

### Authentication

All requests require an API key passed via the `X-Panxo-API-Key` header.

```bash
curl -X GET https://api.panxo.com/api/v1/reporting/overview \
  -H "X-Panxo-API-Key: pk_your_api_key_here"
```

#### Getting your API key

{% stepper %}
{% step %}

### Log in

Log in to [app.panxo.com](https://app.panxo.com)
{% endstep %}

{% step %}

### Open API Keys

Go to **Settings > API Keys**
{% endstep %}

{% step %}

### Generate

Generate a new key (format: `pk_...`)
{% endstep %}
{% endstepper %}

{% hint style="warning" %}
Keep your API key secret. Do not expose it in client-side code or public repositories.
{% endhint %}

***

### Base URL

```
https://api.panxo.com/api/v1/reporting
```

***

### Endpoints

#### GET /overview

Returns aggregated metrics for your property over a given period.

**Query Parameters**

| Parameter | Type     | Required | Default | Description                             |
| --------- | -------- | -------- | ------- | --------------------------------------- |
| `period`  | `string` | No       | `30d`   | Time period. One of: `7d`, `30d`, `90d` |

**Request**

```bash
curl -X GET "https://api.panxo.com/api/v1/reporting/overview?period=30d" \
  -H "X-Panxo-API-Key: pk_your_api_key_here"
```

**Response**

```json
{
  "success": true,
  "period": "30d",
  "data": {
    "revenue": {
      "total": 1520.45,
      "currency": "USD"
    },
    "traffic": {
      "ai_visits": 48230,
      "human_visits": 892400,
      "ai_percentage": 5.12
    },
    "performance": {
      "rpm": 31.52,
      "fill_rate": 86.40
    }
  },
  "generated_at": "2026-02-02T14:30:00.000Z"
}
```

**Response Fields**

| Field                   | Type     | Description                                                     |
| ----------------------- | -------- | --------------------------------------------------------------- |
| `revenue.total`         | `number` | Total revenue in USD for the period                             |
| `revenue.currency`      | `string` | Always `USD`                                                    |
| `traffic.ai_visits`     | `number` | Total AI-influenced visits                                      |
| `traffic.human_visits`  | `number` | Total human visits                                              |
| `traffic.ai_percentage` | `number` | AI visits as percentage of total traffic                        |
| `performance.rpm`       | `number` | Average Revenue Per Mille (per 1,000 AI visits)                 |
| `performance.fill_rate` | `number` | Average fill rate (percentage of AI visits that received an ad) |

***

#### GET /daily

Returns a day-by-day breakdown of revenue and traffic metrics.

**Query Parameters**

| Parameter | Type     | Required | Default | Description                           |
| --------- | -------- | -------- | ------- | ------------------------------------- |
| `days`    | `number` | No       | `30`    | Number of days to return. Range: 1-90 |

**Request**

```bash
curl -X GET "https://api.panxo.ai/api/v1/reporting/daily?days=7" \
  -H "X-Panxo-API-Key: pk_your_api_key_here"
```

**Response**

```json
{
  "success": true,
  "days_requested": 7,
  "days_returned": 7,
  "data": [
    {
      "date": "2026-02-02",
      "revenue": 52.30,
      "ai_visits": 1650,
      "human_visits": 31200,
      "rpm": 31.70,
      "fill_rate": 87.20
    },
    {
      "date": "2026-02-01",
      "revenue": 48.15,
      "ai_visits": 1520,
      "human_visits": 29800,
      "rpm": 31.68,
      "fill_rate": 86.50
    }
  ],
  "generated_at": "2026-02-02T14:30:00.000Z"
}
```

**Response Fields (per day)**

| Field          | Type     | Description                 |
| -------------- | -------- | --------------------------- |
| `date`         | `string` | Date in `YYYY-MM-DD` format |
| `revenue`      | `number` | Revenue in USD for that day |
| `ai_visits`    | `number` | AI-influenced visits        |
| `human_visits` | `number` | Human visits                |
| `rpm`          | `number` | RPM for that day            |
| `fill_rate`    | `number` | Fill rate for that day      |

{% hint style="info" %}
Data is ordered by date descending (most recent first). Days with no traffic data are omitted from the response.
{% endhint %}

***

### Error Handling

#### Authentication Errors

```json
{
  "success": false,
  "error": "Invalid API key format. Key must start with pk_"
}
```

| HTTP Code | Error                           | Cause                                 |
| --------- | ------------------------------- | ------------------------------------- |
| `401`     | `Authentication required`       | Missing `X-Panxo-API-Key` header      |
| `401`     | `Invalid API key format`        | Key does not start with `pk_`         |
| `403`     | `Invalid or inactive API key`   | Key not found or property is inactive |
| `429`     | `Rate limit exceeded`           | Too many requests                     |
| `500`     | `Failed to fetch overview data` | Internal server error                 |

#### Response Structure

All responses follow the same structure:

**Success:**

```json
{
  "success": true,
  "data": { ... },
  "generated_at": "2026-02-02T14:30:00.000Z"
}
```

**Error:**

```json
{
  "success": false,
  "error": "Error description"
}
```

***

### Rate Limits

| Limit               | Value  |
| ------------------- | ------ |
| Requests per minute | 60     |
| Requests per day    | 10,000 |

Rate limit headers are included in responses:

```
X-RateLimit-Limit: 60
X-RateLimit-Remaining: 58
X-RateLimit-Reset: 1706886000
```

***

### Code Examples

{% tabs %}
{% tab title="JavaScript" %}
{% code title="overview\.js" %}

```javascript
const API_KEY = 'pk_your_api_key_here';
const BASE_URL = 'https://api.panxo.ai/api/v1/reporting';

// Get 30-day overview
async function getOverview() {
  const response = await fetch(`${BASE_URL}/overview?period=30d`, {
    headers: { 'X-Panxo-API-Key': API_KEY }
  });
  return response.json();
}

// Get daily breakdown
async function getDailyReport(days = 30) {
  const response = await fetch(`${BASE_URL}/daily?days=${days}`, {
    headers: { 'X-Panxo-API-Key': API_KEY }
  });
  return response.json();
}

// Usage
const overview = await getOverview();
console.log(`Revenue: $${overview.data.revenue.total}`);
console.log(`AI Traffic: ${overview.data.traffic.ai_percentage}%`);
console.log(`RPM: $${overview.data.performance.rpm}`);
```

{% endcode %}
{% endtab %}

{% tab title="Python" %}
{% code title="overview\.py" %}

```python
import requests

API_KEY = 'pk_your_api_key_here'
BASE_URL = 'https://api.panxo.ai/api/v1/reporting'
HEADERS = {'X-Panxo-API-Key': API_KEY}

# Get 30-day overview
def get_overview(period='30d'):
    response = requests.get(
        f'{BASE_URL}/overview',
        params={'period': period},
        headers=HEADERS
    )
    return response.json()

# Get daily breakdown
def get_daily_report(days=30):
    response = requests.get(
        f'{BASE_URL}/daily',
        params={'days': days},
        headers=HEADERS
    )
    return response.json()

# Usage
overview = get_overview()
print(f"Revenue: ${overview['data']['revenue']['total']}")
print(f"AI Traffic: {overview['data']['traffic']['ai_percentage']}%")
print(f"RPM: ${overview['data']['performance']['rpm']}")
```

{% endcode %}
{% endtab %}

{% tab title="cURL" %}
{% code title="examples.sh" %}

```bash
# Overview (last 30 days)
curl -s "https://api.panxo.ai/api/v1/reporting/overview?period=30d" \
  -H "X-Panxo-API-Key: pk_your_api_key_here" | jq .

# Daily breakdown (last 7 days)
curl -s "https://api.panxo.ai/api/v1/reporting/daily?days=7" \
  -H "X-Panxo-API-Key: pk_your_api_key_here" | jq .
```

{% endcode %}
{% endtab %}
{% endtabs %}

***

### Support

| Resource            | Link                                        |
| ------------------- | ------------------------------------------- |
| Publisher Dashboard | [app.panxo.ai](https://app.panxo.ai/)       |
| Technical Support   | <tech@panxo.ai>                             |
| API Status          | [status.panxo.ai](https://status.panxo.ai/) |