Manage online click conversions

    You can use the Google Ads API to manage online click conversions in Google Ads. Online click conversions help you track ads that led to sales in the online world, such as through a website.

    Online conversions are tracked using the Google tag , but you can adjust or enhance them using the Google Ads API.

    If you already have the Google tag set up and want to adjust your online conversions, see the conversion adjustments page. If you have the Google tag set up and you want to enhance your online conversions with user-provided data, also known as Enhanced conversions for web , continue reading.

    Enhanced conversions for web

    The following section explains how to enhance online click conversions, also known as Enhanced conversions for web.

    Enhanced conversions for web requires setting up a tag that automatically sends a click identifier, like a GCLID, and an order ID to Google Ads when a user converts. You have the option of setting up enhanced conversions through Google Tag Manager , the Google tag , or the Google Ads API. Using the Google Ads API gives you the advantage of sending first-party conversion data within 24 hours of the conversion event, instead of at the same time. This makes it possible to locate first-party data from a variety of sources, such as a customer database or CRM system.

    How enhanced conversions for web works

    Enhanced conversions for web in the Google Ads API supplements step 3 in the following flow.

    Instead of sending the hashed user information when the user converts, the tag sends just the GCLID and the order ID, and you send hashed user information later by importing the order ID along with the hashed data. To learn more about enhanced conversions for web, see our Help Center .

    Enhanced conversions for web

    Prerequisites

    You must accept the customer data terms before you can use enhanced conversions for web. You can verify whether the customer data terms have been accepted by issuing the following query to the Google Ads conversion customer:

      SELECT 
  
 customer 
 . 
 id 
 , 
  
 customer 
 . 
 conversion_tracking_setting 
 . 
  accepted_customer_data_terms 
 FROM 
  
 customer

    If accepted_customer_data_terms is false , follow the instructions in the Help Center to complete this prerequisite.

    Configure tagging

    You can configure tagging for your website by following the instructions in the Help Center . It is recommended that you also add transaction IDs (order IDs) to your conversion tracking tag to assist with conversion matching.

    API Implementation

    Here is the overall flow for importing enhanced conversions for web in the Google Ads API.

    1. Normalize and hash the user-provided data , such as email address, phone number, and mailing address.

    2. Populate ConversionAdjustment objects with the normalized and hashed user-provided data.

    3. Import the ConversionAdjustment objects to the ConversionAdjustmentUploadService .

    4. Review your imports .

    Normalize and hash user-provided data

    For privacy considerations, the following data must be hashed using SHA-256 before being imported:

    • Email address
    • Phone number
    • First name
    • Last name
    • Street address

    Don't hash the following data:

    • Country
    • State
    • City
    • Zip code

    In order to standardize the hash results, you must do the following prior to hashing one of these values:

    • Remove leading and trailing whitespaces.
    • Convert the text to lowercase.
    • Format phone numbers according to the E164 standard .
    • Remove all periods ( . ) that precede the domain name in gmail.com and googlemail.com email addresses.

    Java

     private 
  
 String 
  
 normalizeAndHash 
 ( 
 MessageDigest 
  
 digest 
 , 
  
 String 
  
 s 
 , 
  
 boolean 
  
 trimIntermediateSpaces 
 ) 
  
 throws 
  
 UnsupportedEncodingException 
  
 { 
  
 // Normalizes by first converting all characters to lowercase, then trimming spaces. 
  
 String 
  
 normalized 
  
 = 
  
 s 
 . 
 toLowerCase 
 (); 
  
 if 
  
 ( 
 trimIntermediateSpaces 
 ) 
  
 { 
  
 // Removes leading, trailing, and intermediate spaces. 
  
 normalized 
  
 = 
  
 normalized 
 . 
 replaceAll 
 ( 
 "\\s+" 
 , 
  
 "" 
 ); 
  
 } 
  
 else 
  
 { 
  
 // Removes only leading and trailing spaces. 
  
 normalized 
  
 = 
  
 normalized 
 . 
 trim 
 (); 
  
 } 
  
 // Hashes the normalized string using the hashing algorithm. 
  
 byte 
 [] 
  
 hash 
  
 = 
  
 digest 
 . 
 digest 
 ( 
 normalized 
 . 
 getBytes 
 ( 
 "UTF-8" 
 )); 
  
 StringBuilder 
  
 result 
  
 = 
  
 new 
  
 StringBuilder 
 (); 
  
 for 
  
 ( 
 byte 
  
 b 
  
 : 
  
 hash 
 ) 
  
 { 
  
 result 
 . 
 append 
 ( 
 String 
 . 
 format 
 ( 
 "%02x" 
 , 
  
 b 
 )); 
  
 } 
  
 return 
  
 result 
 . 
 toString 
 (); 
 } 
 /** 
 * Returns the result of normalizing and hashing an email address. For this use case, Google Ads 
 * requires removal of any '.' characters preceding {@code gmail.com} or {@code googlemail.com}. 
 * 
 * @param digest the digest to use to hash the normalized string. 
 * @param emailAddress the email address to normalize and hash. 
 */ 
 private 
  
 String 
  
 normalizeAndHashEmailAddress 
 ( 
 MessageDigest 
  
 digest 
 , 
  
 String 
  
 emailAddress 
 ) 
  
 throws 
  
 UnsupportedEncodingException 
  
 { 
  
 String 
  
 normalizedEmail 
  
 = 
  
 emailAddress 
 . 
 toLowerCase 
 (); 
  
 String 
 [] 
  
 emailParts 
  
 = 
  
 normalizedEmail 
 . 
 split 
 ( 
 "@" 
 ); 
  
 if 
  
 ( 
 emailParts 
 . 
 length 
 > 
 1 
 && 
 emailParts 
 [ 
 1 
 ] 
 . 
 matches 
 ( 
 "^(gmail|googlemail)\\.com\\s*" 
 )) 
  
 { 
  
 // Removes any '.' characters from the portion of the email address before the domain if the 
  
 // domain is gmail.com or googlemail.com. 
  
 emailParts 
 [ 
 0 
 ] 
  
 = 
  
 emailParts 
 [ 
 0 
 ] 
 . 
 replaceAll 
 ( 
 "\\." 
 , 
  
 "" 
 ); 
  
 normalizedEmail 
  
 = 
  
 String 
 . 
 format 
 ( 
 "%s@%s" 
 , 
  
 emailParts 
 [ 
 0 
 ] 
 , 
  
 emailParts 
 [ 
 1 
 ] 
 ); 
  
 } 
  
 return 
  
 normalizeAndHash 
 ( 
 digest 
 , 
  
 normalizedEmail 
 , 
  
 true 
 ); 
 } 
 
      UploadEnhancedConversionsForWeb 
 . 
 java

    C#

     /// <summary> 
 /// Normalizes the email address and hashes it. For this use case, Google Ads requires 
 /// removal of any '.' characters preceding <code>gmail.com</code> or 
 /// <code>googlemail.com</code>. 
 /// </summary> 
 /// <param name="emailAddress">The email address.</param> 
 /// <returns>The hash code.</returns> 
 private 
  
 string 
  
 NormalizeAndHashEmailAddress 
 ( 
 string 
  
 emailAddress 
 ) 
 { 
  
 string 
  
 normalizedEmail 
  
 = 
  
 emailAddress 
 . 
 ToLower 
 (); 
  
 string 
 [] 
  
 emailParts 
  
 = 
  
 normalizedEmail 
 . 
 Split 
 ( 
 '@' 
 ); 
  
 if 
  
 ( 
 emailParts 
 . 
 Length 
 > 
 1 
 && 
 ( 
 emailParts 
 [ 
 1 
 ] 
  
 == 
  
 "gmail.com" 
  
 || 
  
 emailParts 
 [ 
 1 
 ] 
  
 == 
  
 "googlemail.com" 
 )) 
  
 { 
  
 // Removes any '.' characters from the portion of the email address before 
  
 // the domain if the domain is gmail.com or googlemail.com. 
  
 emailParts 
 [ 
 0 
 ] 
  
 = 
  
 emailParts 
 [ 
 0 
 ]. 
 Replace 
 ( 
 "." 
 , 
  
 "" 
 ); 
  
 normalizedEmail 
  
 = 
  
 $"{emailParts[0]}@{emailParts[1]}" 
 ; 
  
 } 
  
 return 
  
 NormalizeAndHash 
 ( 
 normalizedEmail 
 ); 
 } 
 /// <summary> 
 /// Normalizes and hashes a string value. 
 /// </summary> 
 /// <param name="value">The value to normalize and hash.</param> 
 /// <returns>The normalized and hashed value.</returns> 
 private 
  
 static 
  
 string 
  
 NormalizeAndHash 
 ( 
 string 
  
 value 
 ) 
 { 
  
 return 
  
 ToSha256String 
 ( 
 digest 
 , 
  
 ToNormalizedValue 
 ( 
 value 
 )); 
 } 
 /// <summary> 
 /// Hash a string value using SHA-256 hashing algorithm. 
 /// </summary> 
 /// <param name="digest">Provides the algorithm for SHA-256.</param> 
 /// <param name="value">The string value (e.g. an email address) to hash.</param> 
 /// <returns>The hashed value.</returns> 
 private 
  
 static 
  
 string 
  
 ToSha256String 
 ( 
 SHA256 
  
 digest 
 , 
  
 string 
  
 value 
 ) 
 { 
  
 byte 
 [] 
  
 digestBytes 
  
 = 
  
 digest 
 . 
 ComputeHash 
 ( 
 Encoding 
 . 
 UTF8 
 . 
 GetBytes 
 ( 
 value 
 )); 
  
 // Convert the byte array into an unhyphenated hexadecimal string. 
  
 return 
  
 BitConverter 
 . 
 ToString 
 ( 
 digestBytes 
 ). 
 Replace 
 ( 
 "-" 
 , 
  
 string 
 . 
 Empty 
 ); 
 } 
 /// <summary> 
 /// Removes leading and trailing whitespace and converts all characters to 
 /// lower case. 
 /// </summary> 
 /// <param name="value">The value to normalize.</param> 
 /// <returns>The normalized value.</returns> 
 private 
  
 static 
  
 string 
  
 ToNormalizedValue 
 ( 
 string 
  
 value 
 ) 
 { 
  
 return 
  
 value 
 . 
 Trim 
 (). 
 ToLower 
 (); 
 } 
 
      UploadEnhancedConversionsForWeb 
 . 
 cs

    PHP

     private static function normalizeAndHash( 
 string $hashAlgorithm, 
 string $value, 
 bool $trimIntermediateSpaces 
 ): string { 
 // Normalizes by first converting all characters to lowercase, then trimming spaces. 
 $normalized = strtolower($value); 
 if ($trimIntermediateSpaces === true) { 
 // Removes leading, trailing, and intermediate spaces. 
 $normalized = str_replace(' ', '', $normalized); 
 } else { 
 // Removes only leading and trailing spaces. 
 $normalized = trim($normalized); 
 } 
 return hash($hashAlgorithm, strtolower(trim($normalized))); 
 } 
 /** 
 * Returns the result of normalizing and hashing an email address. For this use case, Google 
 * Ads requires removal of any '.' characters preceding "gmail.com" or "googlemail.com". 
 * 
 * @param string $hashAlgorithm the hash algorithm to use 
 * @param string $emailAddress the email address to normalize and hash 
 * @return string the normalized and hashed email address 
 */ 
 private static function normalizeAndHashEmailAddress( 
 string $hashAlgorithm, 
 string $emailAddress 
 ): string { 
 $normalizedEmail = strtolower($emailAddress); 
 $emailParts = explode("@", $normalizedEmail); 
 if ( 
 count($emailParts) > 1 
 && preg_match('/^(gmail|googlemail)\.com\s*/', $emailParts[1]) 
 ) { 
 // Removes any '.' characters from the portion of the email address before the domain 
 // if the domain is gmail.com or googlemail.com. 
 $emailParts[0] = str_replace(".", "", $emailParts[0]); 
 $normalizedEmail = sprintf('%s@%s', $emailParts[0], $emailParts[1]); 
 } 
 return self::normalizeAndHash($hashAlgorithm, $normalizedEmail, true); 
 } 
     UploadEnhancedConversionsForWeb.php

    Python

     def 
  
 normalize_and_hash_email_address 
 ( 
 email_address 
 ): 
  
 """Returns the result of normalizing and hashing an email address. 
 For this use case, Google Ads requires removal of any '.' characters 
 preceding "gmail.com" or "googlemail.com" 
 Args: 
 email_address: An email address to normalize. 
 Returns: 
 A normalized (lowercase, removed whitespace) and SHA-265 hashed string. 
 """ 
 normalized_email 
 = 
 email_address 
 . 
 strip 
 () 
 . 
 lower 
 () 
 email_parts 
 = 
 normalized_email 
 . 
 split 
 ( 
 "@" 
 ) 
 # Check that there are at least two segments 
 if 
 len 
 ( 
 email_parts 
 ) 
