> ## Documentation Index
> Fetch the complete documentation index at: https://adcp-docs-ja.pier1.co.jp/llms.txt
> Use this file to discover all available pages before exploring further.

# list_creative_formats

> list_creative_formats は任意の AdCP エージェントからアセット要件と技術的制約を含む広告フォーマット仕様を探索します。

クリエイティブエージェントがサポートするクリエイティブフォーマットを探索します。アセット要件や技術的制約を含む完全なフォーマット仕様を返します。

**応答時間**: 約 1 秒（データベース参照）

**認証**: 不要（フォーマット探索のための公開エンドポイント）

**Request Schema**: [`/schemas/v3/creative/list-creative-formats-request.json`](https://adcontextprotocol.org/schemas/v3/creative/list-creative-formats-request.json)
**Response Schema**: [`/schemas/v3/creative/list-creative-formats-response.json`](https://adcontextprotocol.org/schemas/v3/creative/list-creative-formats-response.json)

## エージェントタイプ別の動作

Creative Protocol を実装するどのエージェントも `list_creative_formats` を提供できます。レスポンスはエージェントが担う役割によって異なります。

**専用クリエイティブエージェント**（例: `https://creative.adcontextprotocol.org`）:

* 自身が保有する **権威あるフォーマット定義** を返す
* クリエイティブの構築とバリデーションのための完全な仕様を提供します

**Media Buy Protocol のみを実装する営業エージェント**（例: `https://agenticadvertising.org/api/training-agent`）:

* **稼働中のプロダクトで使われているフォーマットのみ** を返す
* 権威あるフォーマット仕様についてクリエイティブエージェントを参照します
* 実際に購入可能なものに基づいて結果をフィルタリングします

**両方のプロトコルを実装する営業エージェント** — 自前のフォーマット定義と参照フォーマットを合わせて返します。[セールスエージェントのクリエイティブ機能](/docs/creative/sales-agent-creative-capabilities)を参照。

営業エージェント固有の挙動は [list\_creative\_formats (Sales Agent)](/docs/creative/task-reference/list_creative_formats) を参照。

## リクエストパラメーター

| Parameter                | Type        | Required | Description                                                                                                                                   |
| ------------------------ | ----------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
| `format_ids`             | FormatID\[] | No       | 特定のフォーマット ID のみ返す（`get_products` レスポンス由来）                                                                                                     |
| `type`                   | string      | No       | *(非推奨)* 種別でフィルター: `audio`, `video`, `display`, `dooh`。代わりに `asset_types` フィルターを使用すること。                                                        |
| `asset_types`            | string\[]   | No       | `image`, `video`, `audio`, `text`, `html`, `javascript`, `url` を受け付けるフォーマットに絞り込む（OR ロジック）。**`type` フィルターより推奨。**                               |
| `max_width`              | integer     | No       | 最大幅（ピクセル、以下を含む）- いずれかのレンダーが収まれば一致                                                                                                             |
| `max_height`             | integer     | No       | 最大高さ（ピクセル、以下を含む）- いずれかのレンダーが収まれば一致                                                                                                            |
| `min_width`              | integer     | No       | 最小幅（ピクセル、以上を含む）                                                                                                                               |
| `min_height`             | integer     | No       | 最小高さ（ピクセル、以上を含む）                                                                                                                              |
| `is_responsive`          | boolean     | No       | レスポンシブ対応（コンテナサイズに適応）に絞る                                                                                                                       |
| `name_search`            | string      | No       | 名前による検索（大文字小文字を区別しない部分一致）                                                                                                                     |
| `wcag_level`             | string      | No       | 少なくともこの WCAG レベルを満たすフォーマットに絞り込む: `A`、`AA`、`AAA`。[アクセシビリティ](/docs/creative/accessibility)を参照。                                                  |
| `disclosure_positions`   | string\[]   | No       | これらすべてのディスクロージャーポジションをサポートするフォーマットに絞り込む。`disclosure_capabilities` が存在する場合はそれに対してマッチングし、存在しない場合は `supported_disclosure_positions` にフォールバックします。 |
| `disclosure_persistence` | string\[]   | No       | `disclosure_capabilities` に少なくとも 1 つのポジションでこれらの持続性モードをすべて含むフォーマットに絞り込む。値: `continuous`、`initial`、`flexible`。                                  |
| `output_format_ids`      | FormatID\[] | No       | `output_format_ids` にこれらのいずれかが含まれるフォーマットに絞り込む。これらの出力を生成できるフォーマットが返されます。`input_format_ids` で受け付ける入力を確認します。                                     |
| `input_format_ids`       | FormatID\[] | No       | `input_format_ids` にこれらのいずれかが含まれるフォーマットに絞り込む。これらのクリエイティブを入力として受け付けるフォーマットが返されます。`output_format_ids` で生成できる出力を確認します。                           |
| `pagination`             | object      | No       | ページネーション: `max_results`（1〜100、デフォルト 50）と `cursor`（前のレスポンスの不透明なカーソル）                                                                           |

### 複数レンダーの寸法フィルタリング

フォーマットは複数のレンダー（例: 動画 + コンパニオンバナー）を生成する場合があります。寸法フィルターは **「いずれかのレンダーが合致すれば OK」** というロジックです。

* `max_width: 300, max_height: 250` - **少なくとも 1 つ** のレンダーが 300×250 以下であれば一致
* ユースケース: 「300×250 の広告枠に収まるフォーマットを探す」
* 例: メイン動画 (1920×1080) とコンパニオンバナー (300×250) を持つフォーマットは、バナーが収まるため **一致**

## レスポンス

| Field             | Description                                                                       |
| ----------------- | --------------------------------------------------------------------------------- |
| `formats`         | フォーマット定義の完全な配列（format\_id、name、assets、renders を含む）。`type` フィールドは非推奨で省略される場合があります。 |
| `creative_agents` | 追加フォーマットを提供する他のクリエイティブエージェントの任意配列                                                 |

完全なフォーマット構造は [Format schema](https://adcontextprotocol.org/schemas/v3/core/format.json) を参照。

### 再帰的な探索

クリエイティブエージェントは、追加フォーマットを提供する他のクリエイティブエージェントを参照する場合があります。

```json theme={null}
{
  "creative_agents": [{
    "agent_url": "https://creative.adcontextprotocol.org",
    "agent_name": "AdCP Reference Creative Agent",
    "capabilities": ["validation", "assembly", "preview"]
  }]
}
```

バイヤーは `creative_agents` を再帰的に問い合わせできます。**無限ループを避けるため、訪問済み URL を必ず追跡すること。**

## カタログ要件

フォーマットは `assets` 配列の `catalog` アセットタイプとしてカタログのニーズを宣言します。これにより、バイヤーはそのフォーマット向けのクリエイティブを送信する前にどのカタログを同期すべきかを把握できます。

```json theme={null}
{
  "format_id": {
    "agent_url": "https://creative.adcontextprotocol.org",
    "id": "product_carousel_4x"
  },
  "name": "Product Carousel (4 items)",
  "assets": [
    {
      "item_type": "individual",
      "asset_id": "product_catalog",
      "asset_type": "catalog",
      "required": true,
      "requirements": {
        "catalog_type": "product",
        "min_items": 4,
        "required_fields": ["name", "price", "image_url"]
      }
    }
  ]
}
```

カタログアセットは `asset_type: "catalog"` を使用し、以下を含む `requirements` オブジェクトを持ちます。

| Field             | Type      | Description                                                  |
| ----------------- | --------- | ------------------------------------------------------------ |
| `catalog_type`    | string    | 必須。カタログのタイプ（例: `product`、`store`、`job`）                      |
| `min_items`       | integer   | カタログが含まなければなりませんアイテムの最小数                                     |
| `max_items`       | integer   | フォーマットがレンダーできるアイテムの最大数。この制限を超えるアイテムは無視される                    |
| `required_fields` | string\[] | すべてのアイテムに存在しなければなりませんフィールド                                   |
| `feed_formats`    | string\[] | 受け付けるフィードフォーマット（例: `google_merchant_center`、`linkedin_jobs`） |

カタログアセットが存在する場合、バイヤーはクリエイティブを送信する前に [`sync_catalogs`](/docs/media-buy/task-reference/sync_catalogs) で必要なカタログを同期すること。完全なライフサイクルは[カタログ](/docs/creative/catalogs)を参照。

## よくあるシナリオ

### プロダクトのフォーマット ID から仕様を取得します

<CodeGroup>
  ```javascript JavaScript theme={null}
  import { testAgent } from '@adcp/client/testing';
  import { ListCreativeFormatsResponseSchema } from '@adcp/client';

  // Get full specs for formats returned by get_products
  const result = await testAgent.listCreativeFormats({
    format_ids: [
      {
        agent_url: 'https://creative.adcontextprotocol.org',
        id: 'video_15s_hosted'
      },
      {
        agent_url: 'https://creative.adcontextprotocol.org',
        id: 'display_300x250'
      }
    ]
  });

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

  // Validate response against schema
  const validated = ListCreativeFormatsResponseSchema.parse(result.data);
  validated.formats.forEach(format => {
    console.log(`${format.name}: ${format.assets.length} assets required`);
  });
  ```

  ```python Python theme={null}
  import asyncio
  from adcp.testing import test_agent
  from adcp.types import ListCreativeFormatsRequest, FormatId

  async def main():
      # Get full specs for formats returned by get_products
      result = await test_agent.list_creative_formats(
          ListCreativeFormatsRequest(
              format_ids=[
                  FormatId(agent_url='https://creative.adcontextprotocol.org', id='video_15s_hosted'),
                  FormatId(agent_url='https://creative.adcontextprotocol.org', id='display_300x250')
              ]
          )
      )

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

      for fmt in result.formats:
          print(f"{fmt.name}: {len(fmt.assets)} assets required")

  asyncio.run(main())
  ```
</CodeGroup>

### アセットタイプでフォーマットを探す

<CodeGroup>
  ```javascript JavaScript theme={null}
  import { testAgent } from '@adcp/client/testing';
  import { ListCreativeFormatsResponseSchema } from '@adcp/client';

  // Find formats that accept images and text
  const result = await testAgent.listCreativeFormats({
    asset_types: ['image', 'text']
  });

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

  const validated = ListCreativeFormatsResponseSchema.parse(result.data);
  console.log(`Found ${validated.formats.length} formats`);

  // Examine asset requirements
  validated.formats.forEach(format => {
    console.log(`\n${format.name}:`);
    format.assets.forEach(asset => {
      const label = asset.asset_role ?? asset.asset_id;
      console.log(`  - ${label}: ${asset.asset_type}`);
    });
  });
  ```

  ```python Python theme={null}
  import asyncio
  from adcp.testing import test_agent
  from adcp.types import ListCreativeFormatsRequest

  async def main():
      # Find formats that accept images and text
      result = await test_agent.list_creative_formats(
          ListCreativeFormatsRequest(asset_types=['image', 'text'])
      )

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

      print(f"Found {len(result.formats)} formats")
      for fmt in result.formats:
          print(f"\n{fmt.name}:")
          for asset in fmt.assets:
              label = asset.asset_role or asset.asset_id
              print(f"  - {label}: {asset.asset_type}")

  asyncio.run(main())
  ```
</CodeGroup>

### サードパーティタグ対応フォーマットを探す

<CodeGroup>
  ```javascript JavaScript theme={null}
  import { testAgent } from '@adcp/client/testing';
  import { ListCreativeFormatsResponseSchema } from '@adcp/client';

  // Find formats that accept JavaScript or HTML tags
  const result = await testAgent.listCreativeFormats({
    asset_types: ['javascript', 'html'],
    max_width: 970,
    max_height: 250
  });

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

  const validated = ListCreativeFormatsResponseSchema.parse(result.data);
  console.log(`Found ${validated.formats.length} third-party tag formats ≤ 970×250`);

  validated.formats.forEach(format => {
    const renders = format.renders || [];
    if (renders.length > 0) {
      const dims = renders[0].dimensions;
      console.log(`${format.name}: ${dims.width}×${dims.height}`);
    }
  });
  ```

  ```python Python theme={null}
  import asyncio
  from adcp.testing import test_agent
  from adcp.types import ListCreativeFormatsRequest

  async def main():
      # Find formats that accept JavaScript or HTML tags
      result = await test_agent.list_creative_formats(
          ListCreativeFormatsRequest(
              asset_types=['javascript', 'html'],
              max_width=970,
              max_height=250
          )
      )

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

      print(f"Found {len(result.formats)} third-party tag formats ≤ 970×250")
      for fmt in result.formats:
          if fmt.renders:
              dims = fmt.renders[0].dimensions
              print(f"{fmt.name}: {dims.width}×{dims.height}")

  asyncio.run(main())
  ```
</CodeGroup>

### 種別と寸法で絞り込む

<CodeGroup>
  ```javascript JavaScript theme={null}
  import { testAgent } from '@adcp/client/testing';
  import { ListCreativeFormatsResponseSchema } from '@adcp/client';

  // Find video formats
  const result = await testAgent.listCreativeFormats({
    type: 'video'
  });

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

  const validated = ListCreativeFormatsResponseSchema.parse(result.data);
  console.log(`Found ${validated.formats.length} video formats`);

  validated.formats.forEach(format => {
    const assetTypes = format.assets.map(a => a.asset_type).join(', ');
    console.log(`${format.name}: ${assetTypes}`);
  });
  ```

  ```python Python theme={null}
  import asyncio
  from adcp.testing import test_agent
  from adcp.types import ListCreativeFormatsRequest

  async def main():
      # Find video formats
      result = await test_agent.list_creative_formats(
          ListCreativeFormatsRequest(type='video')
      )

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

      print(f"Found {len(result.formats)} video formats")
      for fmt in result.formats:
          asset_types = ', '.join(a.asset_type for a in fmt.assets)
          print(f"{fmt.name}: {asset_types}")

  asyncio.run(main())
  ```
</CodeGroup>

### 名前で検索します

<CodeGroup>
  ```javascript JavaScript theme={null}
  import { testAgent } from '@adcp/client/testing';
  import { ListCreativeFormatsResponseSchema } from '@adcp/client';

  // Find mobile-optimized formats
  const result = await testAgent.listCreativeFormats({
    name_search: 'mobile'
  });

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

  const validated = ListCreativeFormatsResponseSchema.parse(result.data);
  console.log(`Found ${validated.formats.length} mobile formats`);

  validated.formats.forEach(format => {
    console.log(`- ${format.name} (${format.type})`);
  });
  ```

  ```python Python theme={null}
  import asyncio
  from adcp.testing import test_agent
  from adcp.types import ListCreativeFormatsRequest

  async def main():
      # Find mobile-optimized formats
      result = await test_agent.list_creative_formats(
          ListCreativeFormatsRequest(name_search='mobile')
      )

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

      print(f"Found {len(result.formats)} mobile formats")
      for fmt in result.formats:
          print(f"- {fmt.name} ({fmt.type})")

  asyncio.run(main())
  ```
</CodeGroup>

### レスポンシブフォーマットを探す

<CodeGroup>
  ```javascript JavaScript theme={null}
  import { testAgent } from '@adcp/client/testing';
  import { ListCreativeFormatsResponseSchema } from '@adcp/client';

  // Find formats that adapt to container size
  const result = await testAgent.listCreativeFormats({
    is_responsive: true,
    type: 'display'
  });

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

  const validated = ListCreativeFormatsResponseSchema.parse(result.data);
  console.log(`Found ${validated.formats.length} responsive display formats`);

  validated.formats.forEach(format => {
    console.log(`${format.name}: Adapts to container`);
  });
  ```

  ```python Python theme={null}
  import asyncio
  from adcp.testing import test_agent
  from adcp.types import ListCreativeFormatsRequest

  async def main():
      # Find formats that adapt to container size
      result = await test_agent.list_creative_formats(
          ListCreativeFormatsRequest(is_responsive=True, type='display')
      )

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

      print(f"Found {len(result.formats)} responsive display formats")
      for fmt in result.formats:
          print(f"{fmt.name}: Adapts to container")

  asyncio.run(main())
  ```
</CodeGroup>

### ビルドケイパビリティを探索します

一部のフォーマットは `output_format_ids` 経由で生成できる出力フォーマットを宣言します。マルチパブリッシャーのテンプレートツールのようなクリエイティブビルダーは、1 つのアセットグループを受け取り多くのパブリッシャー固有フォーマットを生成する場合があります。フォーマットトランスフォーマーは既存のクリエイティブを受け取り再フォーマットする場合があります。

フォーマットスキーマはリレーションシップの両側を表現します。

* **`input_format_ids`** — このフォーマットが入力として受け付ける既存のクリエイティブフォーマット
* **`output_format_ids`** — このフォーマットが生成できる具体的な出力フォーマット

これらのフィルターは AND で組み合わされます。フォーマットは指定したすべてのフィルターに一致しなければなりません。各フィルター内でのマッチングは OR（配列内のいずれかの ID が一致）です。ディメンションパラメーターなしの裸のフォーマット ID はそのフォーマットのすべてのパラメーター化されたバリアントに一致し、パラメーター化された ID は完全一致です。

注意: `asset_types` とこれらのフィルターは異なるものを対象にしています。クリエイティブマニフェストのみを入力として受け取るフォーマットは `assets` 配列にエントリを持たないため、`asset_types` と `input_format_ids` を組み合わせると通常は結果が返らない。

配信時のダイナミッククリエイティブ（広告配信時にデータフィードからレンダーする DCO プラットフォーム）はこれらのフィールドでは表現されない。それらのプラットフォームは `assets` 経由で入力を、フォーマット自体で出力を記述します。

#### 必要な出力フォーマットが決まっている場合、どんな入力が受け付けられるか？

<CodeGroup>
  ```javascript test=false theme={null}
  import { testAgent } from '@adcp/client/testing';
  import { ListCreativeFormatsResponseSchema } from '@adcp/client';

  // I need portrait video — what can generate it?
  const result = await testAgent.listCreativeFormats({
    output_format_ids: [
      { agent_url: 'https://creative.adcontextprotocol.org', id: 'video_9x16_15s' }
    ]
  });

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

  const validated = ListCreativeFormatsResponseSchema.parse(result.data);
  validated.formats.forEach(format => {
    const inputs = format.input_format_ids?.map(f => f.id) ?? ['(from brief)'];
    console.log(`${format.name} accepts: ${inputs.join(', ')}`);
  });
  ```

  ```python test=false theme={null}
  import asyncio
  from adcp.testing import test_agent
  from adcp.types import ListCreativeFormatsRequest, FormatId

  async def main():
      result = await test_agent.list_creative_formats(
          ListCreativeFormatsRequest(
              output_format_ids=[
                  FormatId(agent_url='https://creative.adcontextprotocol.org', id='video_9x16_15s')
              ]
          )
      )

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

      for fmt in result.formats:
          inputs = [f.id for f in fmt.input_format_ids] if fmt.input_format_ids else ['(from brief)']
          print(f"{fmt.name} accepts: {', '.join(inputs)}")

  asyncio.run(main())
  ```
</CodeGroup>

#### 手持ちの入力フォーマットから、どんな出力を生成できるか？

<CodeGroup>
  ```javascript test=false theme={null}
  import { testAgent } from '@adcp/client/testing';
  import { ListCreativeFormatsResponseSchema } from '@adcp/client';

  // I have a landscape 16:9 video — what can I transform it into?
  const result = await testAgent.listCreativeFormats({
    input_format_ids: [
      { agent_url: 'https://creative.adcontextprotocol.org', id: 'video_16x9_30s' }
    ]
  });

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

  const validated = ListCreativeFormatsResponseSchema.parse(result.data);
  validated.formats.forEach(format => {
    const outputs = format.output_format_ids?.map(f => f.id) ?? [];
    console.log(`${format.name} → ${outputs.join(', ')}`);
  });
  ```

  ```python test=false theme={null}
  import asyncio
  from adcp.testing import test_agent
  from adcp.types import ListCreativeFormatsRequest, FormatId

  async def main():
      result = await test_agent.list_creative_formats(
          ListCreativeFormatsRequest(
              input_format_ids=[
                  FormatId(agent_url='https://creative.adcontextprotocol.org', id='video_16x9_30s')
              ]
          )
      )

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

      for fmt in result.formats:
          outputs = [f.id for f in fmt.output_format_ids] if fmt.output_format_ids else []
          print(f"{fmt.name} → {', '.join(outputs)}")

  asyncio.run(main())
  ```
</CodeGroup>

## フォーマット構造

各フォーマットには次が含まれます。

| Field               | Description                                                                 |
| ------------------- | --------------------------------------------------------------------------- |
| `format_id`         | agent\_url と id を持つ構造化された識別子                                                |
| `name`              | 人が読みやすいフォーマット名                                                              |
| `type`              | *(非推奨)* フォーマット種別（audio、video、display、dooh）。代わりに `asset_types` フィルターを使用すること。 |
| `assets`            | すべてのアセット配列。必須か任意かは `required` ブール値で示す                                       |
| `renders`           | レンダリングされる成果物の配列（寸法、役割）                                                      |
| `input_format_ids`  | このフォーマットが入力マニフェストとして受け付けるクリエイティブフォーマット（生のアセットから機能するフォーマットでは省略）              |
| `output_format_ids` | このフォーマットが生成できる出力フォーマット（単一の固定出力を生成するフォーマットでは省略）                              |

### アセットロール

共通のアセットロールはアセットの用途を把握するのに役立つ。

* **`hero_image`** - メインビジュアル
* **`hero_video`** - メインの動画コンテンツ
* **`logo`** - ブランドロゴ
* **`headline`** - メインテキスト
* **`body_text`** - セカンダリテキスト
* **`call_to_action`** - CTA ボタン文言

## アセットタイプのフィルターロジック

`asset_types` パラメーターは **OR ロジック** で、指定したいずれかのアセットタイプを受け付けるフォーマットが返されます。

**例**: `asset_types: ['html', 'javascript', 'image']`

* html または javascript または image を受け付けるフォーマットが返る
* ユースケース: 「手元のアセットタイプのどれかで使えるフォーマットを知りたい」

**特定の組み合わせを必要とするフォーマットを探す場合** は、取得後に結果をフィルタリングします。

```javascript test=false theme={null}
// 画像とテキストの両方を必要とするフォーマットを探す
const result = await agent.listCreativeFormats();
const imageAndText = result.formats.filter(format => {
  const assetTypes = format.assets.map(a => a.asset_type);
  return assetTypes.includes('image') && assetTypes.includes('text');
});
```

## 複数レンダーフォーマットの寸法フィルタリング

複数の成果物を生成するフォーマット例:

* **コンパニオンバナー付き動画** - メイン動画 (1920×1080) + バナー (300×250)
* **アダプティブディスプレイ** - デスクトップ (728×90) + モバイル (320×50)
* **DOOH 設置** - 寸法が異なる複数画面

寸法フィルターは **少なくとも 1 つのレンダー** が条件に合えば一致します。

```javascript test=false theme={null}
// いずれかのレンダーが 300×250 以下のフォーマットを探す
const result = await agent.listCreativeFormats({
  max_width: 300,
  max_height: 250
});

// 300×250 の枠に収まるレンダーが 1 つでもあれば返される
// より大きいコンパニオンを含む場合もある
```

## 実装上の要件

クリエイティブエージェントで `list_creative_formats` を実装する場合:

1. **権威あるフォーマットを返す** - 定義するフォーマットに関する完全な仕様を含めます
2. **他エージェントを参照する** - `creative_agents` を使って他のクリエイティブエージェントに委譲します
3. **能力を明記する** - validation、assembly、generation、preview などサポートする操作を示します
4. **フィルターをサポートする** - type、asset\_types、寸法などのフィルターパラメーターを実装します

## エラーハンドリング

| Error Code         | Description                | Resolution                              |
| ------------------ | -------------------------- | --------------------------------------- |
| `FORMAT_NOT_FOUND` | リクエストされた format\_id が存在しない | get\_products のレスポンスから format\_id を確認する |
| `INVALID_REQUEST`  | フィルターパラメーターが不正             | パラメーターの型と値を確認する                         |
| `AGENT_NOT_FOUND`  | 参照先のクリエイティブエージェントが利用不可     | 廃止されたエージェント由来のフォーマットの可能性                |

## ベストプラクティス

**1. format\_ids パラメーターを使う**
`get_products` で返されたフォーマット仕様を取得する最も効率的な方法。

**2. フォーマット仕様をキャッシュする**
フォーマット仕様は滅多に変わらないため、format\_id ごとにキャッシュして API 呼び出しを減らす。

**3. タグ系はアセットタイプで検索する**
`asset_types: ['html']` や `['javascript']` を指定してタグを受け付けるフォーマットを探す。

**4. 複数レンダーフォーマットを考慮する**
`renders` 配列の長さを確認し、複数の掲出面が必要かどうかを把握します。

**5. アセット要件を検証する**
クリエイティブを構築する前に、アセットがフォーマット仕様に一致していることを確認します。

## 次のステップ

フォーマットを探索したら:

1. **クリエイティブを構築**: [`build_creative`](/docs/creative/task-reference/build_creative) でアセットをフォーマットに組み立てる
2. **プレビュー**: [`preview_creative`](/docs/creative/task-reference/preview_creative) でビジュアルを確認します
3. **検証**: [`sync_creatives`](/docs/creative/task-reference/sync_creatives) に `dry_run: true` を指定して検証します
4. **アップロード**: [`sync_creatives`](/docs/creative/task-reference/sync_creatives) でエージェントホスト型クリエイティブライブラリにアップロードします

## 参考

* [Format Schema](https://adcontextprotocol.org/schemas/v3/core/format.json) - フォーマット構造の全体像
* [Asset Types](/docs/creative/asset-types) - アセット仕様の詳細
* [Standard Formats](/docs/media-buy/capability-discovery/implementing-standard-formats) - IAB 互換のリファレンスフォーマット