> ## 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.

# OpenAI Compatible Endpoints

<Warning>
  This integration method is maintained but no longer actively developed. For the best experience and latest features, use our new [AI Gateway](/gateway/overview) with unified API access to 100+ models.
</Warning>

<Note>
  If you are utilizing an OpenAI compatible endpoint, you can conveniently log
  your requests to Helicone by modifying the base URL from
  `https://oai.helicone.ai/v1` to any of the following supported dedicated
  endpoints:
  <br />- `https://together.helicone.ai/v1`
</Note>

<Note>
  <b>Are you using another target that is OpenAI compatible?</b>

  If the target is a domain that has been approved with a <a href="/getting-started/integration-method/gateway#approved-domains"> dedicated domain</a> (e.g., TogetherAI), then you can replace the base URL with the dedicated domain.
  If the target has not been approved, you can <a href="/getting-started/integration-method/gateway">utilize the Helicone Gateway</a> to log your requests to Helicone.

  <b>Example:</b>

  Instead of using the base URL

  <code>base\_url="[https://oai.helicone.ai/v1](https://oai.helicone.ai/v1)", </code>

  You can use the base URL

  <code>base\_url="[https://together.helicone.ai/v1](https://together.helicone.ai/v1)", </code>
</Note>

<Tabs>
  <Tab title="Python">
    <AccordionGroup>
      <Accordion title="OpenAI v1+">
        Set HELICONE\_API\_KEY as an environment variable

        ```python theme={null}
        export HELICONE_API_KEY=<your API key>
        ```

        Initialize the OpenAI client. This can also be done via a global client.

        ```python theme={null}
        client = OpenAI(
          api_key="your-api-key-here",  # Replace with your OpenAI API key
          base_url="https://oai.helicone.ai/v1",  # Set the API endpoint
          default_headers= {  # Optionally set default headers or set per request (see below)
            "Helicone-Auth": f"Bearer {HELICONE_API_KEY}",
          }
        )
        ```

        Send a request and attach extra headers

        ```python theme={null}
        chat_completion = client.chat.completions.create(
          model="gpt-4-vision-preview",
          messages=[
              {"role": "user", "content": "Hello world!"}
          ],
          extra_headers={ # Can also attach headers per request
              "Helicone-Auth": f"Bearer {HELICONE_API_KEY}",
          },
        )
        ```

        Congratulations! Your OpenAI requests are now logging results to Helicone.
      </Accordion>

      <Accordion title="OpenAI <v1">
        Set HELICONE\_API\_KEY as an environment variable

        ```python theme={null}
        export HELICONE_API_KEY=<your API key>
        ```

        Modify the API base and add a Helicone-Auth header

        ```python theme={null}
        import openai

        client = OpenAI(
            base_url="https://oai.helicone.ai/v1",
            default_headers={
                "Helicone-Auth": f"Bearer {HELICONE_API_KEY}",
            }
        )

        client.chat.completions.create(
          # ...other parameters
          extra_headers={
            "Helicone-Auth": f"Bearer {HELICONE_API_KEY}",
          }
        )
        ```

        Congratulations! Your OpenAI requests are now logging results to Helicone.
      </Accordion>
    </AccordionGroup>
  </Tab>

  <Tab title="Node.js">
    **Set HELICONE\_API\_KEY as an environment variable**

    ```javascript theme={null}
    export HELICONE_API_KEY=<your API key>
    ```

    **Modify the base path and add a Helicone-Auth header**

    **OpenAI V4+**

    ```javascript theme={null}
    import OpenAI from "openai";

    const openai = new OpenAI({
      apiKey: request.env.OPENAI_API_KEY,
      baseURL: "https://oai.helicone.ai/v1",
      defaultHeaders: {
        "Helicone-Auth": `Bearer ${request.env.HELICONE_API_KEY}`,
      },
    });
    ```

    **OpenAI \< V4**

    ```javascript theme={null}
    import { Configuration, OpenAIApi } from "openai";

    const configuration = new Configuration({
        apiKey: process.env.OPENAI_API_KEY,
        basePath: "https://oai.helicone.ai/v1",
        baseOptions: {
          headers: {
              "Helicone-Auth": `Bearer ${process.env.HELICONE_API_KEY}`,
          },
        },
    });

    const openai = new OpenAIApi(configuration);
    ```
  </Tab>

  <Tab title="Node.js (w/ package)">
    # Installation and Setup

    <Steps>
      <Step title="To get started, install the `helicone-openai` package">
        ```bash theme={null}
        npm install @helicone/helicone
        ```
      </Step>

      <Step title="Set `HELICONE_API_KEY` as an environment variable">
        ```bash theme={null}
        export HELICONE_API_KEY=sk-<your-api-key>
        ```

        <Info>You can also set the Helicone API Key in your code (See below)</Info>
      </Step>

      <Step title="Replace">
        ```typescript theme={null}
        const { ClientOptions, OpenAI } = require("openai");
        ```

        with

        ```typescript theme={null}
        const { HeliconeProxyOpenAI as OpenAI,
          IHeliconeProxyClientOptions as ClientOptions } = require("helicone");
        ```
      </Step>

      <Step title="Make a request">
        Chat, Completion, Embedding, etc usage is equivalent to OpenAI package.

        ```typescript theme={null}
        const openai = new OpenAI({
          apiKey: process.env.OPENAI_API_KEY,
          heliconeMeta: {
            apiKey: process.env.HELICONE_API_KEY, // Can be set as env variable
            // ... additional helicone meta fields
          },
        });

        const chatCompletion = await openai.chat.completion.create({
          model: "gpt-4o-mini",
          messages: [{ role: "user", content: "Hello world" }],
        });

        console.log(chatCompletion.data.choices[0].message);
        ```
      </Step>
    </Steps>

    ## Send feedback

    Ensure you store the `helicone-id` header returned in the original response

    ```typescript theme={null}
    const { data, response } = await openai.chat.completion.create({
      model: "gpt-4o-mini",
      messages: [{ role: "user", content: "Hello world" }],
    }).withResponse();

    const heliconeId = response.headers.get("helicone-id");

    await openai.helicone.logFeedback(heliconeId, HeliconeFeedbackRating.Positive) // or Negative
    ```

    #### HeliconeMeta options

    ```typescript theme={null}
    interface IHeliconeMeta {
      apiKey?: string;
      properties?: { [key: string]: any };
      cache?: boolean;
      retry?: boolean | { [key: string]: any };
      rateLimitPolicy?: string | { [key: string]: any };
      user?: string;
      baseUrl?: string;
      onFeedback?: OnHeliconeFeedback; // Callback after feedback was processed
    }

    type OnHeliconeLog = (response: Response) => Promise<void>;
    type OnHeliconeFeedback = (result: Response) => Promise<void>;
    ```
  </Tab>

  <Tab title="cURL">
    **Replace the OpenAI Base URL with Helicone's**

    ```bash theme={null}
    - POST https://api.openai.com/v1

    - POST https://oai.helicone.ai/v1

    ```

    **Add a Helicone-Auth header into the requests**

    ```bash theme={null}
    "Helicone-Auth": "Bearer HELICONE_API_KEY"
    ```

    Here is an example cURL command:

    <Note>
      Please ensure to replace API keys with your own
    </Note>

    ```bash theme={null}
          curl --request POST \
              --url https://oai.helicone.ai/v1/chat/completions \
              --header "Authorization: Bearer $OPENAI_API_KEY" \
              --header "Content-Type: application/json" \
              --header "Helicone-Auth: Bearer $HELICONE_API_KEY" \
              --data '{
                  "model": "gpt-4o-mini",
                  "messages": [
                      {
                          "role": "system",
                          "content": "Say Hello!"
                      }
                  ],
                  "temperature": 1,
                  "max_tokens": 30
          }'
    ```
  </Tab>

  <Tab title="Langchain">
    **Python**

    Modify the API base and add a Helicone-Auth header

    ```python theme={null}
    #  Option 1
    openai.api_base = "https://oai.helicone.ai/v1"
    llm = ChatOpenAI(
        openai_api_key='<>',
        model_kwargs={
          "extra_headers":{
            "Helicone-Auth": f"Bearer {HELICONE_API_KEY}"
          }
        }
    )

    # Option 2
    llm = ChatOpenAI(
        openai_api_key='<>',
        model_kwargs={
          "extra_headers":{
            "Helicone-Auth": f"Bearer {HELICONE_API_KEY}"
          }
        },
        openai_api_base="https://oai.helicone.ai/v1",
    )
    ```

    **Typescript**

    ```typescript theme={null}
    const llm = new OpenAI({
      modelName: "gpt-4o-mini",
      configuration: {
        basePath: "https://oai.helicone.ai/v1",
        defaultHeaders: {
          "Helicone-Auth": `Bearer HELICONE_API_KEY`,
        },
      },
    });
    ```
  </Tab>
</Tabs>