> 1 
 : 
 # Checks whether the domain of the email address is either "gmail.com" 
 # or "googlemail.com". If this regex does not match then this statement 
 # will evaluate to None. 
 if 
 re 
 . 
 match 
 ( 
 r 
 "^(gmail|googlemail)\.com$" 
 , 
 email_parts 
 [ 
 1 
 ]): 
 # Removes any '.' characters from the portion of the email address 
 # before the domain if the domain is gmail.com or googlemail.com. 
 email_parts 
 [ 
 0 
 ] 
 = 
 email_parts 
 [ 
 0 
 ] 
 . 
 replace 
 ( 
 "." 
 , 
 "" 
 ) 
 normalized_email 
 = 
 "@" 
 . 
 join 
 ( 
 email_parts 
 ) 
 return 
 normalize_and_hash 
 ( 
 normalized_email 
 ) 
 def 
  
 normalize_and_hash 
 ( 
 s 
 ): 
  
 """Normalizes and hashes a string with SHA-256. 
 Private customer data must be hashed during upload, as described at: 
 https://support.google.com/google-ads/answer/9888656 
 Args: 
 s: The string to perform this operation on. 
 Returns: 
 A normalized (lowercase, removed whitespace) and SHA-256 hashed string. 
 """ 
 return 
 hashlib 
 . 
 sha256 
 ( 
 s 
 . 
 strip 
 () 
 . 
 lower 
 () 
 . 
 encode 
 ()) 
 . 
 hexdigest 
 () 
 
      upload_enhanced_conversions_for_web 
 . 
 py

    Ruby

     # Returns the result of normalizing and then hashing the string using the 
 # provided digest.  Private customer data must be hashed during upload, as 
 # described at https://support.google.com/google-ads/answer/9888656. 
 def 
  
 normalize_and_hash 
 ( 
 str 
 ) 
  
 # Remove leading and trailing whitespace and ensure all letters are lowercase 
  
 # before hasing. 
  
 Digest 
 :: 
 SHA256 
 . 
 hexdigest 
 ( 
 str 
 . 
 strip 
 . 
 downcase 
 ) 
 end 
 # Returns the result of normalizing and hashing an email address. For this use 
 # case, Google Ads requires removal of any '.' characters preceding 'gmail.com' 
 # or 'googlemail.com'. 
 def 
  
 normalize_and_hash_email 
 ( 
 email 
 ) 
  
 email_parts 
  
 = 
  
 email 
 . 
 downcase 
 . 
 split 
 ( 
 "@" 
 ) 
  
 # Removes any '.' characters from the portion of the email address before the 
  
 # domain if the domain is gmail.com or googlemail.com. 
  
 if 
  
 email_parts 
 . 
 last 
  
 =~ 
 /^(gmail|googlemail)\.com\s*/ 
  
 email_parts 
 [ 
 0 
 ] 
  
 = 
  
 email_parts 
 [ 
 0 
 ]. 
 gsub 
 ( 
 '.' 
 , 
  
 '' 
 ) 
  
 end 
  
 normalize_and_hash 
 ( 
 email_parts 
 . 
 join 
 ( 
 '@' 
 )) 
 end 
     upload_enhanced_conversions_for_web 

     
     
 . 
 rb

    Perl

     sub 
  
 normalize_and_hash 
  
 { 
  
 my 
  
 $value 
  
 = 
  
 shift 
 ; 
  
 my 
  
 $trim_intermediate_spaces 
  
 = 
  
 shift 
 ; 
  
 if 
  
 ( 
 $trim_intermediate_spaces 
 ) 
  
 { 
  
 $value 
  
 =~ 
  
 s/\s+//g 
 ; 
  
 } 
  
 else 
  
 { 
  
 $value 
  
 =~ 
  
 s/^\s+|\s+$//g 
 ; 
  
 } 
  
 return 
  
 sha256_hex 
 ( 
 lc 
  
 $value 
 ); 
 } 
 # Returns the result of normalizing and hashing an email address. For this use 
 # case, Google Ads requires removal of any '.' characters preceding 'gmail.com' 
 # or 'googlemail.com'. 
 sub 
  
 normalize_and_hash_email_address 
  
 { 
  
 my 
  
 $email_address 
  
 = 
  
 shift 
 ; 
  
 my 
  
 $normalized_email 
  
 = 
  
 lc 
  
 $email_address 
 ; 
  
 my 
  
 @email_parts 
  
 = 
  
 split 
 ( 
 '@' 
 , 
  
 $normalized_email 
 ); 
  
 if 
  
 ( 
 scalar 
  
 @email_parts 
 > 
 1 
 && 
 $email_parts 
 [ 
 1 
 ] 
  
 =~ 
 /^(gmail|googlemail)\.com\s*/ 
 ) 
  
 { 
  
 # Remove any '.' characters from the portion of the email address before the 
  
 # domain if the domain is 'gmail.com' or 'googlemail.com'. 
  
 $email_parts 
 [ 
 0 
 ] 
  
 =~ 
  
 s/\.//g 
 ; 
  
 $normalized_email 
  
 = 
  
 sprintf 
  
 '%s@%s' 
 , 
  
 $email_parts 
 [ 
 0 
 ], 
  
 $email_parts 
 [ 
 1 
 ]; 
  
 } 
  
 return 
  
 normalize_and_hash 
 ( 
 $normalized_email 
 , 
  
 1 
 ); 
 } 
 
      upload_enhanced_conversions_for_web 
 . 
 pl

    Populate ConversionAdjustment objects

    The following section demonstrates how to construct an enhancement adjustment that contains an order ID, plus identifiers for email address, phone number, and physical address, with standardization and hashing applied as required. As a best practice, include gclid on the adjustment if it's available.

    This step is nearly identical to the Import Conversion Adjustments guide, with a few caveats:

    • Populate user_identifiers with the normalized and hashed user data. If you have multiple user identifiers available, create a separate UserIdentifier for each one, up to five identifiers.

    Java

     // Creates a builder for constructing the enhancement adjustment. 
 ConversionAdjustment 
 . 
 Builder 
  
 enhancementBuilder 
  
 = 
  
 ConversionAdjustment 
 . 
 newBuilder 
 (). 
 setAdjustmentType 
 ( 
 ConversionAdjustmentType 
 . 
 ENHANCEMENT 
 ); 
 // Extracts user email, phone, and address info from the raw data, normalizes and hashes it, 
 // then wraps it in UserIdentifier objects. 
 // Creates a separate UserIdentifier object for each. The data in this example is hardcoded, but 
 // in your application you might read the raw data from an input file. 
 // IMPORTANT: Since the identifier attribute of UserIdentifier 
 // (https://developers.google.com/google-ads/api/reference/rpc/latest/UserIdentifier) is a 
 // oneof 
 // (https://protobuf.dev/programming-guides/proto3/#oneof-features), you must set only ONE of 
 // hashedEmail, hashedPhoneNumber, mobileId, thirdPartyUserId, or addressInfo. Setting more 
 // than one of these attributes on the same UserIdentifier will clear all the other members 
 // of the oneof. For example, the following code is INCORRECT and will result in a 
 // UserIdentifier with ONLY a hashedPhoneNumber. 
 // 
 // UserIdentifier incorrectlyPopulatedUserIdentifier = 
 //     UserIdentifier.newBuilder() 
 //         .setHashedEmail("...") 
 //         .setHashedPhoneNumber("...") 
 //         .build(); 
 ImmutableMap 
 . 
 Builder<String 
 , 
  
 String 
