Policy Exemption Requests

Exemption requests allow you to automatically submit review requests for keywords and ads that trigger policy violations.

This feature could be used, for example, when:

  • Your ad contains some punctuation that's generally considered unconventional, but that follows standards within your industry.
  • A keyword in your ad group contains medical terms, but you (or your users) believe your usage of the term adheres to AdWords policies and warrants further review.

In such situations, your initial attempt at creating the ad or keyword will fail with a PolicyViolationError.

If you've populated your ads' and keywords' exemptionRequests collection, they'll be automatically submitted for review. Depending on the outcome of the review, you may be able to successfully resubmit your ads or keywords using the ADD operation.

Important: Do not simply resubmit every ad or keyword that generates a PolicyViolationError after adding exemption requests. Only resubmit those ads or keywords you believe comply with our advertising policies and warrant further review. If your ads or keywords are repeatedly disapproved for violating our advertising policies, your AdWords account could be suspended.

In the event that an ad is submitted successfully without a PolicyViolationError but is later disapproved due to an ads policy violation, further details are provided in the AdGroupAdPolicySummary.

This sections below describe the steps required to submit exemption requests.

Check each failed operation for policy violation errors

Let's say you're creating three ads in a single call to AdGroupAdService.mutate():

  • Ads A and B contain the same medical term in their headlines
  • Ad B also contains some non-standard punctuation in its headline
  • Ad C contains text that isn't in standard sentence form or doesn't reflect the target site's content

When you submit the service call containing three AdGroupAdOperations, the request fails with the following errors:

Error PolicyViolationError.fieldPath PolicyViolationError.isExemptable PolicyViolationKey.policyName
PolicyViolationError 0 (Ad A) true pharma
PolicyViolationError 1 (Ad B) true pharma
PolicyViolationError 1 (Ad B) true nonstandard_punctuation
PolicyViolationError 2 (Ad C) false unclear_or_inaccurate_ad_text

Keep the operations with exemptible policy violations

Since the errors for operations 0 and 1 are exemptible, you can resubmit them with exemption requests. The error for operation 2, however, is not exemptible so there's no point in resubmitting that operation.

The following code snippet iterates over the errors in the response and retains the operation index of each operation that failed with an exemptible policy violation error.


for (ApiError error : e.getErrors()) {
  // Get the index of the failed operation from the error's field path elements.
  FieldPathElement[] fieldPathElements = error.getFieldPathElements();
  FieldPathElement firstFieldPathElement = null;
  if (fieldPathElements != null && fieldPathElements.length > 0) {
    firstFieldPathElement = fieldPathElements[0];
  if (firstFieldPathElement == null
      || !"operations".equals(firstFieldPathElement.getField())
      || firstFieldPathElement.getIndex() == null) {
    // If the operation index is not present on the first error field path element, then
    // there's no way to determine which operation to remove, so simply throw the exception.
    throw e;
  int operationIndex = firstFieldPathElement.getIndex();
  AdGroupAdOperation operation = operations[operationIndex];
  if (handleApiError(error, operationIndex, operation)) {
  } else {
        "Removing operation with non-exemptable error at index %d.%n", operationIndex);

Update the operations with exemption requests

In order to resubmit the operations that failed due to exemptible policy violation errors, you need to add one or more ExemptionRequests to the operation's exemptionRequests collection.

An ExemptionRequest has just one attribute, a PolicyViolationKey, that consists of:

  • a string identifying the policy name
  • a string identifying the violating text

The good news is that each PolicyViolationError you encounter provides this information. As shown in the following code snippet, you can use the key attribute of each PolicyViolationError for the key attribute of the corresponding ExemptionRequest.


private static boolean handleApiError(
    ApiError error, int operationIndex, AdGroupAdOperation operation) {
  // Determine if the operation can be resubmitted with an exemption request.
  boolean isExemptableError = false;
  PolicyViolationError policyViolationError = null;
  if (error instanceof PolicyViolationError) {
    policyViolationError = (PolicyViolationError) error;
    ExpandedTextAd expandedTextAd = (ExpandedTextAd) operation.getOperand().getAd();
        "Ad with headline '%s - %s' violated %s policy '%s'.%n",
        policyViolationError.getIsExemptable() ? "exemptable" : "non-exemptable",
    isExemptableError = policyViolationError.getIsExemptable();

  if (isExemptableError) {
    // Add exemption request to the operation.
        "Adding exemption request for policy name '%s' on text '%s' to operation at index %d.%n",
    ExemptionRequest exemptionRequest = new ExemptionRequest();

    List<ExemptionRequest> exemptionRequests =
        (operation.getExemptionRequests() == null)
            ? new ArrayList<ExemptionRequest>()
            : new ArrayList<>(Arrays.asList(operation.getExemptionRequests()));
        exemptionRequests.toArray(new ExemptionRequest[exemptionRequests.size()]));
  return isExemptableError;

Resubmit the modified operations

Using the example, at this point you'll have the following AdGroupAdOperations:

  • An AdGroupAdOperation for ad A with a single exemption request with policy name "pharma" and violating text taken from the first PolicyViolationError.
  • An AdGroupAdOperation for ad B with two exemption requests: one with policy name "pharma" with violating text from the second PolicyViolationError, and one with policy name "nonstandard_punctuation" with violating text from the third PolicyViolationError.

The AdGroupAdOperation for ad C has been discarded since its PolicyViolationError was not exemptible.

With all of this in place, you can submit the modified AdGroupAdOperations for ads A and B. These operations will succeed and result in two new ads that are pending review.

Monitor the approval status of each ad or keyword

As with any other new ads, you can periodically submit AdGroupAdService.get() or AdGroupAdService.query() requests that include the AdGroupCreativeApprovalStatus field to monitor the ad and determine if it's ultimately approved or rejected.

Code examples

Each client library contains two code examples related to policy violations:

  • Handle Policy Violation Errors - This example illustrates how to identify and resubmit AdGroupAdOperations that failed due to exemptible policy violations.
  • Validate Text Ad - This example illustrates how to submit ads for validation using the validateOnly SOAP header, described in the API Call Structure guide.

Enviar comentarios sobre…

¿Necesitas ayuda? Visita nuestra página de asistencia.