# gets the API Key from environment variable AZURE_OPENAI_API_KEY
azure_client = AzureOpenAI(
    # https://learn.microsoft.com/azure/ai-services/openai/reference#rest-api-versioning
    api_version="2023-07-01-preview",
    # https://learn.microsoft.com/azure/cognitive-services/openai/how-to/create-resource?pivots=web-portal#create-a-resource
    azure_endpoint="https://example-endpoint.openai.azure.com",
)
azure_client = track_openai(azure_client)

completion = azure_client.chat.completions.create(
    model="deployment-name",  # e.g. gpt-35-instant
    messages=[
        {
            "role": "user",
            "content": "How do I output all files in a directory using Python?",
        },
    ],
)
```

## Cost Tracking

The `track_openai` wrapper automatically tracks token usage and cost for all supported OpenAI models.

Cost information is automatically captured and displayed in the Opik UI, including:

* Token usage details
* Cost per request based on OpenAI pricing
* Total trace cost

<Tip>
  View the complete list of supported models and providers on the [Supported Models](/tracing/supported_models) page.
</Tip>

## Grouping traces into conversational threads using `thread_id`

Threads in Opik are collections of traces that are grouped together using a unique `thread_id`.

The `thread_id` can be passed to the OpenAI client as a parameter, which will be used to group all traces into a single thread.

```python
import openai

from opik.integrations.openai import track_openai

client = openai.OpenAI()
wrapped_client = track_openai(
    openai_client=client,
    project_name="opik_args demo",
)
messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "What is Opik?"},
]

_ = wrapped_client.responses.create(
    model="gpt-4o-mini",
    input=messages,
    opik_args={"trace": {"thread_id": "f174a"}}
)
```

More information on logging chat conversations can be found in the [Log conversations](/tracing/log_chat_conversations) section.

## Video Generation (Sora)

The `track_openai` wrapper also supports OpenAI's video generation API (Sora). When you generate videos, Opik automatically tracks the video creation process and logs the generated video as an attachment when you download it via the client API.

```python
import os
from opik import track
from opik.integrations.openai import track_openai
from openai import OpenAI

os.environ["OPIK_PROJECT_NAME"] = "openai-video-demo"

client = OpenAI()
tracked_client = track_openai(client)


@track
def generate_video(prompt: str) -> dict:
    """Generate a video using OpenAI's Sora model."""
    # Create video and wait for completion
    video = tracked_client.videos.create_and_poll(
        model="sora-2",
        prompt=prompt,
    )

    result = {"id": video.id, "status": video.status}

    # Download the video if generation succeeded
    # If OpenAI moderation rejected your request - you'll see it in the create_and_poll span output
    if video.status == "completed":
        content = tracked_client.videos.download_content(video_id=video.id)
        content.write_to_file("output_video.mp4")
        result["output_path"] = "output_video.mp4"

    return result