>  
 rawRecordBuilder 
  
 = 
  
 ImmutableMap 
 . 
< String 
 , 
  
 String>builder 
 () 
  
 . 
 put 
 ( 
 "email" 
 , 
  
 "alex.2@example.com" 
 ) 
  
 // Email address that includes a period (.) before the Gmail domain. 
  
 . 
 put 
 ( 
 "email" 
 , 
  
 "alex.2@example.com" 
 ) 
  
 // Address that includes all four required elements: first name, last name, country 
  
 // code, and postal code. 
  
 . 
 put 
 ( 
 "firstName" 
 , 
  
 "Alex" 
 ) 
  
 . 
 put 
 ( 
 "lastName" 
 , 
  
 "Quinn" 
 ) 
  
 . 
 put 
 ( 
 "countryCode" 
 , 
  
 "US" 
 ) 
  
 . 
 put 
 ( 
 "postalCode" 
 , 
  
 "94045" 
 ) 
  
 // Phone number to be converted to E.164 format, with a leading '+' as required. 
  
 . 
 put 
 ( 
 "phone" 
 , 
  
 "+1 800 5550102" 
 ) 
  
 // This example lets you put conversion details as arguments, but in reality you might 
  
 // store this data alongside other user data, so we include it in this sample user 
  
 // record. 
  
 . 
 put 
 ( 
 "orderId" 
 , 
  
 orderId 
 ) 
  
 . 
 put 
 ( 
 "conversionActionId" 
 , 
  
 Long 
 . 
 toString 
 ( 
 conversionActionId 
 )) 
  
 . 
 put 
 ( 
 "currencyCode" 
 , 
  
 "USD" 
 ); 
 // Adds entries for the optional fields. 
 if 
  
 ( 
 conversionDateTime 
  
 != 
  
 null 
 ) 
  
 { 
  
 rawRecordBuilder 
 . 
 put 
 ( 
 "conversionDateTime" 
 , 
  
 conversionDateTime 
 ); 
 } 
 if 
  
 ( 
 userAgent 
  
 != 
  
 null 
 ) 
  
 { 
  
 rawRecordBuilder 
 . 
 put 
 ( 
 "userAgent" 
 , 
  
 userAgent 
 ); 
 } 
 // Builds the map representing the record. 
 Map<String 
 , 
  
 String 
>  
 rawRecord 
  
 = 
  
 rawRecordBuilder 
 . 
 build 
 (); 
 // Creates a SHA256 message digest for hashing user identifiers in a privacy-safe way, as 
 // described at https://support.google.com/google-ads/answer/9888656. 
 MessageDigest 
  
 sha256Digest 
  
 = 
  
 MessageDigest 
 . 
 getInstance 
 ( 
 "SHA-256" 
 ); 
 // Creates a list for the user identifiers. 
 List<UserIdentifier> 
  
 userIdentifiers 
  
 = 
  
 new 
  
 ArrayList 
