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

# Runtime APIs

> What the platform provides to your code at runtime — the container execution environment, the per-language entrypoint contract, and the bindings that connect your code to platform resources.

Most serverless platforms hand you a sandbox: a restricted runtime, a fixed set of provided APIs, one supported way to return a response. Edge Compute doesn't. A function is a **real Linux container** running your language's own runtime — so the bulk of your "runtime API" is just the standard library and any dependency you install, exactly as it behaves on any Linux box.

What the platform adds on top is small and explicit, and this section documents it end to end:

* **An execution environment** — how containers start, stay warm, scale, and get a request budget. This is the architecture your code runs inside.
* **An entrypoint contract** — which file the platform runs and how a request reaches your code, per language.
* **Bindings** — declared connections to platform resources: the Telnyx API, secrets, KV, and object storage, with credentials injected for you so nothing sensitive lives in your code.

Everything else — HTTP parsing, crypto, file I/O, database drivers — comes from your language, not from the platform.

## Real containers

Because a function is a real container:

* **Native runtimes** — Node.js, Go, Python, and Java (Quarkus) run as themselves. No fetch-only sandbox, no restricted language subset.
* **Any dependency that installs** — npm packages, Go modules, PyPI packages, Maven artifacts.
* **POSIX environment** — environment variables, plus file I/O in the working directory and `/tmp`. The root filesystem is read-only and writes are ephemeral — they don't survive the container being recycled, so persist real data in [KV](/docs/edge-compute/kv) or a [bucket](/docs/cloud-storage/bindings).
* **Outbound network** — HTTP clients, TCP sockets, DNS resolution.

The trade-off is container lifecycle: instances cold-start, stay warm between requests, and are recycled. [Execution model](/docs/edge-compute/runtime/execution-model) covers what that means for initialization and in-memory state.

## The entrypoint contract

HTTP is the only trigger. What "handling a request" means differs by language:

| Language   | `new-func -l` | Entrypoint                                                               | Server owned by |
| ---------- | ------------- | ------------------------------------------------------------------------ | --------------- |
| TypeScript | `ts`          | `index.ts` — your own `node:http` server on `process.env.PORT \|\| 8080` | You             |
| JavaScript | `js`          | `index.js` — same contract as TypeScript                                 | You             |
| Go         | `go`          | `handler.go` — exported `Handle(w, r)` in `package function`             | Platform        |
| Python     | `python`      | `function/func.py` — ASGI `new()` factory                                | Platform        |
| Java       | `quarkus`     | Quarkus Funqy `@Funq` method                                             | Quarkus         |

The exact per-language contract — files, signatures, health probes, bodies, the request budget — is specified in [HTTP handler](/docs/edge-compute/runtime/http-handler).

## Bindings

A function reaches platform resources — the Telnyx API, secrets, KV, and object storage — through **bindings** you declare in the project manifest. The platform injects the credential, so no keys or tokens appear in your code.

How you reach a binding depends on the language:

* **TypeScript** gets a typed handle for each declared binding, resolved at runtime.
* **Go, Python, and Java** reach the same resources through injected environment variables (the Telnyx API key, each secret) and REST.

[Bindings](/docs/edge-compute/runtime/bindings) documents every binding type and how to declare it; [Environment variables](/docs/edge-compute/configuration/environment-variables) and [Secrets](/docs/edge-compute/configuration/secrets) cover configuration.

## In this section

<CardGroup cols={2}>
  <Card title="Execution model" href="/docs/edge-compute/runtime/execution-model">
    How your code runs: cold starts, warm reuse, scaling, the request budget, and where state lives.
  </Card>

  <Card title="HTTP handler" href="/docs/edge-compute/runtime/http-handler">
    The per-language entrypoint contract — files, signatures, health probes.
  </Card>

  <Card title="Bindings" href="/docs/edge-compute/runtime/bindings">
    Reach platform resources — Telnyx API, secrets, KV, object storage — from any language.
  </Card>
</CardGroup>