--- schema_version: "1" id: 3e331e05d545d845f65ce3b7688916758632498d2e2d0de52aeac152055b8545 title: GraphQL API Query Limitations collection: developer version: current locale: en-us portal_url: https://docs.salesforce.com/developer/current/en-us/graphql-api/graphql/guides/query/query-limits.md canonical_url: https://developer.salesforce.com/docs/platform/graphql/guide/query-limits.html source_site: developer.salesforce.com content_type: documentation content_hash: 76970e71b2d7c8ca3155ad36a6ba1c7b37e17056d781b26384d81af90211627c products: - GraphQL API --- # GraphQL API Query Limitations | AVAILABLE API VERSION | | --------------------------------------------------------- | | API v56.0 and later | | Event and task beta available in API v59.0–65.0 | | Event and task generally available in API v66.0 and later | GraphQL has the same limitations as SOQL. When working with GraphQL API queries, consider the following limitations. - Each GraphQL query can contain up to 10 subqueries. - Each subquery counts as one request for rate limiting. - Each subquery can return up to 2000 records within the same GraphQL query. - By default, the first 10 records are returned. You can use [pagination information](https://developer.salesforce.com/docs/platform/graphql/paginate.md) to retrieve additional records. - You can query only objects that [User Interface API](https://developer.salesforce.com/docs/atlas.en-us.uiapi.meta/uiapi/ui_api_all_supported_objects.htm) supports. **note:** Some fields are not filterable using the `where` filter. To find out if a field is supported for filtering, see the [Object Reference for the Salesforce Platform](https://developer.salesforce.com/docs/atlas.en-us.object_reference.meta/object_reference/sforce_api_objects_list.htm). For example, the [NewValue and OldValue fields](https://developer.salesforce.com/docs/atlas.en-us.object_reference.meta/object_reference/sforce_api_objects_casehistory.htm) on the CaseHistory object don't include "Filter" in the **Properties** section and aren't supported for filtering. If you attempt to pass in an unsupported field to the `where` filter, you get a "Field 'FieldName' in type 'ObjectName' is undefined" error. ## Relationship Queries An object must have a parent or child relationship with another object to form a query similar to an SOQL join. Limitations for [relationship queries](https://developer.salesforce.com/docs/atlas.en-us.soql_sosl.meta/soql_sosl/sforce_api_calls_soql_relationships_and_custom_objects.htm) are discussed in the next few sections. ### Child-to-Parent Relationships Child-to-parent relationships follow these limits. - A query can specify up to 55 child-to-parent relationships. A custom object allows up to 40 relationships, so you can reference all the child-to-parent relationships for a custom object in one query. - You can specify up to five levels in a child-to-parent relationship. - A child relationship name can't be the same as a parent relationship name within an object. This example shows three levels of child-to-parent relationship, which is `Contact.Account.Owner.FirstName`. ``` query { uiapi { query { Contact { edges { node { Id Name { value } Account { # first level of child-to-parent relationship Owner { # second level FirstName { value } # third level } } } } } } } } ``` Additionally, consider these differences between API versions. - In API version 57.0 and earlier, you can specify up to two levels of child-to-parent relationship in a query. - In API version 58.0 and later, you can specify up to five levels of child-to-parent relationship for standard and custom objects. ### Parent-to-Child Relationships Parent-to-child relationships follow these limits. - A query can specify up to 20 parent-to-child relationships. - You can specify one level in a parent-to-child relationship. - A parent relationship name can't be the same as a child relationship name within an object. This example shows a parent-to-child relationship, which is `Account.Contacts`. ``` query { uiapi { query { Account { edges { node { Id Name { value } Contacts { # parent-to-child relationship edges { node { Owner { # child-to-parent relationship CreatedBy { # child-to-parent relationship Name { value } } } } } } } } } } } } ``` If you’re querying Account, the fields you select can specify only the Contact or other objects at that level. The query can’t specify a child object of Contact. ## Semi-Join and Anti-Join Queries GraphQL API follows SOQL restrictions on semi-join and anti-join queries. - You can use up to two `nin` and `ninq` operators in a `where` argument. A `nin` and `ninq` operator can support up to two `in` or `nin` operators. - You can't use the `ne` operator with semi-joins and anti-joins. Using this operator converts a semi-join to an anti-join and vice versa. Instead, write the query in the appropriate semi-join or anti-join form. ### Main Query Limits Consider these restrictions on the `where` argument of a semi-join or anti-join query. - You must use a single ID for the semi-join or anti-join query. - The ID in the `where` argument that's used in the semi-join or anti-join can't use relationships. This example uses a single ID in a semi-join to return contact names associated with accounts whose ownership is public. ``` query { uiapi { query { Contact (where: { AccountId: { inq: { Account: { Ownership: { eq: "Public" } }, ApiName:"Id" }, } }) { edges { node { Id Name { value } } } } } } } ``` The previous query is similar to this SOQL statement. ``` SELECT Id, Name FROM Contact WHERE AccountId IN ( SELECT Id FROM Account WHERE Ownership = 'Public' ) ``` ### Subquery Limits A subquery must query a field referencing the same object type as the main query. For example, use the Id field on the `where` argument followed by `ApiName:"AccountId"`in the `inq` operator. Using `Account.Id` (dot notation) instead of `AccountId` isn't supported. This example returns specific accounts using AccountId as the selected field in the subquery, in which the contacts' last names start with "B". ``` query { uiapi { query { Account (where: { Id: { inq: { Contact: { LastName: { like: "B%" } }, ApiName:"AccountId" }, } }) { edges { node { Id Name { value } } } } } } } ``` The previous query is similar to this SOQL statement. ``` SELECT Id, Name FROM Account WHERE Id IN ( SELECT AccountId FROM Contact WHERE LastName LIKE 'B%' ) ``` There's no limit on the number of records matched in a subquery. By default, the first 10 records are returned. You can use the [pagination information](https://developer.salesforce.com/docs/platform/graphql/paginate.md) to retrieve additional records. ``` query { uiapi { query { Account (first:50, where: { Id: { inq: { Contact: { LastName: { like: "B%" } }, ApiName:"AccountId" }, } }) { edges { node { Id Name { value } } } } } } } ``` The selected field in a subquery must be a reference to a different object, and can't traverse relationships. In the previous example, the main query selects from accounts and the subquery selects from contacts. You can’t query on the same object in a subquery as in the main query. Instead of selecting from the same object in the main query and subquery, you can rewrite a semi-join query using the `Parent` field. ``` query { uiapi { query { Account ( where: { Parent: { Name: { like: "United%" } } }) { edges { node { Id Name { value } } } } } } } ``` The previous query is similar to this SOQL statement. ``` SELECT Id, Name FROM Account WHERE Parent.Name LIKE 'United%' ``` A semi-join or anti-join statement: - Can’t be nested in another semi-join or anti-join statement - Can’t be used in a subquery `where` argument. A subquery can’t be used with: - The `or` operator - The `orderBy` operator ### Multiple Semi-Joins and Anti-Joins You can combine semi-join or anti-join clauses in a query using the `inq` or `ninq` functions in a `where` argument. However, you can use only up to two subqueries in a single semi-join or anti-join queries. This example includes 2 semi-join filters that return accounts if they have an associated opportunity and an associated case that has its Priority field set to "High". ``` query { uiapi { query { Account (where: { and: [{ Id: { inq: { Opportunity: {}, ApiName:"AccountId" }, }, Id: { inq: { Case : { Priority : { eq : "High" } }, ApiName:"AccountId" } } }] }) { edges { node { Id Name { value } } } } } } } ``` The previous query is similar to this SOQL statement. ``` SELECT Id, Name FROM Account WHERE Id IN ( SELECT AccountId FROM Opportunity ) AND Id IN ( SELECT AccountId FROM Case WHERE Priority = 'High' ) ``` ## Object-Specific Limitations Only the [UI API supported objects](https://developer.salesforce.com/docs/atlas.en-us.uiapi.meta/uiapi/ui_api_all_supported_objects.htm) are available in GraphQL API. Certain supported objects come with additional limitations. ### Note Object Limitations The Note object has these limitations. - You can't query the Note object in subqueries. - You can query the Note object but you can't evaluate the body of a note, such as filtering on `Note.Body` by using the `eq` or `like` operator. You also can’t filter against the content of textarea fields, blobs, or S-control components in any object. You can return the content of the body of the note like this. ``` query { uiapi { query { Account ( where: { Name: { like: "Edge%" } }) { edges { node { Notes { edges { node { Body {value} } } } Id Name { value } } } } } } } ``` The previous query is similar to this SOQL statement. ``` SELECT Name, (SELECT Note.Body FROM Account.Notes) FROM Account WHERE Name LIKE 'Edge%' ``` You can also return all account names and the owner ID for any notes associated with the account. ``` query { uiapi { query { Account ( where: { Name: { like: "Edge%" } }) { edges { node { Notes { edges { node { OwnerId { value } } } } Id Name { value } } } } } } } ``` The previous query is similar to this SOQL statement. ``` SELECT Account.Name, (SELECT Note.OwnerId FROM Account.Notes) FROM Account ``` ### External Objects Limitations External objects have these limitations. - A subquery that involves external objects can fetch up to 1,000 rows of data. - Each query can have up to 4 joins across external objects and other types of objects. Each join requires a separate round trip to the external system when executing the query. Expect longer response times for each join in a query. - External objects don’t support the `orderBy` argument in relationship queries. This limit applies only when the external data is accessed via the OData 2.0 adapter for Salesforce Connect. ## See Also [SOQL Limits on Objects](https://developer.salesforce.com/docs/atlas.en-us.soql_sosl.meta/soql_sosl/sforce_api_calls_soql_limits.htm) [Understanding Relationship Query Limitations](https://developer.salesforce.com/docs/atlas.en-us.soql_sosl.meta/soql_sosl/sforce_api_calls_soql_relationships_query_limits.htm)