<> (); 
 // Creates a user identifier using the hashed email address, using the normalize and hash method 
 // specifically for email addresses. 
 UserIdentifier 
  
 emailIdentifier 
  
 = 
  
 UserIdentifier 
 . 
 newBuilder 
 () 
  
 // Optional: specify the user identifier source. 
  
 . 
 setUserIdentifierSource 
 ( 
 UserIdentifierSource 
 . 
 FIRST_PARTY 
 ) 
  
 // Uses the normalize and hash method specifically for email addresses. 
  
 . 
 setHashedEmail 
 ( 
 normalizeAndHashEmailAddress 
 ( 
 sha256Digest 
 , 
  
 rawRecord 
 . 
 get 
 ( 
 "email" 
 ))) 
  
 . 
 build 
 (); 
 userIdentifiers 
 . 
 add 
 ( 
 emailIdentifier 
 ); 
 // Checks if the record has a phone number, and if so, adds a UserIdentifier for it. 
 if 
  
 ( 
 rawRecord 
 . 
 containsKey 
 ( 
 "phone" 
 )) 
  
 { 
  
 UserIdentifier 
  
 hashedPhoneNumberIdentifier 
  
 = 
  
 UserIdentifier 
 . 
 newBuilder 
 () 
  
 . 
 setHashedPhoneNumber 
 ( 
 normalizeAndHash 
 ( 
 sha256Digest 
 , 
  
 rawRecord 
 . 
 get 
 ( 
 "phone" 
 ), 
  
 true 
 )) 
  
 . 
 build 
 (); 
  
 // Adds the hashed phone number identifier to the UserData object's list. 
  
 userIdentifiers 
 . 
 add 
 ( 
 hashedPhoneNumberIdentifier 
 ); 
 } 
 // Checks if the record has all the required mailing address elements, and if so, adds a 
 // UserIdentifier for the mailing address. 
 if 
  
 ( 
 rawRecord 
 . 
 containsKey 
 ( 
 "firstName" 
 )) 
  
 { 
  
 // Checks if the record contains all the other required elements of a mailing address. 
  
 Set<String> 
  
 missingAddressKeys 
  
 = 
  
 new 
  
 HashSet 
<> (); 
  
 for 
  
 ( 
 String 
  
 addressKey 
  
 : 
  
 new 
  
 String 
 [] 
  
 { 
 "lastName" 
 , 
  
 "countryCode" 
 , 
  
 "postalCode" 
 }) 
  
 { 
  
 if 
  
 ( 
 ! 
 rawRecord 
 . 
 containsKey 
 ( 
 addressKey 
 )) 
  
 { 
  
 missingAddressKeys 
 . 
 add 
 ( 
 addressKey 
 ); 
  
 } 
  
 } 
  
 if 
  
 ( 
 ! 
 missingAddressKeys 
 . 
 isEmpty 
 ()) 
  
 { 
  
 System 
 . 
 out 
 . 
 printf 
 ( 
  
 "Skipping addition of mailing address information because the following required keys" 
  
 + 
  
 " are missing: %s%n" 
 , 
  
 missingAddressKeys 
 ); 
  
 } 
  
 else 
  
 { 
  
 // Creates an OfflineUserAddressInfo object that contains all the required elements of a 
  
 // mailing address. 
  
 OfflineUserAddressInfo 
  
 addressInfo 
  
 = 
  
 OfflineUserAddressInfo 
 . 
 newBuilder 
 () 
  
 . 
 setHashedFirstName 
 ( 
  
 normalizeAndHash 
 ( 
 sha256Digest 
 , 
  
 rawRecord 
 . 
 get 
 ( 
 "firstName" 
 ), 
  
 false 
 )) 
  
 . 
 setHashedLastName 
 ( 
 normalizeAndHash 
 ( 
 sha256Digest 
 , 
  
 rawRecord 
 . 
 get 
 ( 
 "lastName" 
 ), 
  
 false 
 )) 
  
 . 
 setCountryCode 
 ( 
 rawRecord 
 . 
 get 
 ( 
 "countryCode" 
 )) 
  
 . 
 setPostalCode 
 ( 
 rawRecord 
 . 
 get 
 ( 
 "postalCode" 
 )) 
  
 . 
 build 
 (); 
  
 UserIdentifier 
  
 addressIdentifier 
  
 = 
  
 UserIdentifier 
 . 
 newBuilder 
 (). 
 setAddressInfo 
 ( 
 addressInfo 
 ). 
 build 
 (); 
  
 // Adds the address identifier to the UserData object's list. 
  
 userIdentifiers 
 . 
 add 
 ( 
 addressIdentifier 
 ); 
  
 } 
 } 
 // Adds the user identifiers to the enhancement adjustment. 
 enhancementBuilder 
 . 
 addAllUserIdentifiers 
 ( 
 userIdentifiers 
 ); 
 
      UploadEnhancedConversionsForWeb 
 . 
 java

    C#

     // Normalize and hash the raw data, then wrap it in UserIdentifier objects. 
 // Create a separate UserIdentifier object for each. The data in this example is 
 // hardcoded, but in your application you might read the raw data from an input file. 
 // 
 // IMPORTANT: Since the identifier attribute of UserIdentifier 
 // (https://developers.google.com/google-ads/api/reference/rpc/latest/UserIdentifier) 
 // is a oneof 
 // (https://protobuf.dev/programming-guides/proto3/#oneof-features), you must set 
 // only ONE of hashed_email, hashed_phone_number, mobile_id, third_party_user_id, 
 // or address-info. Setting more than one of these attributes on the same UserIdentifier 
 // will clear all the other members of the oneof. For example, the following code is 
 // INCORRECT and will result in a UserIdentifier with ONLY a hashed_phone_number: 
 // UserIdentifier incorrectlyPopulatedUserIdentifier = new UserIdentifier() 
 // { 
 //         HashedEmail = "..." 
 //         HashedPhoneNumber = "..." 
 // } 
 UserIdentifier 
  
 addressIdentifier 
  
 = 
  
 new 
  
 UserIdentifier 
 () 
 { 
  
 AddressInfo 
  
 = 
  
 new 
  
 OfflineUserAddressInfo 
 () 
  
 { 
  
 HashedFirstName 
  
 = 
  
 NormalizeAndHash 
 ( 
 "Dana" 
 ), 
  
 HashedLastName 
  
 = 
  
 NormalizeAndHash 
 ( 
 "Quinn" 
 ), 
  
 HashedStreetAddress 
  
 = 
  
 NormalizeAndHash 
 ( 
 "1600 Amphitheatre Pkwy" 
 ), 
  
 City 
  
 = 
  
 "Mountain View" 
 , 
  
 State 
  
 = 
  
 "CA" 
 , 
  
 PostalCode 
  
 = 
  
 "94043" 
 , 
  
 CountryCode 
  
 = 
  
 "US" 
  
 }, 
  
 // Optional: Specifies the user identifier source. 
  
 UserIdentifierSource 
  
 = 
  
 UserIdentifierSource 
 . 
 FirstParty 
 }; 
 // Creates a user identifier using the hashed email address. 
 UserIdentifier 
  
 emailIdentifier 
  
 = 
  
 new 
  
 UserIdentifier 
 () 
 { 
  
 UserIdentifierSource 
  
 = 
  
 UserIdentifierSource 
 . 
 FirstParty 
 , 
  
 // Uses the normalize and hash method specifically for email addresses. 
  
 HashedEmail 
  
 = 
  
 NormalizeAndHashEmailAddress 
 ( 
 "dana@example.com" 
 ) 
 }; 
 // Adds the user identifiers to the enhancement adjustment. 
 enhancement 
 . 
 UserIdentifiers 
 . 
 AddRange 
 ( 
 new 
 [] 
  
 { 
  
 addressIdentifier 
 , 
  
 emailIdentifier 
  
 }); 
 
      UploadEnhancedConversionsForWeb 
 . 
 cs

    PHP

     // Creates the conversion enhancement. 
 $enhancement = 
 new ConversionAdjustment(['adjustment_type' => ConversionAdjustmentType::ENHANCEMENT]); 
 // Extracts user email, phone, and address info from the raw data, normalizes and hashes it, 
 // then wraps it in UserIdentifier objects. 
 // Creates a separate UserIdentifier object for each. The data in this example is hardcoded, 
 // but in your application you might read the raw data from an input file. 
 // IMPORTANT: Since the identifier attribute of UserIdentifier 
 // (https://developers.google.com/google-ads/api/reference/rpc/latest/UserIdentifier) is a 
 // oneof 
 // (https://protobuf.dev/programming-guides/proto3/#oneof-features), you must set only ONE 
 // of hashedEmail, hashedPhoneNumber, mobileId, thirdPartyUserId, or addressInfo. Setting 
 // more than one of these attributes on the same UserIdentifier will clear all the other 
 // members of the oneof. For example, the following code is INCORRECT and will result in a 
 // UserIdentifier with ONLY a hashedPhoneNumber. 
 // 
 // $incorrectlyPopulatedUserIdentifier = new UserIdentifier([ 
 //    'hashed_email' => '...', 
 //    'hashed_phone_number' => '...' 
 // ]); 
 $rawRecord = [ 
 // Email address that includes a period (.) before the Gmail domain. 
 'email' => 'alex.2@example.com', 
 // Address that includes all four required elements: first name, last name, country 
 // code, and postal code. 
 'firstName' => 'Alex', 
 'lastName' => 'Quinn', 
 'countryCode' => 'US', 
 'postalCode' => '94045', 
 // Phone number to be converted to E.164 format, with a leading '+' as required. 
 'phone' => '+1 800 5550102', 
 // This example lets you input conversion details as arguments, but in reality you might 
 // store this data alongside other user data, so we include it in this sample user 
 // record. 
 'orderId' => $orderId, 
 'conversionActionId' => $conversionActionId, 
 'conversionDateTime' => $conversionDateTime, 
 'currencyCode' => 'USD' 
 ]; 
 // Creates a list for the user identifiers. 
 $userIdentifiers = []; 
 // Uses the SHA-256 hash algorithm for hashing user identifiers in a privacy-safe way, as 
 // described at https://support.google.com/google-ads/answer/9888656. 
 $hashAlgorithm = "sha256"; 
 // Creates a user identifier using the hashed email address, using the normalize and hash 
 // method specifically for email addresses. 
 $emailIdentifier = new UserIdentifier([ 
 // Uses the normalize and hash method specifically for email addresses. 
 'hashed_email' => self::normalizeAndHashEmailAddress( 
 $hashAlgorithm, 
 $rawRecord['email'] 
 ), 
 // Optional: Specifies the user identifier source. 
 'user_identifier_source' => UserIdentifierSource::FIRST_PARTY 
 ]); 
 $userIdentifiers[] = $emailIdentifier; 
 // Checks if the record has a phone number, and if so, adds a UserIdentifier for it. 
 if (array_key_exists('phone', $rawRecord)) { 
 $hashedPhoneNumberIdentifier = new UserIdentifier([ 
 'hashed_phone_number' => self::normalizeAndHash( 
 $hashAlgorithm, 
 $rawRecord['phone'], 
 true 
 ) 
 ]); 
 // Adds the hashed email identifier to the user identifiers list. 
 $userIdentifiers[] = $hashedPhoneNumberIdentifier; 
 } 
 // Checks if the record has all the required mailing address elements, and if so, adds a 
 // UserIdentifier for the mailing address. 
 if (array_key_exists('firstName', $rawRecord)) { 
 // Checks if the record contains all the other required elements of a mailing 
 // address. 
 $missingAddressKeys = []; 
 foreach (['lastName', 'countryCode', 'postalCode'] as $addressKey) { 
 if (!array_key_exists($addressKey, $rawRecord)) { 
 $missingAddressKeys[] = $addressKey; 
 } 
 } 
 if (!empty($missingAddressKeys)) { 
 printf( 
 "Skipping addition of mailing address information because the " 
 . "following required keys are missing: %s%s", 
 json_encode($missingAddressKeys), 
 PHP_EOL 
 ); 
 } else { 
 // Creates an OfflineUserAddressInfo object that contains all the required 
 // elements of a mailing address. 
 $addressIdentifier = new UserIdentifier([ 
 'address_info' => new OfflineUserAddressInfo([ 
 'hashed_first_name' => self::normalizeAndHash( 
 $hashAlgorithm, 
 $rawRecord['firstName'], 
 false 
 ), 
 'hashed_last_name' => self::normalizeAndHash( 
 $hashAlgorithm, 
 $rawRecord['lastName'], 
 false 
 ), 
 'country_code' => $rawRecord['countryCode'], 
 'postal_code' => $rawRecord['postalCode'] 
 ]) 
 ]); 
 // Adds the address identifier to the user identifiers list. 
 $userIdentifiers[] = $addressIdentifier; 
 } 
 } 
 // Adds the user identifiers to the conversion. 
 $enhancement->setUserIdentifiers($userIdentifiers); 
     UploadEnhancedConversionsForWeb.php

    Python

     # Extracts user email, phone, and address info from the raw data, normalizes 
 # and hashes it, then wraps it in UserIdentifier objects. Creates a separate 
 # UserIdentifier object for each. The data in this example is hardcoded, but 
 # in your application you might read the raw data from an input file. 
 # IMPORTANT: Since the identifier attribute of UserIdentifier 
 # (https://developers.google.com/google-ads/api/reference/rpc/latest/UserIdentifier) 
 # is a oneof 
 # (https://protobuf.dev/programming-guides/proto3/#oneof-features), you must 
 # set only ONE of hashed_email, hashed_phone_number, mobile_id, 
 # third_party_user_id, or address_info. Setting more than one of these 
 # attributes on the same UserIdentifier will clear all the other members of 
 # the oneof. For example, the following code is INCORRECT and will result in 
 # a UserIdentifier with ONLY a hashed_phone_number: 
 # 
 # incorrectly_populated_user_identifier = client.get_type("UserIdentifier") 
 # incorrectly_populated_user_identifier.hashed_email = "..."" 
 # incorrectly_populated_user_identifier.hashed_phone_number = "..."" 
 raw_record 
 = 
 { 
 # Email address that includes a period (.) before the Gmail domain. 
 "email" 
 : 
 "alex.2@example.com" 
 , 
 # Address that includes all four required elements: first name, last 
 # name, country code, and postal code. 
 "first_name" 
 : 
 "Alex" 
 , 
 "last_name" 
 : 
 "Quinn" 
 , 
 "country_code" 
 : 
 "US" 
 , 
 "postal_code" 
 : 
 "94045" 
 , 
 # Phone number to be converted to E.164 format, with a leading '+' as 
 # required. 
 "phone" 
 : 
 "+1 800 5550102" 
 , 
 # This example lets you input conversion details as arguments, but in 
 # reality you might store this data alongside other user data, so we 
 # include it in this sample user record. 
 "order_id" 
 : 
 order_id 
 , 
 "conversion_action_id" 
 : 
 conversion_action_id 
 , 
 "conversion_date_time" 
 : 
 conversion_date_time 
 , 
 "currency_code" 
 : 
 "USD" 
 , 
 "user_agent" 
 : 
 user_agent 
 , 
 } 
 # Constructs the enhancement adjustment. 
 conversion_adjustment 
 = 
 client 
 . 
 get_type 
 ( 
 "ConversionAdjustment" 
 ) 
 conversion_adjustment 
 . 
 adjustment_type 
 = 
 ( 
 client 
 . 
 enums 
 . 
 ConversionAdjustmentTypeEnum 
 . 
 ENHANCEMENT 
 ) 
 # Creates a user identifier using the hashed email address, using the 
 # normalize and hash method specifically for email addresses. 
 email_identifier 
 = 
 client 
 . 
 get_type 
 ( 
 "UserIdentifier" 
 ) 
 # Optional: Specifies the user identifier source. 
 email_identifier 
 . 
 user_identifier_source 
 = 
 ( 
 client 
 . 
 enums 
 . 
 UserIdentifierSourceEnum 
 . 
 FIRST_PARTY 
 ) 
 # Uses the normalize and hash method specifically for email addresses. 
 email_identifier 
 . 
 hashed_email 
 = 
 normalize_and_hash_email_address 
 ( 
 raw_record 
 [ 
 "email" 
 ] 
 ) 
 # Adds the email identifier to the conversion adjustment. 
 conversion_adjustment 
 . 
 user_identifiers 
 . 
 append 
 ( 
 email_identifier 
 ) 
 # Checks if the record has a phone number, and if so, adds a UserIdentifier 
 # for it. 
 if 
 raw_record 
 . 
 get 
 ( 
 "phone" 
 ) 
 is 
 not 
 None 
 : 
 phone_identifier 
 = 
 client 
 . 
 get_type 
 ( 
 "UserIdentifier" 
 ) 
 phone_identifier 
 . 
 hashed_phone_number 
 = 
 normalize_and_hash 
 ( 
 raw_record 
 [ 
 "phone" 
 ] 
 ) 
 # Adds the phone identifier to the conversion adjustment. 
 conversion_adjustment 
 . 
 user_identifiers 
 . 
 append 
 ( 
 phone_identifier 
 ) 
 # Checks if the record has all the required mailing address elements, and if 
 # so, adds a UserIdentifier for the mailing address. 
 if 
 raw_record 
 . 
 get 
 ( 
 "first_name" 
 ) 
 is 
 not 
 None 
 : 
 # Checks if the record contains all the other required elements of a 
 # mailing address. 
 required_keys 
 = 
 [ 
 "last_name" 
 , 
 "country_code" 
 , 
 "postal_code" 
 ] 
 # Builds a new list of the required keys that are missing from 
 # raw_record. 
 missing_keys 
 = 
 [ 
 key 
 for 
 key 
 in 
 required_keys 
 if 
 key 
 not 
 in 
 raw_record 
 . 
 keys 
 () 
 ] 
 if 
 len 
 ( 
 missing_keys 
 ) 
