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

# Send Traces to Bronto

> Send OpenTelemetry traces to Bronto using OTLP over HTTP or gRPC, exported directly from the OTel SDK or routed through an OpenTelemetry Collector.

Bronto accepts OpenTelemetry traces over OTLP. You can export traces directly from an OpenTelemetry SDK, or route them through an OpenTelemetry Collector before forwarding them to Bronto.

<Tip>
  For complete runtime setup and working examples, use the language guides: [Python](/opentelemetry/python) and [Node.js / JavaScript](/opentelemetry/nodejs).
</Tip>

## Prerequisites

Before you begin, make sure you have:

* a Bronto API key
* an application instrumented with an OpenTelemetry SDK, or an OpenTelemetry Collector receiving traces
* network access to the Bronto ingestion endpoint for your region

## Endpoint and authentication

Use the trace endpoint that matches your Bronto region:

| Region | Trace endpoint                             |
| ------ | ------------------------------------------ |
| EU     | `https://ingestion.eu.bronto.io/v1/traces` |
| US     | `https://ingestion.us.bronto.io/v1/traces` |

Both endpoints accept OTLP/HTTP over HTTPS on port `443`. Every request must include this header:

```text theme={"dark"}
x-bronto-api-key: <BRONTO_API_KEY>
```

## Send traces through an OpenTelemetry Collector

If you are using an OpenTelemetry Collector, configure an OTLP receiver and an OTLP/HTTP exporter that targets the Bronto trace endpoint.

```yaml otel-config.yaml theme={"dark"}
receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317
      http:
        endpoint: 0.0.0.0:4318

processors:
  batch:

exporters:
  otlphttp/brontotraces:
    traces_endpoint: https://ingestion.eu.bronto.io/v1/traces
    compression: none
    headers:
      x-bronto-api-key: <BRONTO_API_KEY>

service:
  pipelines:
    traces/bronto:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlphttp/brontotraces]
```

Replace the endpoint with your region and replace `<BRONTO_API_KEY>` with your Bronto API key.

<Note>
  If your Collector also sends logs, keep traces and logs in separate exporters and pipelines. Traces use `traces_endpoint`; logs use `logs_endpoint`.
</Note>

## Send traces directly from an SDK

If you do not need a Collector, configure your application's OpenTelemetry SDK to export traces directly to Bronto over OTLP/HTTP.

For direct trace export, point your SDK at the regional traces endpoint and include the Bronto API key header:

```bash theme={"dark"}
export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT="https://ingestion.<region>.bronto.io/v1/traces"
export OTEL_EXPORTER_OTLP_TRACES_HEADERS="x-bronto-api-key=<BRONTO_API_KEY>"
export OTEL_TRACES_EXPORTER="otlp"
```

## Minimal working examples

Bronto has OpenTelemetry setup guides for several languages. If you want a quick starting point, the Python and Node.js guides include complete working examples for logs and traces, including SDK setup, resource attributes, exporter configuration, and direct export to Bronto.

<CardGroup cols="2">
  <Card title="Python" href="/opentelemetry/python">
    Configure the OpenTelemetry Python SDK, create spans, and export traces to Bronto.
  </Card>

  <Card title="Node.js / JavaScript" href="/opentelemetry/nodejs">
    Configure the OpenTelemetry JS SDK, create spans, and export traces to Bronto.
  </Card>
</CardGroup>

## Verify trace delivery

After configuration, verify trace delivery with these checks:

1. Confirm that you are sending traces to the correct regional endpoint.
2. Confirm every request includes `x-bronto-api-key`.
3. Run your application and trigger an operation that creates a span.
4. Check Bronto for the expected `service.name`.
5. Confirm new traces are visible and spans include the attributes you expect.

## Troubleshooting

If you do not see traces:

* verify the ingestion URL matches your region
* verify the `x-bronto-api-key` header is present and valid
* confirm your process flushes spans before exit
* confirm your exporter is configured for traces, not logs or metrics
* check network egress rules allow outbound HTTPS on port `443`

## Next steps

Once trace ingestion is working, you can:

* add auto-instrumentation for your framework or runtime
* route telemetry through a shared OpenTelemetry Collector
* enrich spans with standard resource attributes
* standardize exporter configuration across services

To inspect incoming trace data, see [Explore Traces](/tracing/explore-traces).