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

# Endpoint & Port Reference

> Concrete hosts and ports to allowlist for a self-hosted Noxus deployment

Use this as a checklist when writing firewall/egress rules. Everything here is
**outbound** unless stated otherwise. You only need the rows for features you
actually use — enable incrementally.

<Note>
  Hostnames reflect the platform's defaults and may evolve as providers change.
  Treat per-provider model and integration hosts as "enable the ones you use",
  not "allow them all".
</Note>

## Inbound (edge)

| Port                   | Service                                          | Source                                                                                | Required                                    |
| ---------------------- | ------------------------------------------------ | ------------------------------------------------------------------------------------- | ------------------------------------------- |
| `443` (`80` redirect)  | Reverse proxy → frontend, `api.`, `relay.` hosts | Users' browsers / API clients                                                         | Yes (can be private/VPN)                    |
| `443` on `relay.` host | Relay service                                    | External SaaS webhooks (WhatsApp, Teams, Telegram, generic, Google Chat webhook mode) | Only for push channels — must be **public** |

All other service ports (workers `8080`, plugin server `8500`, sandbox) are
**internal only** and must not be exposed.

## Outbound — model providers

| Provider            | Host(s)                                                                                       | Notes                                   |
| ------------------- | --------------------------------------------------------------------------------------------- | --------------------------------------- |
| OpenAI              | `api.openai.com`                                                                              |                                         |
| Anthropic           | `api.anthropic.com`                                                                           |                                         |
| Google Gemini (API) | `generativelanguage.googleapis.com`                                                           |                                         |
| Google Vertex AI    | `*-aiplatform.googleapis.com`, `cloudresourcemanager.googleapis.com`, `oauth2.googleapis.com` | Regional inference host + GCP auth/IAM  |
| Azure OpenAI        | `<your-resource>.openai.azure.com`                                                            | Your Azure resource host (configurable) |
| AWS Bedrock         | `bedrock-runtime.<region>.amazonaws.com`, `sts.amazonaws.com`                                 | Regional; plus STS for auth             |
| Mistral             | `api.mistral.ai`                                                                              |                                         |
| Groq                | `api.groq.com`                                                                                |                                         |
| Perplexity          | `api.perplexity.ai`                                                                           |                                         |
| DeepSeek            | `api.deepseek.com`                                                                            |                                         |
| Grok (xAI)          | `api.x.ai`                                                                                    |                                         |
| OpenRouter          | `openrouter.ai`                                                                               |                                         |

<Tip>
  Embeddings and rerankers use the same provider hosts (e.g. OpenAI / Vertex
  embedding endpoints). Allowlisting a provider covers its embedding models too.
  For an air-gapped setup, point a provider's `base_url` at an in-network
  OpenAI-compatible server and skip these entirely.
</Tip>

## Outbound — integrations & OAuth

Enable only the providers you connect. Each typically needs an **authorize**
host (browser), a **token** host (backend, outbound), and an **API** host
(nodes/tools, outbound).

| Provider                                       | Hosts                                                                                    |
| ---------------------------------------------- | ---------------------------------------------------------------------------------------- |
| Google (Drive, Gmail, Sheets, Docs, Calendar)  | `accounts.google.com`, `oauth2.googleapis.com`, `*.googleapis.com`, `www.googleapis.com` |
| Microsoft (Teams, SharePoint, OneDrive, Excel) | `login.microsoftonline.com`, `graph.microsoft.com`                                       |
| Slack                                          | `slack.com`, `api.slack.com`                                                             |
| Notion                                         | `api.notion.com`                                                                         |
| GitHub                                         | `github.com`, `api.github.com`                                                           |
| Airtable                                       | `airtable.com`                                                                           |
| Linear                                         | `linear.app`, `api.linear.app`                                                           |
| Calendly                                       | `auth.calendly.com`, `api.calendly.com`                                                  |
| Typeform                                       | `api.typeform.com`                                                                       |

<Note>
  By default managed-provider OAuth is brokered by NCS (below). If you use NCS
  brokering you still need egress to each provider's **API** host to run its
  nodes, but the OAuth **token** exchange goes via NCS. With direct OAuth apps,
  you also need the **token** host above.
</Note>

## Outbound — platform services & storage

| Purpose                                                                  | Host                                             | Required     | Notes                                                                              |
| ------------------------------------------------------------------------ | ------------------------------------------------ | ------------ | ---------------------------------------------------------------------------------- |
| Noxus Control Service (OAuth broker, web tools, on-prem checkin/upgrade) | `ncs.app.noxus.ai`                               | Optional     | Outbound-only. Drop for air-gap (lose auto-upgrade + NCS-brokered OAuth/web tools) |
| Object storage (GCS)                                                     | `storage.googleapis.com`                         | One of these | Or…                                                                                |
| Object storage (S3)                                                      | `s3.<region>.amazonaws.com` (or your MinIO host) | One of these | …an in-network S3-compatible store                                                 |
| Managed Noxus backend                                                    | `backend.noxus.ai`                               | SaaS only    | Not used by self-hosted deployments                                                |

## Outbound — web tools

| Tool            | Host                  | Notes                           |
| --------------- | --------------------- | ------------------------------- |
| Web search      | `google.serper.dev`   | Often relayed via NCS           |
| Web scrape      | `app.scrapingbee.com` | Often relayed via NCS           |
| Logo enrichment | `logo.clearbit.com`   | Used by some enrichment helpers |

## Outbound — telemetry (optional)

All optional; leave unset to send nothing.

| Purpose                      | Host                                                  |
| ---------------------------- | ----------------------------------------------------- |
| Error tracking (Sentry)      | `*.ingest.de.sentry.io`                               |
| Product analytics (Mixpanel) | `api.mixpanel.com`                                    |
| OpenTelemetry export         | Your configured collector (set to an in-network host) |

## Outbound — build / plugin install (as needed)

Only relevant if you build images in-network or install plugins at runtime.

| Purpose          | Host                                             |
| ---------------- | ------------------------------------------------ |
| Python packages  | `pypi.org`, `files.pythonhosted.org`             |
| Node packages    | `registry.npmjs.org`                             |
| Container images | your registry (`gcr.io`, `ghcr.io`, Docker Hub…) |

## Outbound — your own callbacks

| Purpose                 | Host                                       |
| ----------------------- | ------------------------------------------ |
| Run completion webhooks | Whatever `callback_url` you pass on a run  |
| Channel reply delivery  | The channel provider's API (covered above) |

## Minimal-egress checklist

For a tightly restricted deployment, the smallest viable egress set is usually:

* [ ] **One** model endpoint (in-network OpenAI-compatible, or a single public provider)
* [ ] Object storage (in-network S3-compatible, or one cloud storage host)
* [ ] The specific integration API hosts you actually enable
* [ ] (Optional) an in-network OTel collector
* [ ] Nothing else — NCS, telemetry, web tools, and unused providers can stay blocked

See [Outbound → Running with minimal egress](/deployment/networking/outbound#running-with-minimal-egress)
for the step-by-step.
