The Google Ads API do enforce limits on API operations, such as the number of operations that can be sent in a single mutate request. The table below summarizes some of the important limits and quotas to be aware of.
Request Type, Limitation, and Error Code | |||
---|---|---|---|
Paginated Requests | 10,000 rows per page |
INVALID_PAGE_SIZE
|
|
All with Basic Access | 15,000 API operations per day |
RESOURCE_EXHAUSTED
|
|
Get Requests | 1,000 requests per day |
RESOURCE_EXHAUSTED
|
|
Mutate Requests | 5,000 operations per request |
TOO_MANY_MUTATE_OPERATIONS
|
|
Planning Service Requests | 1 QPS |
RESOURCE_EXHAUSTED
|
|
Conversion Upload Service Requests | 2,000 conversions per request |
TOO_MANY_CONVERSIONS_IN_REQUEST
|
|
Billing and Account Budget Service Requests | 1 operation per mutate request |
TOO_MANY_MUTATE_OPERATIONS
|
Daily API operation limits
Daily API usage limits are based on the number of API Operations made per developer token. API operations are the total sum of get requests and mutate operations. The limits for daily API operations depends on the access level of the developer token. The Access Levels and Permissible Use guide outlines the specific API operation limits for each access level.
Requests that violate these limits will be rejected with the error:
RESOURCE_EXHAUSTED
.
gRPC limitations
All of the Google Ads API client libraries use gRPC for generating requests and responses. By default gRPC has a maximum message size of 4 MB. Responses may exceed this limit; for example, a search request that includes a very high number of fields may generate a response that exceeds 4 MB in size. To avoid this limit in search requests you can reduce the number of selected fields, or the page size. For mutates, send fewer operations per request.
Requests that violate this limitation will not generate a GoogleAdsError
.
They will generate an error at the gRPC error with a 429 Resource Exhausted
error. For reference see this list of gRPC error codes and
messages.
Get requests
Get requests (for example, using the GetCampaign
method on the
CampaignService
), have daily usage limitations
separate from the limits on operations, which are outlined in the
Access Levels and Permissible Use guide.
Unlike daily operations, the limits on get
requests do not vary by access level; all developer tokens, including those with
Standard Access, are limited to 1,000 get requests per day. Unlike search
requests, get requests are expensive because all attribute data is retrieved.
Use search instead of get whenever possible.
Requests that violate these limits will be rejected with the error:
RESOURCE_EXHAUSTED
.
Mutate requests
In addition to counting against the user’s daily operation quota, mutate requests are also subject to the following limitations:
- Mutate requests cannot exceed 5000 operations per request.
- Requests that violate this limitation will be rejected with the error:
TOO_MANY_MUTATE_OPERATIONS
.
- Requests that violate this limitation will be rejected with the error:
Requests that return API exceptions
Requests that are rejected with a GoogleAdsFailure
will count against the user's daily operation quota. Requests that fail
but do not return a GoogleAdsFailure
,
which may be the result of an error at the network level, will not count
against the user's daily operation quota because they never reach the
API. An example of this is a network connectivity failure.
Search requests
Search requests are not considered to be the same as get requests, even though both are used to retrieve data. Therefore, search requests are only subject to daily operation limits.
Paginated requests
Paginated requests (for example, requests that contain a valid
next_page_token
), are not counted against a user's daily operation quota.
However, pagination requests that contain an expired or invalid page token will
generate an exception and will count against the daily operation quota.
Requests that are paginated, such as search requests, are also subject to the following limitations:
- Page size cannot exceed 10,000 rows
- Requests that violate this limit will be rejected with the error:
INVALID_PAGE_SIZE
.
- Requests that violate this limit will be rejected with the error:
For more details on pagination, refer to Paging through results.
Planning services
Due to cost and complexity, the Planning service methods listed below are subject to separate limits from other types of requests.
- Limited to 1 request per second per CID or developer token:
KeywordPlanService.GetKeywordPlan
KeywordPlanService.GenerateHistoricalMetrics
KeywordPlanService.GenerateForecastMetrics
- Requests that violate the above limitations will be rejected with the
error:
RESOURCE_EXHAUSTED
. - 1 QPS is calculated as 60 requests per 60 seconds.
Keep in mind these limits when creating a keyword plan.
Keyword Plan Object | Maximum Number |
---|---|
KeywordPlan per account |
10000 |
KeywordPlanAdGroup per KeywordPlan |
200 |
KeywordPlanAdGroupKeyword per KeywordPlan |
10000 |
KeywordPlanCampaignKeyword (negative keywords) |
1000 |
KeywordPlanCampaign per KeywordPlan |
1 |
Conversion upload service
- Limited to 2000 conversions per request:
ConversionUploadService.UploadCallConversions
ConversionUploadService.UploadClickConversions
- Requests that violate these limits will be rejected with the error:
TOO_MANY_CONVERSIONS_IN_REQUEST
.
Billing and account budget services
- Mutates can only be made against accounts configured for monthly invoicing.
- Requests that violate this limitation will be rejected with the error:
MUTATE_NOT_ALLOWED
.
- Requests that violate this limitation will be rejected with the error:
- Only 1 operation is permitted for mutate requests.
- Requests that violate this limitation will be rejected with the error:
TOO_MANY_MUTATE_OPERATIONS
.
- Requests that violate this limitation will be rejected with the error:
- You should wait at least 12 hours between budget order changes to the same account. Making changes before 12 hours have elapsed may result in unrecoverable failures which can only be resolved by your Google Ads account representative.
Invitations to customer accounts
Starting in version 6.1 of the Google Ads API, new users can be invited to existing
client accounts with the
CustomerUserAccessService
. Because
this functionality sends invitation emails to other users, it has the potential
to be misused, and thus there are limitations to its behavior:
- Users cannot receive more than one pending invitation for the same client
account. If a subsequent request is made to send an invitation to a user
that already has a pending invitation it will be returned with the error:
ACCESS_INVITATION_ERROR_EMAIL_ADDRESS_ALREADY_HAS_PENDING_INVITATION
. - Client accounts cannot have more than 70 invitations pending at one time.
If a request is sent that causes this value to be exceeded, then it will
be returned with the error:
ACCESS_INVITATION_ERROR_PENDING_INVITATIONS_LIMIT_EXCEEDED
.
Other types of limits
A repeated field, such as a list of operations, that has too many items in a
request may incur the error:
REQUEST_SIZE_LIMIT_EXCEEDED
.
This same error message can also be due to other issues.
If you encounter this limitation and are making requests that use a repeated field, the best solution is to try reducing the number of items in the repeated field by deploying a list of operations in a mutate request.