> 0 
 : 
 print 
 ( 
 "Skipping addition of mailing address information because the" 
 f 
 "following required keys are missing: 
 { 
 missing_keys 
 } 
 " 
 ) 
 else 
 : 
 # Creates a user identifier using sample values for the user address, 
 # hashing where required. 
 address_identifier 
 = 
 client 
 . 
 get_type 
 ( 
 "UserIdentifier" 
 ) 
 address_info 
 = 
 address_identifier 
 . 
 address_info 
 address_info 
 . 
 hashed_first_name 
 = 
 normalize_and_hash 
 ( 
 raw_record 
 [ 
 "first_name" 
 ] 
 ) 
 address_info 
 . 
 hashed_last_name 
 = 
 normalize_and_hash 
 ( 
 raw_record 
 [ 
 "last_name" 
 ] 
 ) 
 address_info 
 . 
 country_code 
 = 
 raw_record 
 [ 
 "country_code" 
 ] 
 address_info 
 . 
 postal_code 
 = 
 raw_record 
 [ 
 "postal_code" 
 ] 
 # Adds the address identifier to the conversion adjustment. 
 conversion_adjustment 
 . 
 user_identifiers 
 . 
 append 
 ( 
 address_identifier 
 ) 
 
      upload_enhanced_conversions_for_web 
 . 
 py

    Ruby

     # Extracts user email, phone, and address info from the raw data, normalizes 
 # and hashes it, then wraps it in UserIdentifier objects. Creates a separate 
 # UserIdentifier object for each. The data in this example is hardcoded, but 
 # in your application you might read the raw data from an input file. 
 # IMPORTANT: Since the identifier attribute of UserIdentifier 
 # (https://developers.google.com/google-ads/api/reference/rpc/latest/UserIdentifier) 
 # is a oneof 
 # (https://protobuf.dev/programming-guides/proto3/#oneof-features), you must 
 # set only ONE of hashed_email, hashed_phone_number, mobile_id, 
 # third_party_user_id, or address_info. Setting more than one of these 
 # attributes on the same UserIdentifier will clear all the other members of 
 # the oneof. For example, the following code is INCORRECT and will result in 
 # a UserIdentifier with ONLY a hashed_phone_number: 
 # 
 # incorrectly_populated_user_identifier.hashed_email = "..."" 
 # incorrectly_populated_user_identifier.hashed_phone_number = "..."" 
 raw_record 
  
 = 
  
 { 
  
 # Email address that includes a period (.) before the Gmail domain. 
  
 "email" 
  
 = 
>  
 "alex.2@example.com" 
 , 
  
 # Address that includes all four required elements: first name, last 
  
 # name, country code, and postal code. 
  
 "first_name" 
  
 = 
>  
 "Alex" 
 , 
  
 "last_name" 
  
 = 
>  
 "Quinn" 
 , 
  
 "country_code" 
  
 = 
>  
 "US" 
 , 
  
 "postal_code" 
  
 = 
>  
 "94045" 
 , 
  
 # Phone number to be converted to E.164 format, with a leading '+' as 
  
 # required. 
  
 "phone" 
  
 = 
>  
 "+1 800 5550102" 
 , 
  
 # This example lets you input conversion details as arguments, but in 
  
 # reality you might store this data alongside other user data, so we 
  
 # include it in this sample user record. 
  
 "order_id" 
  
 = 
>  
 order_id 
 , 
  
 "conversion_action_id" 
  
 = 
>  
 conversion_action_id 
 , 
  
 "conversion_date_time" 
  
 = 
>  
 conversion_date_time 
 , 
  
 "currency_code" 
  
 = 
>  
 "USD" 
 , 
  
 "user_agent" 
  
 = 
>  
 user_agent 
 , 
 } 
 enhancement 
  
 = 
  
 client 
 . 
 resource 
 . 
 conversion_adjustment 
  
 do 
  
 | 
 ca 
 | 
  
 ca 
 . 
 conversion_action 
  
 = 
  
 client 
 . 
 path 
 . 
 conversion_action 
 ( 
 customer_id 
 , 
  
 conversion_action_id 
 ) 
  
 ca 
 . 
 adjustment_type 
  
 = 
  
 :ENHANCEMENT 
  
 ca 
 . 
 order_id 
  
 = 
  
 order_id 
  
 # Sets the conversion date and time if provided. Providing this value is 
  
 # optional but recommended. 
  
 unless 
  
 conversion_date_time 
 . 
 nil? 
  
 ca 
 . 
 gclid_date_time_pair 
  
 = 
  
 client 
 . 
 resource 
 . 
 gclid_date_time_pair 
  
 do 
  
 | 
 pair 
 | 
  
 pair 
 . 
 conversion_date_time 
  
 = 
  
 conversion_date_time 
  
 end 
  
 end 
  
 # Creates a user identifier using the hashed email address, using the 
  
 # normalize and hash method specifically for email addresses. 
  
 ca 
 . 
 user_identifiers 
 << 
 client 
 . 
 resource 
 . 
 user_identifier 
  
 do 
  
 | 
 ui 
 | 
  
 # Uses the normalize and hash method specifically for email addresses. 
  
 ui 
 . 
 hashed_email 
  
 = 
  
 normalize_and_hash_email 
 ( 
 raw_record 
 [ 
 "email" 
 ] 
 ) 
  
 # Optional: Specifies the user identifier source. 
  
 ui 
 . 
 user_identifier_source 
  
 = 
  
 :FIRST_PARTY 
  
 end 
  
 # Checks if the record has a phone number, and if so, adds a UserIdentifier 
  
 # for it. 
  
 unless 
  
 raw_record 
 [ 
 "phone" 
 ]. 
 nil? 
  
 ca 
 . 
 user_identifiers 
 << 
 client 
 . 
 resource 
 . 
 user_identifier 
  
 do 
  
 | 
 ui 
 | 
  
 ui 
 . 
 hashed_phone_number 
  
 = 
  
 normalize_and_hash_email 
 ( 
 raw_record 
 [ 
 "phone" 
 ] 
 ) 
  
 end 
  
 end 
  
 # Checks if the record has all the required mailing address elements, and if 
  
 # so, adds a UserIdentifier for the mailing address. 
  
 unless 
  
 raw_record 
 [ 
 "first_name" 
 ]. 
 nil? 
  
 # Checks if the record contains all the other required elements of a 
  
 # mailing address. 
  
 required_keys 
  
 = 
  
 [ 
 "last_name" 
 , 
  
 "country_code" 
 , 
  
 "postal_code" 
 ] 
  
 # Builds a new list of the required keys that are missing from 
  
 # raw_record. 
  
 missing_keys 
  
 = 
  
 required_keys 
  
 - 
  
 raw_record 
 . 
 keys 
  
 if 
  
 missing_keys 
  
 puts 
 ( 
  
 "Skipping addition of mailing address information because the" 
  
 \ 
  
 "following required keys are missing: 
 #{ 
 missing_keys 
 } 
 " 
  
 ) 
  
 else 
  
 ca 
 . 
 user_identifiers 
 << 
 client 
 . 
 resource 
 . 
 user_identifier 
  
 do 
  
 | 
 ui 
 | 
  
 ui 
 . 
 address_info 
  
 = 
  
 client 
 . 
 resource 
 . 
 offline_user_address_info 
  
 do 
  
 | 
 info 
 | 
  
 # Certain fields must be hashed using SHA256 in order to handle 
  
 # identifiers in a privacy-safe way, as described at 
  
 # https://support.google.com/google-ads/answer/9888656. 
  
 info 
 . 
 hashed_first_name 
  
 = 
  
 normalize_and_hash 
 ( 
  
 raw_record 
 [ 
 "first_name" 
 ] 
 ) 
  
 info 
 . 
 hashed_last_name 
  
 = 
  
 normalize_and_hash 
 ( 
  
 raw_record 
 [ 
 "last_name" 
 ] 
 ) 
  
 info 
 . 
 postal_code 
  
 = 
  
 normalize_and_hash 
 ( 
 raw_record 
 [ 
 "country_code" 
 ] 
 ) 
  
 info 
 . 
 country_code 
  
 = 
  
 normalize_and_hash 
 ( 
 raw_record 
 [ 
 "postal_code" 
 ] 
 ) 
  
 end 
  
 end 
  
 end 
  
 end 
     upload_enhanced_conversions_for_web 

     
     
 . 
 rb

    Perl

     # Construct the enhancement adjustment. 
 my 
  
 $enhancement 
  
 = 
  
 Google::Ads::GoogleAds::V21::Services::ConversionAdjustmentUploadService:: 
 ConversionAdjustment 
  
 - 
