> ## Documentation Index
> Fetch the complete documentation index at: https://docs.squarecloud.app/llms.txt
> Use this file to discover all available pages before exploring further.

# Netzwerk & Edge

> Verwalte benutzerdefinierte Domains, DNS, Edge-Analytics, Fehler-Tracking, Request-Logs, Latenz-Perzentile und Cache-Invalidierung für Website-Anwendungen.

<Note>
  Die Endpoints auf dieser Seite gelten nur für **Website-Anwendungen** — Apps mit einer Web-Domain. Sie auf einer Nicht-Web-Anwendung aufzurufen schlägt fehl.
</Note>

```go theme={null}
client := rest.NewClient(os.Getenv("SQUARECLOUD_API_KEY"))
defer client.Close()

api := rest.New(client)
```

## Benutzerdefinierte Domain

`api.SetApplicationCustomDomain(appID, domain)` setzt die an die Website gebundene benutzerdefinierte Domain.

```go theme={null}
err := api.SetApplicationCustomDomain("abc123def456abc123def456", "yoursite.com")
if err != nil {
	panic(err)
}
```

## DNS-Einträge

Nach dem Anbinden einer benutzerdefinierten Domain musst du DNS bei deinem Registrar konfigurieren. `api.GetApplicationDNS(appID)` gibt die zu erstellenden Einträge als `[]squarecloud.DNSRecord` zurück.

```go theme={null}
records, err := api.GetApplicationDNS("abc123def456abc123def456")
if err != nil {
	panic(err)
}

for _, record := range records {
	fmt.Printf("%s %s → %s (%s)\n", record.Type, record.Name, record.Value, record.Status)
}
```

| Feld     | Typ      | Beschreibung                                                                                                                                               |
| -------- | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Type`   | `string` | `"txt"` oder `"cname"` — TXT-Einträge decken Inhaberschafts- und SSL-Validierung ab; der CNAME trägt den Traffic und zeigt immer auf `cname.squareweb.app` |
| `Name`   | `string` | Zu erstellender Eintragsname                                                                                                                               |
| `Value`  | `string` | Wert des Eintrags                                                                                                                                          |
| `Status` | `string` | Validierungszustand: `"pending"`, `"pending_validation"` oder `"active"`                                                                                   |

## Analytics

`api.GetApplicationAnalytics(appID, start, end)` gibt aggregierte Edge-Analytics für das gegebene Zeitfenster als `squarecloud.NetworkAnalytics` zurück. Das Fenster ist erforderlich und die maximale Aufbewahrung beträgt **7 Tage**.

```go theme={null}
end := time.Now()
start := end.Add(-24 * time.Hour)

analytics, err := api.GetApplicationAnalytics("abc123def456abc123def456", start, end)
if err != nil {
	panic(err)
}

