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

# Red y edge

> Gestiona dominios personalizados, DNS, analíticas del edge, seguimiento de errores, logs de solicitudes, percentiles de latencia e invalidación de caché para aplicaciones de sitio web.

<Note>
  Los endpoints de esta página aplican solo a **aplicaciones de sitio web** — apps con un dominio web. Llamarlos en una aplicación que no es web falla.
</Note>

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

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

## Dominio personalizado

`api.SetApplicationCustomDomain(appID, domain)` establece el dominio personalizado vinculado al sitio web.

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

## Registros DNS

Después de vincular un dominio personalizado necesitas configurar el DNS en tu registrador. `api.GetApplicationDNS(appID)` devuelve los registros a crear como un `[]squarecloud.DNSRecord`.

```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)
}
```

| Campo    | Tipo     | Descripción                                                                                                                                              |
| -------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Type`   | `string` | `"txt"` o `"cname"` — los registros TXT cubren la validación de propiedad y SSL; el CNAME transporta el tráfico y siempre apunta a `cname.squareweb.app` |
| `Name`   | `string` | Nombre del registro a crear                                                                                                                              |
| `Value`  | `string` | Valor del registro                                                                                                                                       |
| `Status` | `string` | Estado de validación: `"pending"`, `"pending_validation"` o `"active"`                                                                                   |

## Analíticas

`api.GetApplicationAnalytics(appID, start, end)` devuelve las analíticas agregadas del edge para la ventana dada como un `squarecloud.NetworkAnalytics`. La ventana es obligatoria y la retención máxima es de **7 días**.

```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") // series de 15 minutos
fmt.Println(analytics.Countries)
fmt.Println(analytics.Paths)
```

La respuesta contiene series temporales de 15 minutos (`Visits`, `Countries`, `Devices`, `OS`, `Browsers`, `Protocols`, `Methods`, `Paths`, `Referers`, `Providers`) y buckets de la ventana completa (`IPs`, `StatusCodes`, `Bots`, `ContentTypes`).

<Note>
  Para una ventana completamente anterior a la creación de la aplicación, la API devuelve un objeto vacío — todos los slices de la respuesta son `nil`. Comprueba las longitudes antes de indexar.
</Note>

### Filtros de detalle

Además de la ventana, el endpoint acepta filtros opcionales como parámetros de query — pásalos con `rest.WithQueryParam`. Cada filtro acota a la vez todos los desgloses de la respuesta:

| Filtro         | Notas                                                  |
| -------------- | ------------------------------------------------------ |
| `country`      | Código de país de 2 letras, e.g. `"BR"`                |
| `ip`           | Coincidencia exacta de IP                              |
| `path`         | Coincidencia por prefijo, e.g. `"/api"`                |
| `status`       | Código de estado HTTP, e.g. `"404"`                    |
| `os`           | Sistema operativo                                      |
| `browser`      | Nombre del navegador                                   |
| `protocol`     | Protocolo de la solicitud                              |
| `referer`      | Usa `"Direct"` para solicitudes sin referer            |
| `provider`     | Proveedor de red, e.g. `"GOOGLE (15169)"` (ASN)        |
| `content_type` | Usa `"Unknown"` para tipos de contenido sin clasificar |
| `bot`          | Usa `"Unverified"` para tráfico normal (no bot)        |

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

## Seguimiento de errores

`api.GetApplicationNetworkErrors(appID, start, end)` devuelve el desglose de errores del edge. Por defecto solo se incluyen los errores 5xx — añade `include_4xx=true` para incluir los 4xx.

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

## Logs por solicitud

`api.GetApplicationNetworkLogs(appID, start, end)` devuelve los logs del edge por solicitud.

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

<Note>
  Los logs por solicitud requieren un [plan Pro](https://squarecloud.app/plans) o superior.
</Note>

## Percentiles de latencia

`api.GetApplicationNetworkPerformance(appID, start, end)` devuelve las latencias p50 / p95 / p99 de las capas edge y origin.

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

<Note>
  Las métricas de rendimiento requieren un [plan Pro](https://squarecloud.app/plans) o superior.
</Note>

## Purga de la caché del edge

`api.PurgeApplicationCache(appID)` invalida toda la caché del edge para los dominios de la aplicación.

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

## Dominios y load balancers a nivel de cuenta

Estos dos métodos operan sobre todas las aplicaciones de la cuenta en lugar de un único sitio web.

### Listado de todos los dominios

`api.GetApplicationDomains()` devuelve todos los dominios configurados en todas las aplicaciones de la cuenta como un `[]squarecloud.AppDomain`. Los dominios personalizados se listan primero; las aplicaciones sin dominio web se omiten.

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

`api.GetLoadBalancers()` agrupa las aplicaciones que comparten un dominio personalizado, devolviendo un `squarecloud.LoadBalancers`.

```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")
}
```

Un grupo con 2 o más apps es un load balancer activo: el tráfico se balancea en el edge con failover automático cuando una de las apps está fuera de línea. `Limit` es el número máximo de aplicaciones que pueden compartir un dominio en el plan de la cuenta: 2 (Standard), 5 (Pro), 10 (Enterprise).