get_media_buy_delivery

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

// 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)}`);
}

if (validated.media_buy_deliveries.length > 0) {
  const delivery = validated.media_buy_deliveries[0];
  console.log(`Delivered ${delivery.totals.impressions.toLocaleString()} impressions`);
  if (delivery.currency && delivery.totals.spend !== undefined) {
    console.log(`Spend: ${delivery.totals.spend.toFixed(2)} ${delivery.currency}`);
  }
  console.log(`CTR: ${(delivery.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}")

    if result.media_buy_deliveries:
        delivery = result.media_buy_deliveries[0]
        print(f"Delivered {delivery.totals.impressions:,} impressions")
        if getattr(delivery, 'currency', None) and getattr(delivery.totals, 'spend', None) is not None:
            print(f"Spend: {delivery.totals.spend:.2f} {delivery.currency}")
        print(f"CTR: {delivery.totals.ctr * 100:.2f}%")

asyncio.run(main())

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

// 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.media_buy_deliveries.length} active campaigns`);

// Review each campaign
validated.media_buy_deliveries.forEach(delivery => {
  const spend = delivery.currency && delivery.totals.spend !== undefined
    ? `, ${delivery.totals.spend.toFixed(2)} ${delivery.currency}`
    : '';
  console.log(`${delivery.media_buy_id}: ${delivery.totals.impressions.toLocaleString()} impressions${spend}, 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"{len(result.media_buy_deliveries)} active campaigns")

    # Review each campaign
    for delivery in result.media_buy_deliveries:
        spend = (f", {delivery.totals.spend:.2f} {delivery.currency}"
                 if getattr(delivery, 'currency', None) and getattr(delivery.totals, 'spend', None) is not None else "")
        print(f"{delivery.media_buy_id}: {delivery.totals.impressions:,} impressions{spend}, CTR {delivery.totals.ctr * 100:.2f}%")

asyncio.run(main())

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

// 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.media_buy_deliveries[0].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.media_buy_deliveries[0].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/sdk/testing';
import { GetMediaBuyDeliveryResponseSchema } from '@adcp/sdk';

// 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/sdk/testing';
import { GetMediaBuyDeliveryResponseSchema } from '@adcp/sdk';

// Compare several media buys by their seller-assigned IDs (from create_media_buy / get_media_buys)
const result = await testAgent.getMediaBuyDelivery({
  media_buy_ids: ['mb_q1_campaign_2024', 'mb_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)}`);
}

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

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

async def main():
    # Compare several media buys by their seller-assigned IDs (from create_media_buy / get_media_buys)
    result = await test_agent.get_media_buy_delivery(
        GetMediaBuyDeliveryRequest(
            media_buy_ids=['mb_q1_campaign_2024', 'mb_q1_retargeting_2024']
        )
    )

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

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

asyncio.run(main())

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

// 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)}`);
}

for (const delivery of validated.media_buy_deliveries) {
  if (delivery.currency && delivery.totals.spend !== undefined) {
    console.log(`${delivery.media_buy_id}: ${delivery.totals.spend.toFixed(2)} ${delivery.currency}`);
  }
}

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}")

    for delivery in result.media_buy_deliveries:
        if getattr(delivery, 'currency', None) and getattr(delivery.totals, 'spend', None) is not None:
            print(f"{delivery.media_buy_id}: {delivery.totals.spend:.2f} {delivery.currency}")

asyncio.run(main())