Order history data for prospecting campaigns

To optimize prospecting campaigns (which acquire new customers), it is critical that you provide Axon with order history data. This allows Axon to build an accurate model of your existing customers so it can find new, high-value users.

If you are a Shopify user who installed the Shopify Axon app and connected it to your Axon Ads Manager account, you’re ready!

Otherwise, follow the requirements below to upload this data in CSV form.

File upload requirements

• File format: CSV only.
• File size: Maximum file size of 200 MB per file.
• Upload method: You can upload files directly, via a public URL, or via SFTP.
• Multiple files: You can upload multiple files. The data from each new file are added to your existing backfilled data.
• Deduplication: Axon automatically deduplicates orders based on the transaction_id. Axon ignores any data row with a transaction_id that already exists in its system. If rows with duplicate transaction_ids exist in a single file, Axon keeps the one with the earliest event_timestamp and discards the rest.

Field specifications

Your CSV file must include all the required headers listed below.

The column order does not matter, but the header names must match exactly.

Event window: Axon processes only those events that occurred in the past two years. Axon excludes events that are older than two years.

Field	Value required?	Type	Description	Value
country_code	Yes	String	An ISO 3166 country code	US
currency	Yes	String	The currency of the transaction in ISO 4217 format (3-letter code)	USD
email	Yes	String	The customer’s email address. Provide the plaintext email; Axon will hash it on its side.	customer@example.com
event_name	Yes	String	Must be purchase	purchase
event_timestamp	Yes	String	The time the purchase occurred ISO 8601 format (UTC) ISO 8601 format (offset) Unix Timestamp mm/dd/yyyy	2025-11-10T15:30:00Z 2025-11-10T15:30:00+01:00 1459315678 11/10/2025
transaction_id	Yes	String	A unique identifier for the order (e.g., order ID, checkout ID). This is crucial for deduplication.	txn_12345
user_id	Yes	String	Your internal customer ID.	user_abc123
value	Yes	Double	The total value of the transaction. Must be a number greater than or equal to 0. Do not include currency symbols.	99.99
zip	Yes	String	The customer’s zip code. This must be the billing zip code of the transaction. For U.S. zip-codes, only include the first five digits.	12345
phone	No	String	The customer’s phone number. Must include the country code (e.g., +1). Provide the plaintext number; Axon will hash it on its side.	+14155551234

Note

Axon anonymizes personal identifiers (such as email addresses and phone numbers) by hashing them.

If you would prefer to perform your own hashing, do so by carefully following these guidelines:

email

Remove any leading or trailing whitespace. Convert any uppercase characters to lowercase. Then hash via SHA256.

phone

Remove any leading or trailing whitespace. Also remove any leading zeros. Remove any dashes, plus-signs, or other symbols. Convert any letters to their numerical counterparts. Always include the country code (for example, 1 for United States phone numbers). Then hash via SHA256.

For example (for email addresses):

C++

#include <iostream>
#include <string>
#include <iomanip>
#include <sstream>
#include <algorithm>
#include <openssl/sha.h>

std::string normalizeAndHash(const std::string& email) {
  std::string normalized = email;
  normalized.erase(0, normalized.find_first_not_of(" \t\n\r"));
  normalized.erase(normalized.find_last_not_of(" \t\n\r") + 1);
  std::transform(normalized.begin(), normalized.end(), normalized.begin(), ::tolower);

  unsigned char hash[SHA256_DIGEST_LENGTH];
  SHA256((unsigned char*)normalized.c_str(), normalized.size(), hash);

  std::ostringstream oss;
  for (int i = 0; i < SHA256_DIGEST_LENGTH; ++i)
    oss << std::hex << std::setw(2) << std::setfill('0') << (int)hash[i];
  return oss.str();
}

int main() {
  std::cout << normalizeAndHash(" John_Smith@gmail.com") << std::endl;
}

C#

using System;
using System.Text;
using System.Security.Cryptography;

