---
title: Content Production
description: "Generate content briefs from your top opportunities and draft full articles — a step-by-step guide through the brief → draft → publish flow."
---

> **For AI agents:** the complete documentation index is at [llms.txt](https://docs.boringmarketing.com/llms.txt). Append `.md` to any page URL for its markdown version.

<Note>
Content production requires a valid API key with available daily calls. Every paid tier (Builder $49/mo, Pro, Agency) can run brief and execute — there is no separate gate beyond the standard tier call limit.
</Note>

This guide walks through the full content chain: pick an opportunity, generate a brief, draft an article, and log the outcome.

## Prerequisites

You need a completed pipeline run with opportunities. If you haven't done that yet, start with the [Quickstart](https://docs.boringmarketing.com/quickstart).

## Step-by-step

<Steps>
  <Step title="Pick from the queue">
    Fetch your action queue — it's pre-sorted by priority:

    ```bash
    curl -s \
      -H "X-API-Key: $BM_API_KEY" \
      "https://api.boringmarketing.com/brands/$BRAND_ID/queue" \
      | python3 -m json.tool
    ```

    ```json
    {
      "brand_id": "brand-uuid",
      "total": 8,
      "queue": [
        {
          "id": "qi-uuid-1",
          "kind": "opportunity",
          "status": "pending",
          "rank": 1,
          "priority": 0.95,
          "item": {
            "play": "AI Marketing Tools Comparison Guide",
            "summary": "High-intent cluster with 12K monthly volume, KD 34",
            "recommended_format": "comparison",
            "family": "Marketing Automation"
          }
        }
      ]
    }
    ```

    Take the `id` of the top item.
  </Step>

  <Step title="Generate a brief">
    ```bash
    curl -s -X POST \
      -H "X-API-Key: $BM_API_KEY" \
      -H "Content-Type: application/json" \
      "https://api.boringmarketing.com/brands/$BRAND_ID/brief" \
      -d '{"queue_item_id": "qi-uuid-1"}'
    ```

    ```json
    {
      "run_id": "brief-run-uuid",
      "status": "queued"
    }
    ```

    Poll the run (brief generation takes 1-3 minutes):

    ```bash
    curl -s \
      -H "X-API-Key: $BM_API_KEY" \
      "https://api.boringmarketing.com/brands/$BRAND_ID/runs/brief-run-uuid"
    ```
  </Step>

  <Step title="Review the brief">
    Once the run completes, fetch the generated brief:

    ```bash
    curl -s \
      -H "X-API-Key: $BM_API_KEY" \
      "https://api.boringmarketing.com/brands/$BRAND_ID/briefs" \
      | python3 -m json.tool
    ```

    The brief includes:
    - **Strategy** — competitive angle, positioning, target audience
    - **Pages** — structured outline with H2/H3 hierarchy, section guidance, word counts
    - **Internal links** — recommended links to existing brand content
    - **Key entities** — people, tools, and concepts to reference
    - **Brand context** — your trust signals, terminology, and voice injected into the brief

    <Tip>
    Review the brief before drafting. The draft follows it closely — fixing the brief is faster than fixing the draft.
    </Tip>
  </Step>

  <Step title="Draft the article">
    Take the `brief_id` from the previous step and request a full draft:

    ```bash
    curl -s -X POST \
      -H "X-API-Key: $BM_API_KEY" \
      -H "Content-Type: application/json" \
      "https://api.boringmarketing.com/brands/$BRAND_ID/execute" \
      -d '{"brief_id": "brief-uuid"}'
    ```

    ```json
    {
      "run_id": "exec-run-uuid",
      "status": "queued"
    }
    ```

    Draft generation takes 3-8 minutes (Opus produces long-form content).
  </Step>

  <Step title="Get the draft">
    First list executions to find the `execution_id` (the execute endpoint returns a `run_id`, but drafts are stored and fetched by `execution_id`, which is a separate identifier):

    ```bash
    curl -s \
      -H "X-API-Key: $BM_API_KEY" \
      "https://api.boringmarketing.com/brands/$BRAND_ID/executions" \
      | python3 -m json.tool
    ```

    Then fetch the specific execution:

    ```bash
    curl -s \
      -H "X-API-Key: $BM_API_KEY" \
      "https://api.boringmarketing.com/brands/$BRAND_ID/executions/$EXECUTION_ID" \
      | python3 -m json.tool
    ```

    The article content lives in the `content` field — an opaque JSON blob whose shape mirrors the current content agent (typically `title`, `body`, `word_count`). The response also includes `format` and the `run_id` that produced this execution. Note `status` is always `"draft"` and `gate_scores` is always `null` in the current implementation — to know whether the execution finished, poll the `run_id`, not the execution row.
  </Step>

  <Step title="Log the outcome">
    After publishing, tell the API so the learning loop can track performance:

    ```bash
    curl -s -X POST \
      -H "X-API-Key: $BM_API_KEY" \
      -H "Content-Type: application/json" \
      "https://api.boringmarketing.com/track/outcomes/report" \
      -d '{
        "brand_id": "'$BRAND_ID'",
        "recommendation_id": "opp-uuid-1",
        "brief_id": "brief-uuid",
        "event_type": "completed",
        "url": "https://yourdomain.com/article",
        "notes": "Shipped after a single review pass"
      }'
    ```

    Also capture a baseline snapshot so later diffs can show what changed:

    ```bash
    curl -s -X POST \
      -H "X-API-Key: $BM_API_KEY" \
      "https://api.boringmarketing.com/track/brands/$BRAND_ID/snapshot"
    ```

    See [Tracking Outcomes](https://docs.boringmarketing.com/guides/tracking-outcomes) for the full snapshot + changes + outcome-report workflow.
  </Step>
</Steps>

## Batch production

For producing multiple articles, repeat steps 2-5 for each queue item. A future `POST /brands/{id}/brief/batch` endpoint will handle bulk brief generation — for now, iterate through queue items sequentially.

<Card title="Track your published content" icon="chart-line" href="/guides/tracking-outcomes">
  Set up outcome tracking and read performance reports.
</Card>