# Ratenbegrenzungen und Abfragegrenzwerte für die GraphQL-API

Die GitHub GraphQL-API hat Einschränkungen, um vor übermäßigen oder missbräuchlichen Aufrufen von GitHubServern zu schützen.

## Primäre Ratenbegrenzung

Ratenbeschränkungen sind standardmäßig für GitHub Enterprise Server deaktiviert. Wende dich an deine Websiteadministrator\*innen, um die Ratenlimits für deine Instanz zu bestätigen.

Wenn Sie ein Websiteadministrator sind, können Sie Ratenbegrenzungen für Ihre Instanz festlegen. Weitere Informationen finden Sie unter [Configuring rate limits (Konfigurieren von Ratenbegrenzungen)](/de/enterprise-server@3.22/admin/configuring-settings/configuring-user-applications-for-your-enterprise/configuring-rate-limits).

Wenn Sie eine App für Benutzer oder Organisationen außerhalb Ihrer Instanz entwickeln, gelten die Standardsatzgrenzwerte GitHub . Weitere Informationen finden Sie in der [](/de/graphql/overview/rate-limits-and-query-limits-for-the-graphql-api) Dokumentation unter GitHub Free.

## Knotenlimit

Damit die Schemaüberprüfung bestanden wird, müssen alle GraphQL-API-Aufrufe diese Standards erfüllen:

* Kunden müssen ein `first`- oder `last`-Argument bei jeder [Verbindung](/de/enterprise-server@3.22/graphql/guides/introduction-to-graphql#connection) angeben.
* Werte von `first` und `last` müssen innerhalb von 1-100 liegen.
* Einzelne Aufrufe können nicht mehr als 500.000 [Knoten](/de/enterprise-server@3.22/graphql/guides/introduction-to-graphql#node) insgesamt anfordern.

### Berechnen von Knoten in einem Aufruf

In diesen beiden Beispielen wird gezeigt, wie die Knoten insgesamt in einem Aufruf berechnet werden.

1. Einfache Abfrage:

   <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>

Berechnung:

   <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. Komplexe Abfrage:

   <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>

Berechnung:

   <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>

## Strategien zur Abfrageoptimierung

* **Anzahl der Objekte begrenzen**: Verwende kleinere Werte für `first`- oder `last`-Argumente, und paginiere durch Ergebnisse.
* **Abfragetiefe reduzieren**: Vermeide es, tief geschachtelte Objekte anzufordern, es sei denn, es ist erforderlich.
* **Ergebnisse filtern**: Verwende Argumente, um Daten zu filtern und nur das zurückzugeben, was du benötigst.
* **Große Abfragen aufteilen**: Unterteile komplexe Abfragen in mehrere einfachere Abfragen.
* **Nur erforderliche Felder anfordern**: Wähle nur die benötigten Felder aus, anstatt alle verfügbaren Felder anzufordern.

Durch Befolgen dieser Strategien kannst du die Wahrscheinlichkeit verringern, dass Ressourcengrenzwerte erreicht werden, und die Leistung und Zuverlässigkeit deiner API-Anforderungen verbessern.