# Measure Off-Amazon Conversions in Amazon AMC

Canonical page: https://www.kuudo.com/guides/amc-off-amazon-conversion-events-manager/

Measure off-Amazon conversions in Amazon Marketing Cloud using Events Manager signals, DSP delivery, and separate purchase and non-purchase values.

Author: Thomas Spicer
Updated: Oct 19, 2026

## Summary

Events sent through Amazon Ad Tag, Conversions API, or a Mobile Measurement Partner reach AMC only after the event is defined in Amazon DSP and associated with a DSP order. Use off_amazon_product_sales for purchase revenue and off_amazon_conversion_value for advertiser-defined, unitless non-purchase value; combined_sales is total_product_sales plus off_amazon_product_sales and excludes non-purchase value. Treat Events Manager dimensions and metrics as complete from 10/20/2023 onward.

Amazon Marketing Cloud (AMC) measures off-Amazon conversions only after Events Manager signals are configured, associated with the relevant DSP order, and available in the analysis instance. This workflow joins delivery to web, app, store, or offline outcomes, keeps purchase sales separate from non-purchase value, and returns a grounded total-impact query for repeatable reporting.

Yes, [Amazon Marketing Cloud](/features/amc/) (AMC) can measure DTC web, app, store, and offline conversions once Events Manager receives them through Amazon Ad Tag (AAT), Conversions API (CAPI), or a Mobile Measurement Partner (MMP), the event is defined in the Amazon demand-side platform (DSP), and it is associated with a DSP order.

The practical difference from Amazon conversions is the setup and taxonomy: off-Amazon subtypes arrive as numeric codes, purchase sales and non-purchase value mean different things, and the complete history starts on October 20, 2023. I handed the question to our agent through the [Amazon Ads MCP](/features/amazon-ads-mcp/), grounded by [Amazon Agent Atlas](/features/agent-atlas/), and asked it to prove each gate before running AMC SQL.

| Question | Answer |
| --- | --- |
| Can AMC read DTC events? | Yes, through Events Manager |
| Required ingestion | AAT, CAPI, or MMP |
| Required DSP setup | Define event; link DSP order |
| Purchase revenue | `off_amazon_product_sales` |
| Non-purchase value | `off_amazon_conversion_value` |
| Total product sales | `combined_sales` |
| Complete history | `10/20/2023` onward |

[ChatGPT, Claude, Perplexity, Microsoft Copilot, and whatever comes next](/features/ai-clients/) know nothing about your business out of the box. Your competitors use those tools too. Kuudo gives those same tools your edge: **your data**, **your rules**, and **the way your business operates**. That means **your account as it is right now**, **your judgment running every time**, and **your call before anything changes**.

The [Amazon Ads MCP](/features/amazon-ads-mcp/) reads and tests against your authorized instance, [Skills](/features/skills/) preserve the rules your team expects, [Amazon Agent Atlas](/features/agent-atlas/) supplies Amazon-specific guidance, and approval controls keep activation and other consequential changes with you.

## Events Manager data reaches AMC only after the event is linked to a DSP order

Sending an event to Amazon DSP is necessary but not sufficient. The **Introduction to Events Manager** instructional query names three prerequisites: set up AAT, CAPI, or MMP; define the event in Amazon DSP; and associate that event with an Amazon DSP order. If the order association is missing, the data does not flow into AMC. The empty result can look like zero customer activity even though the failure is configuration.

The agent therefore runs a preflight before SQL. It checks the ingestion source, event definition, order association, AMC instance, and requested start date, then returns a pass or a named setup failure. That sequence also keeps the claim precise: Events Manager covers off-Amazon web, offline, and app events used for attribution, reporting, optimization, and targeting, but the event must pass the DSP setup gate first.

All Events Manager signals are available in AMC whether ad-exposed or not, and the playbook says the paid `conversions_all` subscription is not required to query non-ad-exposed Events Manager signals. That makes non-ad-exposed analysis possible without making it causal proof. It is a comparison and audience-discovery input, not evidence that advertising created an outcome in a user who was never exposed.

