Copy as Markdown[Open in ChatGPT](https://chatgpt.com/?q=Read%20https%3A%2F%2Fdocs-docusaurus.kinsta.page%2Fuser-guides%2Fai%2Fotel-integration%2Fcode-examples%2Faws-bedrock.md%20and%20help%20me%20with%20my%20question%20about%20this%20Coralogix%20documentation%20page.)[Open in Claude](https://claude.ai/new?q=Read%20https%3A%2F%2Fdocs-docusaurus.kinsta.page%2Fuser-guides%2Fai%2Fotel-integration%2Fcode-examples%2Faws-bedrock.md%20and%20help%20me%20with%20my%20question%20about%20this%20Coralogix%20documentation%20page.)

# AWS Bedrock

Auto-instrument Bedrock calls through the botocore instrumentor and emit GenAI spans in the new semantic conventions.

Before you start

These examples export to a local OpenTelemetry Collector over OTLP/gRPC. Deploy the collector first — see [Code examples → Deploy an OpenTelemetry Collector](https://docs-docusaurus.kinsta.page/user-guides/ai/otel-integration/code-examples/.md#prerequisites-deploy-an-opentelemetry-collector).

## Install[​](#install "Direct link to Install")

```
pip install boto3 opentelemetry-instrumentation-botocore opentelemetry-sdk opentelemetry-exporter-otlp-proto-grpc
```

## Environment variables[​](#environment-variables "Direct link to Environment variables")

```
export AWS_ACCESS_KEY_ID="<YOUR_AWS_ACCESS_KEY>"

export AWS_SECRET_ACCESS_KEY="<YOUR_AWS_SECRET_KEY>"

export AWS_DEFAULT_REGION="us-east-1"

export OTEL_EXPORTER_OTLP_ENDPOINT="http://<COLLECTOR_HOST>:4317"

export OTEL_EXPORTER_OTLP_INSECURE="true"

export OTEL_RESOURCE_ATTRIBUTES="cx.application.name=my-genai-app,cx.subsystem.name=my-service"

export OTEL_SEMCONV_STABILITY_OPT_IN="gen_ai_latest_experimental"

export OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT="true"
```

## Script[​](#script "Direct link to Script")

```
import boto3



# --- OTel imports ---

from opentelemetry import trace

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

from opentelemetry.instrumentation.botocore import BotocoreInstrumentor

from opentelemetry.sdk.resources import Resource

from opentelemetry.sdk.trace import TracerProvider

from opentelemetry.sdk.trace.export import BatchSpanProcessor





# --- OTel setup: configure tracer provider and OTLP exporter ---

def configure_otel() -> TracerProvider:

    resource = Resource.create()

    provider = TracerProvider(resource=resource)

    exporter = OTLPSpanExporter()  # reads OTEL_EXPORTER_OTLP_ENDPOINT from env

    provider.add_span_processor(BatchSpanProcessor(exporter))

    trace.set_tracer_provider(provider)

    return provider





def main():

    # OTel: initialize tracing and auto-instrument botocore (Bedrock)

    provider = configure_otel()

    BotocoreInstrumentor().instrument(tracer_provider=provider)



    # Your app logic

    client = boto3.client("bedrock-runtime", region_name="us-east-1")

    response = client.converse(

        modelId="anthropic.claude-3-haiku-20240307-v1:0",

        messages=[

            {

                "role": "user",

                "content": [{"text": "What is OpenTelemetry in one sentence?"}],

            }

        ],

        inferenceConfig={"maxTokens": 256, "temperature": 0.7},

    )



    text = response["output"]["message"]["content"][0]["text"]

    usage = response["usage"]

    print(f"Bedrock response: {text}")

    print(f"Tokens - input: {usage['inputTokens']}, output: {usage['outputTokens']}")



    # OTel: flush and shut down the tracer provider

    provider.force_flush()

    provider.shutdown()





if __name__ == "__main__":

    main()
```

## Expected span attributes[​](#expected-span-attributes "Direct link to Expected span attributes")

* `gen_ai.provider.name` = `"aws.bedrock"`
* `gen_ai.request.model` = `"anthropic.claude-3-haiku-20240307-v1:0"`
* `gen_ai.operation.name` = `"chat"`
* `gen_ai.usage.input_tokens`, `gen_ai.usage.output_tokens`
* `gen_ai.request.max_tokens` = `256`, `gen_ai.request.temperature` = `0.7`
* AWS-specific: `rpc.system` = `"aws-api"`, `rpc.service` = `"BedrockRuntime"`

Tip

Use the Converse API (not InvokeModel) — it has full tracing support in the botocore instrumentation. The model must be enabled in your AWS account for the chosen region.

## Next steps[​](#next-steps "Direct link to Next steps")

Look up which open-source library to use for your provider in [Compatibility matrix](https://docs-docusaurus.kinsta.page/user-guides/ai/otel-integration/providers/.md).