Skip to main content
An exporter sends telemetry data out of your application to a backend system. It’s the component that does the actual network call to Arize AX (or any other OTel-compatible backend). The exporter handles a handful of distinct concerns:
ConcernWhat the exporter does
SerializationConverts spans into Protobuf, JSON, or another wire format.
TransportSends the bytes over HTTP, gRPC, or another protocol.
AuthenticationAttaches API keys, tokens, or TLS credentials.
CompressionReduces payload size (typically gzip).
TimeoutsProtects you from slow or broken networks.
Exporter timeouts are different from Span Processor timeouts. The exporter timeout protects you from slow networks; the processor timeout protects you from slow or overloaded export pipelines. Set the processor timeout higher than the exporter timeout — see the pitfalls section below.
For the full specification, see Exporter documentation.

​
OTLP (OpenTelemetry Protocol)

OTLP is the standardized wire format and transport for OpenTelemetry data. Arize AX accepts spans over OTLP, and most OTel-compatible backends do too. OTLP defines three things:
LayerOptions
Data modelThe structure of spans, metrics, and logs on the wire.
SerializationProtocol Buffers (compact binary format) or JSON.
TransportgRPC or HTTP.
For the full specification, see OTLP Specification.

​
Transport: gRPC vs HTTP

OTLP supports two transports. They’re not identical — pick based on your environment.
OTLP/gRPCOTLP/HTTP
SerializationProtobuf onlyProtobuf or JSON
Underlying protocolHTTP/2 (via gRPC)Standard HTTP POST
Default port43174318
StrengthsBest for production, high-throughput workloadsEasier through proxies, meshes, and corporate firewalls; JSON is easier to debug
Trade-offsSome proxies and load balancers don’t handle gRPC wellSlightly higher overhead than gRPC

​
OTLP/gRPC Configuration

from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
import grpc

otlp_exporter = OTLPSpanExporter(
    endpoint="https://otlp.arize.com/v1",     # Collector / backend address
    insecure=False,                            # If True, disables TLS (dev only)
    headers={                                  # Auth headers
        "space_id": "ARIZE_SPACE_ID",
        "api_key":  "ARIZE_API_KEY",
    },
    credentials=grpc.ssl_channel_credentials(),
    timeout=10,                                # Network timeout (seconds)
    compression="gzip",                        # None | "gzip" | "deflate"
)

​
OTLP/HTTP Configuration

from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter

otlp_exporter = OTLPSpanExporter(
    endpoint="https://otlp.arize.com/v1/traces",
    headers={
        "space_id": "ARIZE_SPACE_ID",
        "api_key":  "ARIZE_API_KEY",
    },
    timeout=10,
    compression="gzip",
)
Three differences worth knowing about the HTTP exporter:
  • No credentials constructor argument — TLS is automatic when the endpoint starts with https://. For client certificates, pass certificate_file, client_key_file, or client_certificate_file.
  • No insecure=True option — controlled entirely by the http:// vs https:// scheme on the endpoint.
  • No protocol constructor argument. To switch the body format between http/protobuf (default) and http/json, set OTEL_EXPORTER_OTLP_TRACES_PROTOCOL in the environment.
For the full set of constructor parameters, see the OTLP Exporter API reference.

​
Multiple Exporters

You can attach multiple exporters to the same Tracer Provider — useful for development (export to Arize AX and to the console) or for fan-out to multiple backends. 
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter

arize_exporter = OTLPSpanExporter(
    endpoint="https://otlp.arize.com/v1",
    headers={
        "space_id": "ARIZE_SPACE_ID",
        "api_key":  "ARIZE_API_KEY",
    },
)

console_exporter = ConsoleSpanExporter()

tracer_provider.add_span_processor(BatchSpanProcessor(arize_exporter))
tracer_provider.add_span_processor(BatchSpanProcessor(console_exporter))
Each exporter gets its own span processor. They run independently — a failure in one doesn’t affect the other.

​
Environment Variables

You can configure the exporter entirely from the environment, which is the recommended pattern for production:
GenericTraces-only override
OTEL_EXPORTER_OTLP_ENDPOINTOTEL_EXPORTER_OTLP_TRACES_ENDPOINT
OTEL_EXPORTER_OTLP_PROTOCOLOTEL_EXPORTER_OTLP_TRACES_PROTOCOL
OTEL_EXPORTER_OTLP_HEADERSOTEL_EXPORTER_OTLP_TRACES_HEADERS
OTEL_EXPORTER_OTLP_CERTIFICATEOTEL_EXPORTER_OTLP_TRACES_CERTIFICATE
OTEL_EXPORTER_OTLP_INSECUREOTEL_EXPORTER_OTLP_TRACES_INSECURE
OTEL_EXPORTER_OTLP_COMPRESSIONOTEL_EXPORTER_OTLP_TRACES_COMPRESSION
OTEL_EXPORTER_OTLP_TIMEOUTOTEL_EXPORTER_OTLP_TRACES_TIMEOUT
The traces-only variant takes priority over the generic one when both are set. For the full reference, see OpenTelemetry environment variables.

​
Common Pitfalls

A few exporter failure modes worth knowing about up front:
  • Wrong OTLP port or endpoint — gRPC defaults to 4317, HTTP to 4318. Mixing them up surfaces as connection refused or 404s.
  • Wrong encoding for the transport — gRPC requires Protobuf. Trying to send JSON over gRPC will silently fail.
  • Proxies breaking gRPC — corporate proxies, service meshes, and some load balancers don’t handle HTTP/2 well. If you see flaky gRPC errors, switch to HTTP.
  • TLS mismatches — forgetting insecure=True when running against a local collector over http:// fails. So does setting insecure=False against an http:// endpoint. Match insecure to the scheme: True for http://, False (default) for https://.
  • Exporter timeout too high — if the exporter timeout exceeds the Span Processor timeout, the processor can fire a retry while the original export is still in flight, leading to queue buildup and dropped spans.
  • Spans over 4 MB hit gRPC message-size limits — very large attributes (full document text, base64 images) can blow past the gRPC default. Truncate large attributes with TraceConfig or chunk them.

​
Next step

The exporter sends spans. The span processor decides when and how often:

Next: Span Processor