# Limites de taxas e limites de consultas para a API GraphQL

A API GraphQL GitHub tem limitações estabelecidas para proteger os servidores de GitHub contra chamadas excessivas ou abusivas.

## Limite da taxa primária

Os limites de taxa são desabilitados por padrão para GitHub Enterprise Server. Fale com o administrador do site para confirmar os limites de velocidade da sua instância.

Se você for um administrador de site, poderá definir limites de taxa para a sua instância. Para saber mais, confira [Como configurar limites de taxa](/pt/enterprise-server@3.22/admin/configuring-settings/configuring-user-applications-for-your-enterprise/configuring-rate-limits).

Se você estiver desenvolvendo um aplicativo para usuários ou organizações fora de sua instância, os limites de taxa padrão GitHub se aplicam. Para obter mais informações, consulte [Limites de taxas e limites de consultas para a API GraphQL](/pt/graphql/overview/rate-limits-and-query-limits-for-the-graphql-api) na GitHub Free documentação.

## Limite do nó

Para passar na validação do [schema](/pt/enterprise-server@3.22/graphql/guides/introduction-to-graphql#schema), todas as chamadas de API do GraphQL devem atender a estes padrões:

* Os clientes devem fornecer um argumento `first` ou `last` em qualquer [conexão](/pt/enterprise-server@3.22/graphql/guides/introduction-to-graphql#connection).
* Os valores de `first`e `last` precisam estar entre 1 e 100.
* As chamadas individuais não podem solicitar mais de 500 mil [nós](/pt/enterprise-server@3.22/graphql/guides/introduction-to-graphql#node) no total.

### Calculando os nós em uma chamada

Estes dois exemplos mostram como calcular os nós totais em uma chamada.

1. Consulta simples:

   <pre>query {
     viewer {
       repositories(first: <span class="redbox">50</span>) {

edges {
repository:node {
name

issues(first: <span class="greenbox">10</span>) {
totalCount
edges {
node {
title
bodyHTML
}
}
}
}
}
}
}
}</pre>

Cálculo:

   <pre><span class="redbox">50</span>         = 50 repositories
    +
   <span class="redbox">50</span> x <span class="greenbox">10</span>  = 500 repository issues

= 550 total nodes</pre>

1. Consulta complexa:

   <pre>query {
     viewer {
       repositories(first: <span class="redbox">50</span>) {

edges {
repository:node {
name

pullRequests(first: <span class="greenbox">20</span>) {
edges {
pullRequest:node {
title

comments(first: <span class="bluebox">10</span>) {
edges {
comment:node {
bodyHTML
}
}
}
}
}
}

issues(first: <span class="greenbox">20</span>) {
totalCount
edges {
issue:node {
title
bodyHTML

comments(first: <span class="bluebox">10</span>) {
edges {
comment:node {
bodyHTML
}
}
}
}
}
}
}
}
}

```
   followers(first: <span class="bluebox">10</span>) {
```

edges {
follower:node {
login
}
}
}
}
}</code></pre>

Cálculo:

   <pre><span class="redbox">50</span>              = 50 repositories
    +
   <span class="redbox">50</span> x <span class="greenbox">20</span>       = 1,000 pullRequests
    +
   <span class="redbox">50</span> x <span class="greenbox">20</span> x <span class="bluebox">10</span> = 10,000 pullRequest comments
    +
   <span class="redbox">50</span> x <span class="greenbox">20</span>       = 1,000 issues
    +
   <span class="redbox">50</span> x <span class="greenbox">20</span> x <span class="bluebox">10</span> = 10,000 issue comments
    +
   <span class="bluebox">10</span>              = 10 followers

= 22,060 total nodes</pre>

## Estratégias de otimização de consulta

* **Limitar o número de objetos**: use valores menores para argumentos `first` ou `last` e paginar pelos resultados.
* **Reduzir a profundidade da consulta**: evite solicitar objetos profundamente aninhados, a menos que necessário.
* **Resultados do filtro**: use argumentos para filtrar dados e retornar apenas o que você precisa.
* **Dividir consultas grandes**: divida consultas complexas em várias consultas mais simples.
* **Solicitar apenas os campos necessários**: selecione apenas os campos de que você precisa, em vez de solicitar todos os campos disponíveis.

Seguindo essas estratégias, você pode reduzir a probabilidade de atingir os limites de recursos e melhorar o desempenho e a confiabilidade de suas solicitações de API.