fmt.Println(len(analytics.Visits), "time buckets") // 15-minute series
fmt.Println(analytics.Countries)
fmt.Println(analytics.Paths)
```

Die Antwort enthält 15-Minuten-Zeitreihen (`Visits`, `Countries`, `Devices`, `OS`, `Browsers`, `Protocols`, `Methods`, `Paths`, `Referers`, `Providers`) und Buckets über das gesamte Fenster (`IPs`, `StatusCodes`, `Bots`, `ContentTypes`).

<Note>
  Für ein Fenster, das vollständig vor der Erstellung der Anwendung liegt, gibt die API ein leeres Objekt zurück — jede Slice in der Antwort ist `nil`. Prüfe Längen vor dem Indizieren.
</Note>

### Drill-down-Filter

Über das Zeitfenster hinaus akzeptiert der Endpoint optionale Filter als Query-Parameter — übergib sie mit `rest.WithQueryParam`. Jeder Filter schränkt jede Aufschlüsselung in der Antwort gleichzeitig ein:

| Filter         | Hinweise                                                    |
| -------------- | ----------------------------------------------------------- |
| `country`      | 2-Buchstaben-Ländercode, z. B. `"BR"`                       |
| `ip`           | Exakte IP-Übereinstimmung                                   |
| `path`         | Präfix-Übereinstimmung, z. B. `"/api"`                      |
| `status`       | HTTP-Statuscode, z. B. `"404"`                              |
| `os`           | Betriebssystem                                              |
| `browser`      | Browser-Name                                                |
| `protocol`     | Request-Protokoll                                           |
| `referer`      | Verwende `"Direct"` für Requests ohne Referer               |
| `provider`     | Netzwerkanbieter, z. B. `"GOOGLE (15169)"` (ASN)            |
| `content_type` | Verwende `"Unknown"` für nicht klassifizierte Content-Types |
| `bot`          | Verwende `"Unverified"` für normalen (Nicht-Bot-)Traffic    |

```go theme={null}
analytics, err := api.GetApplicationAnalytics(
	"abc123def456abc123def456",
	start, end,
	rest.WithQueryParam("country", "BR"),
	rest.WithQueryParam("status", "404"),
	rest.WithQueryParam("bot", "Unverified"),
)
```

## Fehler-Tracking

`api.GetApplicationNetworkErrors(appID, start, end)` gibt die Edge-Fehleraufschlüsselung zurück. Standardmäßig sind nur 5xx-Fehler enthalten — füge `include_4xx=true` hinzu, um 4xx einzuschließen.

```go theme={null}
errs, err := api.GetApplicationNetworkErrors(
	"abc123def456abc123def456",
	start, end,
	rest.WithQueryParam("include_4xx", "true"),
)
if err != nil {
	panic(err)
}
```

## Logs pro Request

`api.GetApplicationNetworkLogs(appID, start, end)` gibt die Edge-Logs pro Request zurück.

```go theme={null}
logs, err := api.GetApplicationNetworkLogs("abc123def456abc123def456", start, end)
if err != nil {
	panic(err)
}
```

<Note>
  Logs pro Request erfordern einen [Pro-Plan](https://squarecloud.app/plans) oder höher.
</Note>

## Latenz-Perzentile

`api.GetApplicationNetworkPerformance(appID, start, end)` gibt die p50- / p95- / p99-Latenzen für die Edge- und Origin-Schichten zurück.

```go theme={null}
perf, err := api.GetApplicationNetworkPerformance("abc123def456abc123def456", start, end)
if err != nil {
	panic(err)
}
```

<Note>
  Performance-Metriken erfordern einen [Pro-Plan](https://squarecloud.app/plans) oder höher.
</Note>

## Den Edge-Cache leeren

`api.PurgeApplicationCache(appID)` invalidiert den gesamten Edge-Cache für die Domains der Anwendung.

```go theme={null}
err := api.PurgeApplicationCache("abc123def456abc123def456")
if err != nil {
	panic(err)
}
```

## Kontoweite Domains und Load Balancer

Diese beiden Methoden arbeiten über jede Anwendung des Kontos hinweg statt auf einer einzelnen Website.

### Jede Domain auflisten

`api.GetApplicationDomains()` gibt jede über alle Anwendungen des Kontos konfigurierte Domain als `[]squarecloud.AppDomain` zurück. Benutzerdefinierte Domains werden zuerst gelistet; Anwendungen ohne Web-Domain werden ausgelassen.

```go theme={null}
domains, err := api.GetApplicationDomains()
if err != nil {
	panic(err)
}

for _, domain := range domains {
	fmt.Println(domain.AppID, domain.Hostname, domain.Type) // "subdomain" | "custom"
}
```

### Load Balancer

`api.GetLoadBalancers()` gruppiert Anwendungen, die sich eine benutzerdefinierte Domain teilen, und gibt ein `squarecloud.LoadBalancers` zurück.

```go theme={null}
lb, err := api.GetLoadBalancers()
if err != nil {
	panic(err)
}

fmt.Println("plan limit:", lb.Limit)
for _, balancer := range lb.Balancers {
	fmt.Println(balancer.Hostname, len(balancer.Apps), "apps")
}
```

Eine Gruppe mit 2 oder mehr Apps ist ein aktiver Load Balancer: Der Traffic wird an der Edge verteilt, mit automatischem Failover, wenn eine der Apps offline ist. `Limit` ist die maximale Anzahl von Anwendungen, die sich im Plan des Kontos eine Domain teilen können: 2 (Standard), 5 (Pro), 10 (Enterprise).