> new 
 ({ 
  
 adjustmentType 
  
 = 
>  
 ENHANCEMENT 
  
 }); 
 # Extract user email, phone, and address info from the raw data, 
 # normalize and hash it, then wrap it in UserIdentifier objects. 
 # Create a separate UserIdentifier object for each. 
 # The data in this example is hardcoded, but in your application 
 # you might read the raw data from an input file. 
 # 
 # IMPORTANT: Since the identifier attribute of UserIdentifier 
 # (https://developers.google.com/google-ads/api/reference/rpc/latest/UserIdentifier) 
 # is a oneof 
 # (https://protobuf.dev/programming-guides/proto3/#oneof-features), you must set 
 # only ONE of hashed_email, hashed_phone_number, mobile_id, third_party_user_id, 
 # or address-info. Setting more than one of these attributes on the same UserIdentifier 
 # will clear all the other members of the oneof. For example, the following code is 
 # INCORRECT and will result in a UserIdentifier with ONLY a hashed_phone_number: 
 # 
 # my $incorrect_user_identifier = Google::Ads::GoogleAds::V21::Common::UserIdentifier->new({ 
 #   hashedEmail => '...', 
 #   hashedPhoneNumber => '...', 
 # }); 
 my 
  
 $raw_record 
  
 = 
  
 { 
  
 # Email address that includes a period (.) before the Gmail domain. 
  
 email 
  
 = 
>  
 'alex.2@example.com' 
 , 
  
 # Address that includes all four required elements: first name, last 
  
 # name, country code, and postal code. 
  
 firstName 
  
 = 
>  
 'Alex' 
 , 
  
 lastName 
  
 = 
>  
 'Quinn' 
 , 
  
 countryCode 
  
 = 
>  
 'US' 
 , 
  
 postalCode 
  
 = 
>  
 '94045' 
 , 
  
 # Phone number to be converted to E.164 format, with a leading '+' as 
  
 # required. 
  
 phone 
  
 = 
>  
 '+1 800 5550102' 
 , 
  
 # This example lets you input conversion details as arguments, 
  
 # but in reality you might store this data alongside other user data, 
  
 # so we include it in this sample user record. 
  
 orderId 
  
 = 
>  
 $order_id 
 , 
  
 conversionActionId 
  
 = 
>  
 $conversion_action_id 
 , 
  
 conversionDateTime 
  
 = 
>  
 $conversion_date_time 
 , 
  
 currencyCode 
  
 = 
>  
 "USD" 
 , 
  
 userAgent 
  
 = 
>  
 $user_agent 
 , 
 }; 
 my 
  
 $user_identifiers 
  
 = 
  
 [] 
 ; 
 # Create a user identifier using the hashed email address, using the normalize 
 # and hash method specifically for email addresses. 
 my 
  
 $hashed_email 
  
 = 
  
 normalize_and_hash_email_address 
 ( 
 $raw_record 
 - 
> { 
 email 
 }); 
 push 
 ( 
  
 @$user_identifiers 
 , 
  
 Google::Ads::GoogleAds::V21::Common:: 
 UserIdentifier 
 - 
> new 
 ({ 
  
 hashedEmail 
  
 = 
>  
 $hashed_email 
 , 
  
 # Optional: Specify the user identifier source. 
  
 userIdentifierSource 
  
 = 
>  
 FIRST_PARTY 
  
 })); 
 # Check if the record has a phone number, and if so, add a UserIdentifier for it. 
 if 
  
 ( 
 defined 
  
 $raw_record 
 - 
> { 
 phone 
 }) 
  
 { 
  
 # Add the hashed phone number identifier to the list of UserIdentifiers. 
  
 push 
 ( 
  
 @$user_identifiers 
 , 
  
 Google::Ads::GoogleAds::V21::Common:: 
 UserIdentifier 
 - 
> new 
 ({ 
  
 hashedPhoneNumber 
  
 = 
>  
 normalize_and_hash 
 ( 
 $raw_record 
 - 
> { 
 phone 
 }, 
  
 1 
 )})); 
 } 
 # Confirm the record has all the required mailing address elements, and if so, add 
 # a UserIdentifier for the mailing address. 
 if 
  
 ( 
 defined 
  
 $raw_record 
 - 
> { 
 firstName 
 }) 
  
 { 
  
 my 
  
 $required_keys 
  
 = 
  
 [ 
 "lastName" 
 , 
  
 "countryCode" 
 , 
  
 "postalCode" 
 ]; 
  
 my 
  
 $missing_keys 
  
 = 
  
 [] 
 ; 
  
 foreach 
  
 my 
  
 $key 
  
 ( 
 @$required_keys 
 ) 
  
 { 
  
 if 
  
 ( 
 ! 
 defined 
  
 $raw_record 
 - 
> { 
 $key 
 }) 
  
 { 
  
 push 
 ( 
 @$missing_keys 
 , 
  
 $key 
 ); 
  
 } 
  
 } 
  
 if 
  
 ( 
 @$missing_keys 
 ) 
  
 { 
  
 print 
  
 "Skipping addition of mailing address information because the following" 
  
 . 
  
 "keys are missing: " 
  
 . 
  
 join 
 ( 
 "," 
 , 
  
 @$missing_keys 
 ); 
  
 } 
  
 else 
  
 { 
  
 push 
 ( 
  
 @$user_identifiers 
 , 
  
 Google::Ads::GoogleAds::V21::Common:: 
 UserIdentifier 
 - 
> new 
 ({ 
  
 addressInfo 
  
 = 
>  
 Google::Ads::GoogleAds::V21::Common:: 
 OfflineUserAddressInfo 
 - 
> new 
 ({ 
  
 # First and last name must be normalized and hashed. 
  
 hashedFirstName 
  
 = 
>  
 normalize_and_hash 
 ( 
 $raw_record 
 - 
> { 
 firstName 
 }), 
  
 hashedLastName 
  
 = 
>  
 normalize_and_hash 
 ( 
 $raw_record 
 - 
> { 
 lastName 
 }), 
  
 # Country code and zip code are sent in plain text. 
  
 countryCode 
  
 = 
>  
 $raw_record 
 - 
> { 
 countryCode 
 }, 
  
 postalCode 
  
 = 
>  
 $raw_record 
 - 
> { 
 postalCode 
 }, 
  
 })})); 
  
 } 
 } 
 # Add the user identifiers to the enhancement adjustment. 
 $enhancement 
 - 