> **The AI is shared. The moat is yours.**
> - **Your account, as it is right now.** The shared AI cannot see whether the event definition is actually linked to the order. You would have to inspect DSP yourself and paste the result back into chat.
> - **Your judgment, running every time.** The shared AI can write plausible AMC SQL while omitting the order-association gate. The query then returns no rows, and the setup failure is mistaken for zero conversions.
> - **Your call, before anything changes.** Plain chat cannot run the preflight or execute the AMC workflow. The Amazon Ads MCP can perform those account-bound checks through an authorized connection.

## Purchase sales and non-purchase conversion value are different measurements

`off_amazon_product_sales` is monetary sales from off-Amazon purchases. `off_amazon_conversion_value` is an advertiser-defined, unitless value for non-purchase events such as a page view, app install, lead, or form submission. Do not add the second field to revenue or use it in return on ad spend (ROAS) unless the advertiser has explicitly documented a monetary scoring convention outside the schema.

Events Manager also represents off-Amazon `conversion_event_subtype` values as numeric codes. The retrieved mapping is:

| Event | Code | Monetary |
| --- | ---: | --- |
| Subscribe | `5` | No |
| Application | `7` | No |
| Sign-up | `21` | No |
| App first start | `37` | No |
| Add to cart | `53` | No |
| Off-Amazon purchase | `54` | Yes |
| Other | `133` | No |
| Page view | `134` | No |
| Search | `135` | No |
| Contact | `136` | No |
| Checkout | `140` | No |
| Lead | `141` | No |

The event formerly labeled **Product purchased** is now **Off-Amazon purchase**. The Skill keeps the mapping versioned and leaves an unknown code visible instead of coercing it to a familiar label. That is safer than silently converting an unrecognized future subtype into revenue.

> **The AI is shared. The moat is yours.**
> - **Your judgment, running every time.** The shared AI may compare the subtype to `purchase` or `add_to_cart`, but Events Manager sends the numeric codes `54` and `53` for those off-Amazon events.
> - **Your judgment, running every time.** The shared AI may call every configured value revenue or reuse the old Product purchased label. That inflates ROAS and hides a renamed event.
> - **Your account, as it is right now.** Plain chat cannot see the advertiser-defined event names or determine whether an unknown subtype has entered the instance. The agent checks the returned taxonomy before labeling the output.

## The canonical Total Impact query joins campaign delivery to conversion outcomes

Amazon's canonical **Total Impact Analysis** query from **Introduction to Events Manager** joins campaign cost, impressions, and unique reach from `dsp_impressions` to Amazon and off-Amazon outcomes from `amazon_attributed_events_by_traffic_time`. It keeps purchase sales, non-purchase value, combined sales, and conversion counts separate, then calculates Amazon and off-Amazon ROAS from the corresponding monetary sales fields. Set the workflow's date range in the AMC query editor to October 20, 2023 or later before running it.