class Program {
  static string NormalizeAndHash(string email) {
    string normalized = email.Trim().ToLower();
    using (SHA256 sha256 = SHA256.Create()) {
      byte[] bytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(normalized));
      StringBuilder sb = new StringBuilder();
      foreach (byte b in bytes)
        sb.Append(b.ToString("x2"));
      return sb.ToString();
    }
  }

  static void Main() {
    Console.WriteLine(NormalizeAndHash(" John_Smith@gmail.com"));
  }
}

Java

import java.security.MessageDigest;
import java.nio.charset.StandardCharsets;

public class HashEmail {
  public static String normalizeAndHash(String email) throws Exception {
    String normalized = email.trim().toLowerCase();
    MessageDigest digest = MessageDigest.getInstance("SHA-256");
    byte[] hash = digest.digest(normalized.getBytes(StandardCharsets.UTF_8));
    StringBuilder hex = new StringBuilder();
    for (byte b : hash) hex.append(String.format("%02x", b));
    return hex.toString();
  }

  public static void main(String[] args) throws Exception {
    System.out.println(normalizeAndHash(" John_Smith@gmail.com"));
  }
}

JavaScript

import { createHash } from "crypto";

function normalizeAndHash(email) {
  const normalized = email.trim().toLowerCase();
  return createHash("sha256").update(normalized).digest("hex");
}

// Example
console.log(normalizeAndHash(" John_Smith@gmail.com"));

Kotlin

import java.security.MessageDigest

fun normalizeAndHash(email: String): String {
  val normalized = email.trim().lowercase()
  val bytes = MessageDigest.getInstance("SHA-256").digest(normalized.toByteArray())
  return bytes.joinToString("") { "%02x".format(it) }
}

fun main() {
  println(normalizeAndHash(" John_Smith@gmail.com"))
}

Python

import hashlib

def normalize_and_hash(email):
  normalized = email.strip().lower()
  return hashlib.sha256(normalized.encode()).hexdigest()

# Example
print(normalize_and_hash(" John_Smith@gmail.com"))

Swift

import Foundation
import CryptoKit

func normalizeAndHash(_ email: String) -> String {
  let normalized = email.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
  let hash = SHA256.hash(data: normalized.data(using: .utf8)!)
  return hash.map { String(format: "%02x", $0) }.joined()
}

print(normalizeAndHash(" John_Smith@gmail.com"))

output

62a14e44f765419d10fea99367361a727c12365e2520f32218d505ed9aa0f62f

Key validation rules

• Headers: The file must contain all the required headers listed above.
• Identifier requirement: Each row must contain a user_id and email. Axon rejects rows that are missing values for those columns.
• Event name: The event_name column must exist and its value must be purchase.
• Transaction value: The value column must contain a non-negative number (≥0).
• Country code: For privacy compliance reasons, Axon does not accept data from the following countries/regions:
  • AX — Åland Islands
  • AD — Andorra
  • AT — Austria
  • BE — Belgium
  • DK — Denmark
  • FO — Faroe Islands
  • FI — Finland
  • FR — France
  • DE — Germany
  • GI — Gibraltar
  • GR — Greece
  • GG — Guernsey
  • IS — Iceland
  • IE — Ireland
  • IM — Isle of Man
  • IT — Italy
  • JE — Jersey
  • LI — Liechtenstein
  • LU — Luxembourg
  • MT — Malta
  • MC — Monaco
  • NL — Netherlands
  • NO — Norway
  • PT — Portugal
  • SM — San Marino
  • ES — Spain
  • SJ — Svalbard & Jan Mayen
  • SE — Sweden
  • CH — Switzerland
  • GB — United Kingdom

Example CSV file

Here is an example of a valid CSV file:

event_name,user_id,phone,email,event_timestamp,value,currency,transaction_id,country_code,zip
purchase,user_abc123,+14155551234,user@example.com,2025-11-10T16:45:00Z,99.99,USD,txn_12345,US,12345
purchase,user_def456,+14155555678,customer@example.com,2025-11-10T16:45:00Z,149.5,USD,txn_67890,US,12345
purchase,user_ghi789,+14155559012,shopper@example.com,2025-11-10T17:20:00Z,75,EUR,txn_11223,US,12345