> { 
 userIdentifiers 
 } 
  
 = 
  
 $user_identifiers 
 ; 
 
      upload_enhanced_conversions_for_web 
 . 
 pl

    • Make sure to set order_id to the order ID of the conversion to be adjusted, which should match the order ID that was sent by the tag .

    • Set adjustment_type to ENHANCEMENT .

    • Set conversion_action to the resource name of a ConversionAction with a type of WEBPAGE .

    • (Optional) If possible, populate gclid_date_time_pair for the most accurate measurement. Set conversion_date_time to the date and time at which the conversion with the specified order_id occurred. Include the timezone offset and use the format yyyy-mm-dd HH:mm:ss+|-HH:mm , for example: 2022-01-01 19:32:45-05:00 (ignoring daylight saving time) .

    • (Optional) Set user_agent to the user agent of the request that sent the original conversion so the conversion and its enhancement are either both attributed as same-device or both attributed as cross-device.

    Java

     // Sets the conversion action. 
 enhancementBuilder 
 . 
 setConversionAction 
 ( 
  
 ResourceNames 
 . 
 conversionAction 
 ( 
  
 customerId 
 , 
  
 Long 
 . 
 parseLong 
 ( 
 rawRecord 
 . 
 get 
 ( 
 "conversionActionId" 
 )))); 
 // Sets the order ID. Enhancements MUST use order ID instead of GCLID date/time pair. 
 enhancementBuilder 
 . 
 setOrderId 
 ( 
 rawRecord 
 . 
 get 
 ( 
 "orderId" 
 )); 
 // Sets the conversion date and time if provided. Providing this value is optional but 
 // recommended. 
 if 
  
 ( 
 rawRecord 
 . 
 containsKey 
 ( 
 "conversionDateTime" 
 )) 
  
 { 
  
 enhancementBuilder 
 . 
 setGclidDateTimePair 
 ( 
  
 GclidDateTimePair 
 . 
 newBuilder 
 () 
  
 . 
 setConversionDateTime 
 ( 
 rawRecord 
 . 
 get 
 ( 
 "conversionDateTime" 
 ))); 
 } 
 // Sets the user agent if provided. This should match the user agent of the request that sent 
 // the original conversion so the conversion and its enhancement are either both attributed as 
 // same-device or both attributed as cross-device. 
 if 
  
 ( 
 rawRecord 
 . 
 containsKey 
 ( 
 "userAgent" 
 )) 
  
 { 
  
 enhancementBuilder 
 . 
 setUserAgent 
 ( 
 rawRecord 
 . 
 get 
 ( 
 "userAgent" 
 )); 
 } 
 
      UploadEnhancedConversionsForWeb 
 . 
 java

    C#

     // Set the conversion action. 
 enhancement 
 . 
 ConversionAction 
  
 = 
  
 ResourceNames 
 . 
 ConversionAction 
 ( 
 customerId 
 , 
  
 conversionActionId 
 ); 
 // Set the order ID. Enhancements MUST use order ID instead of GCLID date/time pair. 
 enhancement 
 . 
 OrderId 
  
 = 
  
 orderId 
 ; 
 // Sets the conversion date and time if provided. Providing this value is optional but 
 // recommended. 
 if 
  
 ( 
 string 
 . 
 IsNullOrEmpty 
 ( 
 conversionDateTime 
 )) 
 { 
  
 enhancement 
 . 
 GclidDateTimePair 
  
 = 
  
 new 
  
 GclidDateTimePair 
 () 
  
 { 
  
 ConversionDateTime 
  
 = 
  
 conversionDateTime 
  
 }; 
 } 
 // Sets optional fields where a value was provided. 
 if 
  
 ( 
 ! 
 string 
 . 
 IsNullOrEmpty 
 ( 
 userAgent 
 )) 
 { 
  
 // Sets the user agent. This should match the user agent of the request that 
  
 // sent the original conversion so the conversion and its enhancement are either 
  
 // both attributed as same-device or both attributed as cross-device. 
  
 enhancement 
 . 
 UserAgent 
  
 = 
  
 userAgent 
 ; 
 } 
 
      UploadEnhancedConversionsForWeb 
 . 
 cs

    PHP

     // Sets the conversion action. 
 $enhancement->setConversionAction( 
 ResourceNames::forConversionAction($customerId, $rawRecord['conversionActionId']) 
 ); 
 // Sets the order ID. Enhancements MUST use order ID instead of GCLID date/time pair. 
 if (!empty($rawRecord['orderId'])) { 
 $enhancement->setOrderId($rawRecord['orderId']); 
 } 
 // Sets the conversion date and time if provided. Providing this value is optional but 
 // recommended. 
 if (!empty($rawRecord['conversionDateTime'])) { 
 // Sets the conversion date and time if provided. Providing this value is optional but 
 // recommended. 
 $enhancement->setGclidDateTimePair(new GclidDateTimePair([ 
 'conversion_date_time' => $rawRecord['conversionDateTime'] 
 ])); 
 } 
 // Sets the user agent if provided. This should match the user agent of the request that 
 // sent the original conversion so the conversion and its enhancement are either both 
 // attributed as same-device or both attributed as cross-device. 
 if (!empty($rawRecord['userAgent'])) { 
 $enhancement->setUserAgent($rawRecord['userAgent']); 
 } 
     UploadEnhancedConversionsForWeb.php

    Python

     conversion_action_service 
 = 
 client 
 . 
 get_service 
 ( 
 "ConversionActionService" 
 ) 
 # Sets the conversion action. 
 conversion_adjustment 
 . 
 conversion_action 
 = 
 ( 
 conversion_action_service 
 . 
 conversion_action_path 
 ( 
 customer_id 
 , 
 raw_record 
 [ 
 "conversion_action_id" 
 ] 
 ) 
 ) 
 # Sets the order ID. Enhancements MUST use order ID instead of GCLID 
 # date/time pair. 
 conversion_adjustment 
 . 
 order_id 
 = 
 order_id 
 # Sets the conversion date and time if provided. Providing this value is 
 # optional but recommended. 
 if 
 raw_record 
 . 
 get 
 ( 
 "conversion_date_time" 
 ): 
 conversion_adjustment 
 . 
 gclid_date_time_pair 
 . 
 conversion_date_time 
 = 
 ( 
 raw_record 
 [ 
 "conversion_date_time" 
 ] 
 ) 
 # Sets optional fields where a value was provided 
 if 
 raw_record 
 . 
 get 
 ( 
 "user_agent" 
 ): 
 # Sets the user agent. This should match the user agent of the request 
 # that sent the original conversion so the conversion and its 
 # enhancement are either both attributed as same-device or both 
 # attributed as cross-device. 
 conversion_adjustment 
 . 
 user_agent 
 = 
 user_agent 
     upload_enhanced_conversions_for_web 

     
     
 . 
 py

    Ruby

     ca 
 . 
 conversion_action 
  
 = 
  
 client 
 . 
 path 
 . 
 conversion_action 
 ( 
 customer_id 
 , 
  
 conversion_action_id 
 ) 
 ca 
 . 
 adjustment_type 
  
 = 
  
 :ENHANCEMENT 
 ca 
 . 
 order_id 
  
 = 
  
 order_id 
 # Sets the conversion date and time if provided. Providing this value is 
 # optional but recommended. 
 unless 
  
 conversion_date_time 
 . 
 nil? 
  
 ca 
 . 
 gclid_date_time_pair 
  
 = 
  
 client 
 . 
 resource 
 . 
 gclid_date_time_pair 
  
 do 
  
 | 
 pair 
 | 
  
 pair 
 . 
 conversion_date_time 
  
 = 
  
 conversion_date_time 
  
 end 
 end 
 # Creates a user identifier using the hashed email address, using the 
 # normalize and hash method specifically for email addresses. 
 ca 
 . 
 user_identifiers 
 << 
 client 
 . 
 resource 
 . 
 user_identifier 
  
 do 
  
 | 
 ui 
 | 
  
 # Uses the normalize and hash method specifically for email addresses. 
  
 ui 
 . 
 hashed_email 
  
 = 
  
 normalize_and_hash_email 
 ( 
 raw_record 
 [ 
 "email" 
 ] 
 ) 
  
 # Optional: Specifies the user identifier source. 
  
 ui 
 . 
 user_identifier_source 
  
 = 
  
 :FIRST_PARTY 
 end 
 # Checks if the record has a phone number, and if so, adds a UserIdentifier 
 # for it. 
 unless 
  
 raw_record 
 [ 
 "phone" 
 ]. 
 nil? 
  
 ca 
 . 
 user_identifiers 
 << 
 client 
 . 
 resource 
 . 
 user_identifier 
  
 do 
  
 | 
 ui 
 | 
  
 ui 
 . 
 hashed_phone_number 
  
 = 
  
 normalize_and_hash_email 
 ( 
 raw_record 
 [ 
 "phone" 
 ] 
 ) 
  
 end 
 end 
 # Checks if the record has all the required mailing address elements, and if 
 # so, adds a UserIdentifier for the mailing address. 
 unless 
  
 raw_record 
 [ 
 "first_name" 
 ]. 
 nil? 
  
 # Checks if the record contains all the other required elements of a 
  
 # mailing address. 
  
 required_keys 
  
 = 
  
 [ 
 "last_name" 
 , 
  
 "country_code" 
 , 
  
 "postal_code" 
 ] 
  
 # Builds a new list of the required keys that are missing from 
  
 # raw_record. 
  
 missing_keys 
  
 = 
  
 required_keys 
  
 - 
  
 raw_record 
 . 
 keys 
  
 if 
  
 missing_keys 
  
 puts 
 ( 
  
 "Skipping addition of mailing address information because the" 
  
 \ 
  
 "following required keys are missing: 
 #{ 
 missing_keys 
 } 
 " 
  
 ) 
  
 else 
  
 ca 
 . 
 user_identifiers 
 << 
 client 
 . 
 resource 
 . 
 user_identifier 
  
 do 
  
 | 
 ui 
 | 
  
 ui 
 . 
 address_info 
  
 = 
  
 client 
 . 
 resource 
 . 
 offline_user_address_info 
  
 do 
  
 | 
 info 
 | 
  
 # Certain fields must be hashed using SHA256 in order to handle 
  
 # identifiers in a privacy-safe way, as described at 
  
 # https://support.google.com/google-ads/answer/9888656. 
  
 info 
 . 
 hashed_first_name 
  
 = 
  
 normalize_and_hash 
 ( 
  
 raw_record 
 [ 
 "first_name" 
 ] 
 ) 
  
 info 
 . 
 hashed_last_name 
  
 = 
  
 normalize_and_hash 
 ( 
  
 raw_record 
 [ 
 "last_name" 
 ] 
 ) 
  
 info 
 . 
 postal_code 
  
 = 
  
 normalize_and_hash 
 ( 
 raw_record 
 [ 
 "country_code" 
 ] 
 ) 
  
 info 
 . 
 country_code 
  
 = 
  
 normalize_and_hash 
 ( 
 raw_record 
 [ 
 "postal_code" 
 ] 
 ) 
  
 end 
  
 end 
  
 end 
 end 
 # Sets optional fields where a value was provided. 
 unless 
  
 user_agent 
 . 
 nil? 
  
 # Sets the user agent. This should match the user agent of the request 
  
 # that sent the original conversion so the conversion and its enhancement 
  
 # are either both attributed as same-device or both attributed as 
  
 # cross-device. 
  
 ca 
 . 
 user_agent 
  
 = 
  
 user_agent 
 end 
     upload_enhanced_conversions_for_web 

     
     
 . 
 rb

    Perl

     # Set the conversion action. 
 $enhancement 
 - 
> { 
 conversionAction 
 } 
  
 = 
  
 Google::Ads::GoogleAds::V21::Utils::ResourceNames:: 
 conversion_action 
 ( 
  
 $customer_id 
 , 
  
 $raw_record 
 - 
> { 
 conversionActionId 
 }); 
 # Set the order ID. Enhancements MUST use order ID instead of GCLID date/time pair. 
 $enhancement 
 - 
> { 
 orderId 
 } 
  
 = 
  
 $raw_record 
 - 
