get_media_buy_delivery

import { testAgent } from '@adcp/client/testing';
import { GetMediaBuyDeliveryResponseSchema } from '@adcp/client';

// Get single media buy delivery report
const result = await testAgent.getMediaBuyDelivery({
  media_buy_ids: ['mb_12345'],
  start_date: '2024-02-01',
  end_date: '2024-02-07'
});

if (!result.success) {
  throw new Error(`Request failed: ${result.error}`);
}

const validated = GetMediaBuyDeliveryResponseSchema.parse(result.data);

// Check for errors (discriminated union response)
if ('errors' in validated && validated.errors) {
  throw new Error(`Query failed: ${JSON.stringify(validated.errors)}`);
}

console.log(`Delivered ${validated.aggregated_totals.impressions.toLocaleString()} impressions`);
console.log(`Spend: $${validated.aggregated_totals.spend.toFixed(2)}`);
if (validated.media_buy_deliveries.length > 0) {
  console.log(`CTR: ${(validated.media_buy_deliveries[0].totals.ctr * 100).toFixed(2)}%`);
}

import asyncio
from adcp.testing import test_agent
from adcp.types import GetMediaBuyDeliveryRequest

async def main():
    # Get single media buy delivery report
    result = await test_agent.get_media_buy_delivery(
        GetMediaBuyDeliveryRequest(
            media_buy_ids=['mb_12345'],
            start_date='2024-02-01',
            end_date='2024-02-07'
        )
    )

    # Check for errors (discriminated union response)
    if hasattr(result, 'errors') and result.errors:
        raise Exception(f"Query failed: {result.errors}")

    print(f"Delivered {result.aggregated_totals.impressions:,} impressions")
    print(f"Spend: ${result.aggregated_totals.spend:.2f}")
    if result.media_buy_deliveries:
        print(f"CTR: {result.media_buy_deliveries[0].totals.ctr * 100:.2f}%")

asyncio.run(main())

import { testAgent } from '@adcp/client/testing';
import { GetMediaBuyDeliveryResponseSchema } from '@adcp/client';

// Get all active media buys from context
const result = await testAgent.getMediaBuyDelivery({
  status_filter: 'active',
  start_date: '2024-02-01',
  end_date: '2024-02-07'
});

if (!result.success) {
  throw new Error(`Request failed: ${result.error}`);
}

const validated = GetMediaBuyDeliveryResponseSchema.parse(result.data);

if ('errors' in validated && validated.errors) {
  throw new Error(`Query failed: ${JSON.stringify(validated.errors)}`);
}

console.log(`${validated.aggregated_totals.media_buy_count} active campaigns`);
console.log(`Total impressions: ${validated.aggregated_totals.impressions.toLocaleString()}`);
console.log(`Total spend: $${validated.aggregated_totals.spend.toFixed(2)}`);

// Review each campaign
validated.media_buy_deliveries.forEach(delivery => {
  console.log(`${delivery.media_buy_id}: ${delivery.totals.impressions.toLocaleString()} impressions, CTR ${(delivery.totals.ctr * 100).toFixed(2)}%`);
});

import asyncio
from adcp.testing import test_agent
from adcp.types import GetMediaBuyDeliveryRequest

async def main():
    # Get all active media buys from context
    result = await test_agent.get_media_buy_delivery(
        GetMediaBuyDeliveryRequest(
            status_filter='active',
            start_date='2024-02-01',
            end_date='2024-02-07'
        )
    )

    if hasattr(result, 'errors') and result.errors:
        raise Exception(f"Query failed: {result.errors}")

    print(f"{result.aggregated_totals.media_buy_count} active campaigns")
    print(f"Total impressions: {result.aggregated_totals.impressions:,}")
    print(f"Total spend: ${result.aggregated_totals.spend:.2f}")

    # Review each campaign
    for delivery in result.media_buy_deliveries:
        print(f"{delivery.media_buy_id}: {delivery.totals.impressions:,} impressions, CTR {delivery.totals.ctr * 100:.2f}%")

asyncio.run(main())

import { testAgent } from '@adcp/client/testing';
import { GetMediaBuyDeliveryResponseSchema } from '@adcp/client';

// Get month-to-date performance
const now = new Date();
const monthStart = new Date(now.getFullYear(), now.getMonth(), 1);
const dateFormat = date => date.toISOString().split('T')[0];

const result = await testAgent.getMediaBuyDelivery({
  media_buy_ids: ['mb_12345'],
  start_date: dateFormat(monthStart),
  end_date: dateFormat(now)
});

if (!result.success) {
  throw new Error(`Request failed: ${result.error}`);
}

const validated = GetMediaBuyDeliveryResponseSchema.parse(result.data);

if ('errors' in validated && validated.errors) {
  throw new Error(`Query failed: ${JSON.stringify(validated.errors)}`);
}

if (validated.media_buy_deliveries.length > 0) {
  // Analyze daily breakdown
  const dailyBreakdown = validated.media_buy_deliveries[0].daily_breakdown;
  if (dailyBreakdown && dailyBreakdown.length > 0) {
    console.log(`Daily average: ${Math.round(validated.aggregated_totals.impressions / dailyBreakdown.length).toLocaleString()} impressions`);

    // Find peak day
    const peakDay = dailyBreakdown.reduce((max, day) =>
      day.impressions > max.impressions ? day : max
    );
    console.log(`Peak day: ${peakDay.date} with ${peakDay.impressions.toLocaleString()} impressions`);
  }
}

import asyncio
from adcp.testing import test_agent
from adcp.types import GetMediaBuyDeliveryRequest
from datetime import date

async def main():
    # Get month-to-date performance
    today = date.today()
    month_start = date(today.year, today.month, 1)

    result = await test_agent.get_media_buy_delivery(
        GetMediaBuyDeliveryRequest(
            media_buy_ids=['mb_12345'],
            start_date=str(month_start),
            end_date=str(today)
        )
    )

    if hasattr(result, 'errors') and result.errors:
        raise Exception(f"Query failed: {result.errors}")

    if result.media_buy_deliveries:
        # Analyze daily breakdown
        daily_breakdown = result.media_buy_deliveries[0].daily_breakdown
        if daily_breakdown:
            daily_avg = result.aggregated_totals.impressions // len(daily_breakdown)
            print(f"Daily average: {daily_avg:,} impressions")

            # Find peak day
            peak_day = max(daily_breakdown, key=lambda d: d.impressions)
            print(f"Peak day: {peak_day.date} with {peak_day.impressions:,} impressions")

asyncio.run(main())

import { testAgent } from '@adcp/client/testing';
import { GetMediaBuyDeliveryResponseSchema } from '@adcp/client';

// Get both active and paused campaigns
const result = await testAgent.getMediaBuyDelivery({
  status_filter: ['active', 'paused'],
  start_date: '2024-02-01',
  end_date: '2024-02-07'
});

if (!result.success) {
  throw new Error(`Request failed: ${result.error}`);
}

const validated = GetMediaBuyDeliveryResponseSchema.parse(result.data);

if ('errors' in validated && validated.errors) {
  throw new Error(`Query failed: ${JSON.stringify(validated.errors)}`);
}

// Group by status
const byStatus = validated.media_buy_deliveries.reduce((acc, delivery) => {
  if (!acc[delivery.status]) acc[delivery.status] = [];
  acc[delivery.status].push(delivery);
  return acc;
}, {});

console.log(`Active campaigns: ${byStatus.active?.length || 0}`);
console.log(`Paused campaigns: ${byStatus.paused?.length || 0}`);

// Identify underperforming campaigns
byStatus.paused?.forEach(delivery => {
  if (delivery.by_package && delivery.by_package.length > 0) {
    const avgPacing = delivery.by_package.reduce((sum, pkg) => sum + pkg.pacing_index, 0) / delivery.by_package.length;
    console.log(`${delivery.media_buy_id}: paused with ${(avgPacing * 100).toFixed(0)}% pacing`);
  }
});

import asyncio
from adcp.testing import test_agent
from adcp.types import GetMediaBuyDeliveryRequest
from collections import defaultdict

async def main():
    # Get both active and paused campaigns
    result = await test_agent.get_media_buy_delivery(
        GetMediaBuyDeliveryRequest(
            status_filter=['active', 'paused'],
            start_date='2024-02-01',
            end_date='2024-02-07'
        )
    )

    if hasattr(result, 'errors') and result.errors:
        raise Exception(f"Query failed: {result.errors}")

    # Group by status
    by_status = defaultdict(list)
    for delivery in result.media_buy_deliveries:
        by_status[delivery.status].append(delivery)

    print(f"Active campaigns: {len(by_status['active'])}")
    print(f"Paused campaigns: {len(by_status['paused'])}")

    # Identify underperforming campaigns
    for delivery in by_status['paused']:
        if delivery.by_package:
            avg_pacing = sum(pkg.pacing_index for pkg in delivery.by_package) / len(delivery.by_package)
            print(f"{delivery.media_buy_id}: paused with {avg_pacing * 100:.0f}% pacing")