```sql
-- Instructional Query: How to query Events Manager Signals - Total Impact Analysis --
-- AD PRODUCTS: Amazon DSP
/*
 ------- Customization Instructions -------
 1) Set the "Date range" in the Query Editor to define the time range.
 1a) It is recommended to query events after 10/20/2023, as events before this date may be missing dimensions and metrics.
 */
-- Gather campaign cost and impression data
WITH traffic AS (
  SELECT
    campaign_id_string,
    campaign,
    SUM(impressions) AS impressions,
    SUM(total_cost / 100000) AS total_cost,
    COUNT(DISTINCT user_id) AS unique_reach
  FROM
    dsp_impressions
  WHERE
    user_id IS NOT NULL
  GROUP BY
    1,
    2
),
-- Gather Amazon and off-Amazon (Events Manager events) conversion data
conversions AS (
  SELECT
    campaign_id_string,
    conversion_event_source_name,
    conversion_event_name,
    conversion_event_category,
    CASE
      conversion_event_subtype
      WHEN 53 THEN 'Add to shopping cart'
      WHEN 7 THEN 'Application'
      WHEN 140 THEN 'Checkout'
      WHEN 136 THEN 'Contact'
      WHEN 141 THEN 'Lead'
      WHEN 54 THEN 'Off-Amazon purchase'
      WHEN 133 THEN 'Other'
      WHEN 134 THEN 'Page View'
      WHEN 135 THEN 'Search'
      WHEN 21 THEN 'Sign-up'
      WHEN 5 THEN 'Subscribe'
      ELSE conversion_event_subtype
    END amazon_conversion_event,
    SUM(off_amazon_conversion_value) AS off_amazon_conversion_value,
    SUM(off_amazon_product_sales) AS off_amazon_product_sales,
    SUM(conversions) AS conversions,
    SUM(total_product_sales) AS total_product_sales,
    SUM(total_purchases) AS total_purchases,
    SUM(combined_sales) AS combined_sales
  FROM
    amazon_attributed_events_by_traffic_time
  GROUP BY
    1,
    2,
    3,
    4,
    5
) -- Join cost and impressions with conversions
SELECT
  t.campaign,
  c.conversion_event_category,
  c.conversion_event_source_name,
  c.conversion_event_name,
  c.amazon_conversion_event,
  SUM(t.impressions) AS impressions,
  SUM(t.total_cost) AS total_cost,
  SUM(t.unique_reach) AS unique_reach,
  SUM(COALESCE(c.off_amazon_conversion_value, 0)) AS off_amazon_conversion_value,
  SUM(COALESCE(c.off_amazon_product_sales, 0)) AS off_amazon_product_sales,
  SUM(COALESCE(c.conversions, 0)) AS conversions,
  SUM(COALESCE(c.total_product_sales, 0)) AS total_product_sales,
  SUM(COALESCE(c.total_purchases, 0)) AS total_purchases,
  SUM(COALESCE(c.combined_sales, 0)) AS combined_sales,
  CASE
    WHEN SUM(t.total_cost) > 0 THEN SUM(COALESCE(c.total_product_sales, 0)) / SUM(t.total_cost)
    ELSE 0
  END AS amazon_roas,
  CASE
    WHEN SUM(t.total_cost) > 0 THEN SUM(COALESCE(c.off_amazon_product_sales, 0)) / SUM(t.total_cost)
    ELSE 0
  END AS off_amazon_roas
FROM
  traffic t
  LEFT JOIN conversions c ON t.campaign_id_string = c.campaign_id_string
GROUP BY
  1,
  2,
  3,
  4,
  5
```

The query stays faithful to the retrieved instructional query, including Amazon's `total_cost / 100000` normalization and campaign-ID join. Inspect the returned source names and event definitions before operationalizing it; unknown subtype codes stay visible through the `ELSE` branch instead of being silently relabeled.

`combined_sales` is Amazon `total_product_sales` plus `off_amazon_product_sales`; it does not include the unitless value assigned to non-purchase conversions. The query reports Amazon and off-Amazon ROAS separately, so leads and page views never enter either monetary numerator. A combined-sales return can be derived downstream only after the output grain and cost allocation have been reviewed.

> **The AI is shared. The moat is yours.**
> - **Your account, as it is right now.** The shared AI cannot discover the source names and custom event names in your AMC instance. You would have to run the query, export the result, and paste it back.
> - **Your judgment, running every time.** The shared AI may calculate total impact from Amazon sales alone or add `off_amazon_conversion_value` to the numerator. Both change what ROAS means.
> - **Your call, before anything changes.** Plain chat cannot execute or schedule the AMC workflow. The Amazon Ads MCP runs the canonical query, while the Skill validates returned codes before downstream calculation.

## Events Manager history is complete only from October 20, 2023 onward

Treat October 20, 2023 as the completeness boundary for the named Events Manager dimensions and metrics in `amazon_attributed_events_by_*` and `conversions*` tables. Earlier periods can be missing those fields. A range before the boundary can also omit 30-day ad-unexposed events from `conversions` and `conversions_with_relevance`, so a lower historical count is not safely interpreted as lower customer activity.

The **Off-Amazon Conversions Playbook** carries the result beyond reporting into campaign measurement, segmentation, and separately reviewed audience creation. Examples include users who added to cart off Amazon but did not purchase, converters who were not ad-exposed, and non-ad-exposed purchasers of product A who may be candidates for product B. Those are useful hypotheses. They do not prove incrementality, and measurement SQL does not activate an audience by itself.