> { 
 orderId 
 }; 
 # Set the conversion date and time if provided. Providing this value is optional 
 # but recommended. 
 if 
  
 ( 
 defined 
  
 $raw_record 
 - 
> { 
 conversionDateTime 
 }) 
  
 { 
  
 $enhancement 
 - 
> { 
 gclidDateTimePair 
 } 
  
 = 
  
 Google::Ads::GoogleAds::V21::Services::ConversionAdjustmentUploadService:: 
 GclidDateTimePair 
  
 - 
> new 
 ({ 
  
 conversionDateTime 
  
 = 
>  
 $raw_record 
 - 
> { 
 conversionDateTime 
 }}); 
 } 
 # Set the user agent if provided. This should match the user agent of the 
 # request that sent the original conversion so the conversion and its enhancement 
 # are either both attributed as same-device or both attributed as cross-device. 
 if 
  
 ( 
 defined 
  
 $raw_record 
 - 
> { 
 userAgent 
 }) 
  
 { 
  
 $enhancement 
 - 
> { 
 userAgent 
 } 
  
 = 
  
 $raw_record 
 - 
> { 
 userAgent 
 }; 
 } 
 
      upload_enhanced_conversions_for_web 
 . 
 pl

    Import conversion enhancements

    Java

     // Creates the conversion adjustment upload service client. 
 try 
  
 ( 
 ConversionAdjustmentUploadServiceClient 
  
 conversionUploadServiceClient 
  
 = 
  
 googleAdsClient 
 . 
 getLatestVersion 
 (). 
 createConversionAdjustmentUploadServiceClient 
 ()) 
  
 { 
  
 // Uploads the enhancement adjustment. Partial failure should always be set to true. 
  
 // NOTE: This request contains a single adjustment as a demonstration. However, if you have 
  
 // multiple adjustments to upload, it's best to upload multiple adjustments per request 
  
 // instead of sending a separate request per adjustment. See the following for per-request 
  
 // limits: 
  
 // https://developers.google.com/google-ads/api/docs/best-practices/quotas#conversion_adjustment_upload_service 
  
 UploadConversionAdjustmentsResponse 
  
 response 
  
 = 
  
 conversionUploadServiceClient 
 . 
 uploadConversionAdjustments 
 ( 
  
 UploadConversionAdjustmentsRequest 
 . 
 newBuilder 
 () 
  
 . 
 setCustomerId 
 ( 
 Long 
 . 
 toString 
 ( 
 customerId 
 )) 
  
 . 
 addConversionAdjustments 
 ( 
 enhancementBuilder 
 ) 
  
 // Enables partial failure (must be true). 
  
 . 
 setPartialFailure 
 ( 
 true 
 ) 
  
 . 
 build 
 ()); 
 
      UploadEnhancedConversionsForWeb 
 . 
 java

    C#

     // Uploads the enhancement adjustment. Partial failure should always be set to true. 
 // 
 // NOTE: This request contains a single adjustment as a demonstration. 
 // However, if you have multiple adjustments to upload, it's best to upload 
 // multiple adjustmenst per request instead of sending a separate request per 
 // adjustment. See the following for per-request limits: 
 // https://developers.google.com/google-ads/api/docs/best-practices/quotas#conversion_adjust 
 UploadConversionAdjustmentsResponse 
  
 response 
  
 = 
  
 conversionAdjustmentUploadService 
 . 
 UploadConversionAdjustments 
 ( 
  
 new 
  
 UploadConversionAdjustmentsRequest 
 () 
  
 { 
  
 CustomerId 
  
 = 
  
 customerId 
 . 
 ToString 
 (), 
  
 ConversionAdjustments 
  
 = 
  
 { 
  
 enhancement 
  
 }, 
  
 // Enables partial failure (must be true). 
  
 PartialFailure 
  
 = 
  
 true 
 , 
  
 }); 
 
      UploadEnhancedConversionsForWeb 
 . 
 cs

    PHP

     // Issues a request to upload the conversion enhancement. 
 $conversionAdjustmentUploadServiceClient = 
 $googleAdsClient->getConversionAdjustmentUploadServiceClient(); 
 // NOTE: This request contains a single adjustment as a demonstration. However, if you have 
 // multiple adjustments to upload, it's best to upload multiple adjustments per request 
 // instead of sending a separate request per adjustment. See the following for per-request 
 // limits: 
 // https://developers.google.com/google-ads/api/docs/best-practices/quotas#conversion_adjustment_upload_service 
 $response = $conversionAdjustmentUploadServiceClient->uploadConversionAdjustments( 
 // Enables partial failure (must be true). 
 UploadConversionAdjustmentsRequest::build($customerId, [$enhancement], true) 
 ); 
     UploadEnhancedConversionsForWeb.php

    Python

     # Creates the conversion adjustment upload service client. 
 conversion_adjustment_upload_service 
 = 
 client 
 . 
 get_service 
 ( 
 "ConversionAdjustmentUploadService" 
 ) 
 # Uploads the enhancement adjustment. Partial failure should always be set 
 # to true. 
 # NOTE: This request only uploads a single conversion, but if you have 
 # multiple conversions to upload, it's still best to upload them in a single 
 # request. See the following for per-request limits for reference: 
 # https://developers.google.com/google-ads/api/docs/best-practices/quotas#conversion_upload_service 
 response 
 = 
 conversion_adjustment_upload_service 
 . 
 upload_conversion_adjustments 
 ( 
 customer_id 
 = 
 customer_id 
 , 
 conversion_adjustments 
 = 
 [ 
 conversion_adjustment 
 ], 
 # Enables partial failure (must be true). 
 partial_failure 
 = 
 True 
 , 
 ) 
 
      upload_enhanced_conversions_for_web 
 . 
 py

    Ruby

     response 
  
 = 
  
 client 
 . 
 service 
 . 
 conversion_adjustment_upload 
 . 
 upload_conversion_adjustments 
 ( 
  
 customer_id 
 : 
  
 customer_id 
 , 
  
 # NOTE: This request only uploads a single conversion, but if you have 
  
 # multiple conversions to upload, it's still best to upload them in a single 
  
 # request. See the following for per-request limits for reference: 
  
 # https://developers.google.com/google-ads/api/docs/best-practices/quotas#conversion_upload_service 
  
 conversion_adjustments 
 : 
  
 [ 
 enhancement 
 ] 
 , 
  
 # Partial failure must be set to true. 
  
 partial_failure 
 : 
  
 true 
 , 
 ) 
 
      upload_enhanced_conversions_for_web 
 . 
 rb

    Perl

     # Upload the enhancement adjustment. Partial failure should always be set to true. 
 # 
 # NOTE: This request contains a single adjustment as a demonstration. 
 # However, if you have multiple adjustments to upload, it's best to 
 # upload multiple adjustments per request instead of sending a separate 
 # request per adjustment. See the following for per-request limits: 
 # https://developers.google.com/google-ads/api/docs/best-practices/quotas#conversion_adjustment_upload_service 
 my 
  
 $response 
  
 = 
  
 $api_client 
 - 
> ConversionAdjustmentUploadService 
 () 
  
 - 
> upload_conversion_adjustments 
 ({ 
  
 customerId 
  
 = 
>  
 $customer_id 
 , 
  
 conversionAdjustments 
  
 = 
>  
 [ 
 $enhancement 
 ], 
  
 # Enable partial failure (must be true). 
  
 partialFailure 
  
 = 
>  
 "true" 
  
 }); 
 
      upload_enhanced_conversions_for_web 
 . 
 pl

    Review your imports

    Use the enhanced conversions API diagnostics report to validate that your enhanced conversions for web are working effectively and to diagnose issues in your setup.

    Use offline data diagnostics to review the overall health of your recent imports.

    When reporting on conversion metrics for your campaigns, refer to Mapping user interface metrics to correlate Google Ads UI metrics with Google Ads API reporting fields. You can also query the conversion_action resource to view the total number of conversions and the total conversion value for a given conversion action.

    Best practices

    Keep the following best practices in mind when implementing enhanced conversions for web.

    Check for the customer identifier

    When you import conversions, the customer ID must be set to the account that contains the conversion action and that does the conversion tracking. To check this setting, query the serving Google Ads Customer resource for the ConversionTrackingSetting . Issue the following query with GoogleAdsService.SearchStream , to find the value of customer.conversion_tracking_setting.google_ads_conversion_customer .

      SELECT 
  
 customer 
 . 
 conversion_tracking_setting 
 . 
 google_ads_conversion_customer 
 , 
  
 customer 
 . 
 conversion_tracking_setting 
 . 
 conversion_tracking_status 
 , 
  
 customer 
 . 
 conversion_tracking_setting 
 . 
 conversion_tracking_id 
 , 
  
 customer 
 . 
 conversion_tracking_setting 
 . 
 cross_account_conversion_tracking_id 
 FROM 
  
 customer

    Set customer_id to the google_ads_conversion_customer value in your requests to import conversions.

    Include multiple identifiers if you have them

    If you have the gclid for a conversion, we recommend sending it in addition to the user_identifiers for improved performance. Further, if you have more than one UserIdentifier for the conversion, including all of these can improve the likelihood of a match. Include all identifiers on the same ConversionAdjustment .

    Review partial failure errors when setting up your integration

    When you're first setting up your enhanced conversions for web integration, review and address any partial errors in the partial_failure_error field of the response. If there are issues in your setup, you can inspect this field to investigate and address them. For more details and examples related to partial failure error handling, visit the dedicated partial failure guide .

    Once you've resolved any issues that surfaced in partial failure errors and your integration is complete, switch to using offline data diagnostics to regularly review the health of your conversions.

    Batch multiple adjustments in a single request

    If you have multiple adjustments to import, batch the operations into one UploadConversionAdjustmentsRequest , rather than sending an import request per adjustment.

    Check the quota guide for limits on the number of adjustments per request. If you want offline data diagnostics to group a set of requests under the same logical job, set the job_id of all the requests to the same value.

    Troubleshooting

    Use the enhanced conversions API diagnostics report to validate that your enhanced conversions for web are working effectively and to diagnose issues in your setup.

    Debug common errors

    Error
    CONVERSION_NOT_FOUND
    A conversion for the supplied conversion action and conversion identifier pair or order_id couldn't be found. Verify the conversion is a Google Ads conversion for the Google Ads conversion customer specified in the request's customer_id .
    In addition, verify that the conversion was not for a click where gbraid or wbraid was populated instead of gclid . Google Ads does not support enhanced conversions for web for these conversions.
    CUSTOMER_NOT_ACCEPTED_CUSTOMER_DATA_TERMS
    The customer data terms and conditions have not been accepted for the customer_id of the request. Find instructions for this in the prerequisites guide.
    CONVERSION_ALREADY_ENHANCED
    This conversion has already received an adjustment with the given order_id and conversion_action . Make sure to provide a unique order_id for each conversion.
    CONVERSION_ACTION_NOT_ELIGIBLE_FOR_ENHANCEMENT
    The conversion_action supplied is not eligible for enhanced conversions for web. In the Google Ads UI, make sure you check the Turn on enhanced conversions box on the conversion action referenced in your request. Find instructions for this in the Help Center .
    Previous
    Manage offline conversions
    Next
    Manage call conversions
    Design a Mobile Site
    View Site in Mobile | Classic
    Share by: