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

# OpenLLMetry Async Integration

> Log LLM traces directly to Helicone, bypassing our proxy, with OpenLLMetry. Supports OpenAI, Anthropic, Azure OpenAI, Cohere, Bedrock, Google AI Platform, and more.

# Overview

Async Integration let's you log events and calls without placing Helicone in your app's critical
path. This ensures that an issue with Helicone will not cause an outage to your app.

<Tabs>
  <Tab title="Node.js">
    <Steps>
      <Step title="Install Helicone Async">
        ```bash theme={null}
        npm install @helicone/async
        ```
      </Step>

      <Step title="Initialize Logger">
        ```typescript theme={null}
        import { HeliconeAsyncLogger } from "@helicone/async";
        import OpenAI from "openai";

        const logger = new HeliconeAsyncLogger({
          apiKey: process.env.HELICONE_API_KEY,
          // pass in the providers you want logged
          providers: {
            openAI: OpenAI,
            //anthropic: Anthropic,
            //cohere: Cohere
            // ...
          }
        });
        logger.init();

        const openai = new OpenAI();

        async function main() {
          const completion = await openai.chat.completions.create({
            messages: [
              {"role": "system", "content": "You are a helpful assistant."},
              {"role": "user", "content": "Who won the world series in 2020?"},
              {"role": "assistant", "content": "The Los Angeles Dodgers won the World Series in 2020."},
              {"role": "user", "content": "Where was it played?"}
            ],
            model: "gpt-4o-mini",
          });

          console.log(completion.choices[0]);
        }

        main();
        ```
      </Step>

      <Step title="Properties">
        You can set properties on the logger to be used in Helicone using the `withProperties` method. (These can be used for [Sessions](/features/sessions), [User Metrics](/features/advanced-usage/user-metrics), and more.)

        ```typescript theme={null}
        const sessionId = randomUUID();

        logger.withProperties({
          "Helicone-Session-Id": sessionId,
          "Helicone-Session-Path": "/abstract",
          "Helicone-Session-Name": "Course Plan",
        }, () => {
          const completion = await openai.chat.completions.create({
            // ...
          })
        })
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="Python">
    <Steps>
      <Step title="Install Helicone Async">
        ```bash theme={null}
        pip install helicone-async
        ```
      </Step>

      <Step title="Initialize Logger">
        ```python theme={null}
        from helicone_async import HeliconeAsyncLogger
        from openai import OpenAI

        logger = HeliconeAsyncLogger(
          api_key=HELICONE_API_KEY,
        )

        logger.init()

        client = OpenAI(api_key=OPENAI_API_KEY)

        # Make the OpenAI call
        response = client.chat.completions.create(
          model="gpt-4o-mini",
          messages=[
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": "Who won the world series in 2020?"},
            {"role": "assistant", "content": "The Los Angeles Dodgers won the World Series in 2020."},
            {"role": "user", "content": "Where was it played?"}
          ]
        )

        print(response.choices[0])
        ```
      </Step>

      <Step title="Properties">
        You can set properties on the logger to be used in Helicone using the `set_properties` method. (These can be used for [Sessions](/features/sessions), [User Metrics](/features/advanced-usage/user-metrics), and more.)

        ```python theme={null}
        session_id = str(uuid.uuid4())

        logger.set_properties({
          "Helicone-Session-Id": session_id,
          "Helicone-Session-Path": "/abstract",
          "Helicone-Session-Name": "Course Plan",
        })

        response = client.chat.completions.create(
          # ...
        )
        ```
      </Step>
    </Steps>
  </Tab>
</Tabs>

# Disabling Logging

You can completely disable all logging to Helicone if needed when using the async integration mode. This is useful for development environments or when you want to temporarily stop sending data to Helicone without changing your code structure.

<Tabs>
  <Tab title="Python">
    ```python theme={null}
    # Disable all logging in async mode
    logger.disable_logging()

    # Later, re-enable logging if needed
    logger.enable_logging()
    ```
  </Tab>

  <Tab title="Node.js">
    Coming soon
  </Tab>
</Tabs>

When logging is disabled, no traces will be sent to Helicone. This is different from `disable_content_tracing()` which only omits request and response content but still sends other metrics. Note that this feature is only available when using Helicone's async integration mode.

# Supported Providers

* [x] OpenAI
* [x] Anthropic
* [x] Azure OpenAI
* [x] Cohere
* [x] Bedrock
* [x] Google AI Platform

# Other Integrations

* [Comparing Proxy vs Async Integration](/references/proxy-vs-async)
* [Gateway Integration](/getting-started/integration-method/gateway)