asyncio.run(main())

import { testAgent } from '@adcp/client/testing';
import { GetMediaBuyDeliveryResponseSchema } from '@adcp/client';

// Query by buyer reference instead of media buy ID
const result = await testAgent.getMediaBuyDelivery({
  media_buy_ids: ['acme_q1_campaign_2024', 'acme_q1_retargeting_2024']
});

if (!result.success) {
  throw new Error(`Request failed: ${result.error}`);
}

const validated = GetMediaBuyDeliveryResponseSchema.parse(result.data);

if ('errors' in validated && validated.errors) {
  throw new Error(`Query failed: ${JSON.stringify(validated.errors)}`);
}

// Lifetime delivery data (no date range specified)
console.log(`Total lifetime impressions: ${validated.aggregated_totals.impressions.toLocaleString()}`);
console.log(`Total lifetime spend: $${validated.aggregated_totals.spend.toFixed(2)}`);

// Compare campaigns
validated.media_buy_deliveries.forEach(delivery => {
  if (delivery.totals.impressions > 0) {
    const cpm = (delivery.totals.spend / delivery.totals.impressions) * 1000;
    console.log(`${delivery.media_buy_id}: CPM $${cpm.toFixed(2)}, CTR ${(delivery.totals.ctr * 100).toFixed(2)}%`);
  }
});

import asyncio
from adcp.testing import test_agent
from adcp.types import GetMediaBuyDeliveryRequest

async def main():
    # Query by buyer reference instead of media buy ID
    result = await test_agent.get_media_buy_delivery(
        GetMediaBuyDeliveryRequest(
            media_buy_ids=['acme_q1_campaign_2024', 'acme_q1_retargeting_2024']
        )
    )

    if hasattr(result, 'errors') and result.errors:
        raise Exception(f"Query failed: {result.errors}")

    # Lifetime delivery data (no date range specified)
    print(f"Total lifetime impressions: {result.aggregated_totals.impressions:,}")
    print(f"Total lifetime spend: ${result.aggregated_totals.spend:.2f}")

    # Compare campaigns
    for delivery in result.media_buy_deliveries:
        if delivery.totals.impressions > 0:
            cpm = (delivery.totals.spend / delivery.totals.impressions) * 1000
            print(f"{delivery.media_buy_id}: CPM ${cpm:.2f}, CTR {delivery.totals.ctr * 100:.2f}%")

asyncio.run(main())

import { testAgent } from '@adcp/client/testing';
import { GetMediaBuyDeliveryResponseSchema } from '@adcp/client';

// Get delivery for a specific advertiser account
const result = await testAgent.getMediaBuyDelivery({
  account: { account_id: 'acc_acme_pinnacle' },
  status_filter: 'active',
  start_date: '2024-02-01',
  end_date: '2024-02-07'
});

if (!result.success) {
  throw new Error(`Request failed: ${result.error}`);
}

const validated = GetMediaBuyDeliveryResponseSchema.parse(result.data);

if ('errors' in validated && validated.errors) {
  throw new Error(`Query failed: ${JSON.stringify(validated.errors)}`);
}

console.log(`${validated.aggregated_totals.media_buy_count} campaigns for account`);
console.log(`Total spend: $${validated.aggregated_totals.spend.toFixed(2)}`);

import asyncio
from adcp.testing import test_agent
from adcp.types import GetMediaBuyDeliveryRequest

async def main():
    # Get delivery for a specific advertiser account
    result = await test_agent.get_media_buy_delivery(
        GetMediaBuyDeliveryRequest(
            account={'account_id': 'acc_acme_pinnacle'},
            status_filter='active',
            start_date='2024-02-01',
            end_date='2024-02-07'
        )
    )

    if hasattr(result, 'errors') and result.errors:
        raise Exception(f"Query failed: {result.errors}")

    print(f"{result.aggregated_totals.media_buy_count} campaigns for account")
    print(f"Total spend: ${result.aggregated_totals.spend:.2f}")

asyncio.run(main())