AMC only returns aggregated, pseudonymized outputs that meet its aggregation thresholds. The agent keeps the output at campaign and event grain, avoids `SELECT *`, rejects unsafe start dates, and reports suppressed or unknown results instead of turning them into zeros.

> **The AI is shared. The moat is yours.**
> - **Your judgment, running every time.** The shared AI may query the advertiser's full history and interpret missing pre-boundary data as zero. The agent applies the `10/20/2023` guard before execution.
> - **Your account, as it is right now.** The shared AI cannot see whether sparse event groups were suppressed by AMC thresholds or whether the requested window crosses the completeness boundary.
> - **Your call, before anything changes.** Plain chat cannot schedule a corrected run or route a reviewed segment into a separate audience workflow. The Skill can stop the run, explain the guard, and continue only with an approved window.

## What happens next: validate the joined signals before reporting {#what-happens-next}

After the preflight and subtype checks pass, schedule the total-impact analysis as a recurring Skill. Keep Amazon product sales, DTC purchase sales, and non-purchase conversion value in separate output columns; use `combined_sales` for the Amazon-plus-DTC product-sales view; and review any unknown subtype before the run reaches a dashboard or optimization rule.

The complete workflow runs through the [Amazon Agent Data layer](/features/amazon-agent-flow/): the [Amazon Ads MCP](/features/amazon-ads-mcp/) supplies live AMC access, the [Selling Partner MCP](/features/amazon-selling-partner-mcp/) adds catalog or retail context when the decision needs it, [Skills](/features/skills/) make the checks recurring, and Amazon Agent Atlas grounds the taxonomy, date rule, and setup gates. If a segment is worth activating, hand it to a separate reviewed audience workflow rather than making activation an invisible side effect of measurement.

Events Manager turns DTC outcomes into dependable AMC measurement only when ingestion, DSP association, event taxonomy, and revenue semantics are all correct.

### Continue the workflow

*Next, place those captured outcomes inside [the full AMC path across DSP and sponsored ads](/guides/amc-path-to-conversion-sankey/).*


## Frequently asked questions

### Can AMC measure conversions on my DTC website?

Yes. Send the events through Amazon Ad Tag, Conversions API, or a Mobile Measurement Partner, define them in Amazon DSP, and associate them with a DSP order so they flow into AMC.

### Why are my Events Manager conversions missing from AMC?

Check the DSP-order association first. Events sent to Amazon DSP do not flow into AMC when the defined event is not associated with an Amazon DSP order.

### What is the difference between off_amazon_product_sales and off_amazon_conversion_value?

off_amazon_product_sales is monetary sales from off-Amazon purchases. off_amazon_conversion_value is an advertiser-defined, unitless value for non-purchase actions such as visits, installs, and forms.

### What does combined_sales include in AMC?

combined_sales is total_product_sales plus off_amazon_product_sales. It does not include off_amazon_conversion_value.

### Why does conversion_event_subtype contain numbers?

Events Manager represents off-Amazon event subtypes with numeric codes, while on-Amazon subtypes commonly use readable strings. Map the current numeric codes and leave unknown codes visible for review.

### How far back can I query Events Manager signals in AMC?

Treat 10/20/2023 as the completeness boundary. Earlier ranges can miss Events Manager dimensions and metrics, plus 30-day ad-unexposed events in conversions table variants.

### Do I need conversions_all for non-ad-exposed Events Manager events?

No. Amazon's Introduction to Events Manager says non-ad-exposed Events Manager signals can be queried without the conversions_all paid-feature subscription.


## Sources

- [Amazon Marketing Cloud](https://advertising.amazon.com/solutions/products/amazon-marketing-cloud)

- [Import off-Amazon conversions with Conversions API](https://advertising.amazon.com/help/GEDE65PCE2CL5P63)

- [Create an Amazon Ad Tag](https://advertising.amazon.com/help/GLZ54GXQW773A6MG)

- [Import app events](https://advertising.amazon.com/help/GF97FJUFXBDM32P4)

- [Use first-party signals in AMC](https://advertising.amazon.com/help/G9MWJR9CK8PRNUXQ)