Getting Started with the Official OpenAI Node.js Library

mkdir openai-node-starter
cd openai-node-starter
npm init -y

npm install openai dotenv

node_modules
.env

Your API key is the password that gives your application access to OpenAI's models. Treat it like a secret!

1. Log in to the OpenAI Platform.
2. Navigate to the API Keys section in the left-hand menu.
3. Click "Create new secret key". Give it a descriptive name like "Node.js Starter".
4. Copy the key immediately. For security reasons, OpenAI will not show it to you again.

Now, open your .env file and add the key you just copied:

OPENAI_API_KEY="sk-YourSecretKeyGoesHere"

With this setup, the dotenv package can load this variable into your application's environment, and the OpenAI library will automatically find it.

Step 3: Your First Chat Completion

It's time for the exciting part! Let's write some code to interact with an AI model. We'll use gpt-4o-mini, a fast and highly capable model perfect for getting started. Create a new file named index.js.

Here is the complete code to send a message and receive a response. We'll break it down right after.

// 1. Load environment variables
require('dotenv').config();

// 2. Import the OpenAI class
const { OpenAI } = require('openai');

// 3. Create an instance of the OpenAI client
// The library automatically finds the API key in your .env file
const openai = new OpenAI();

async function main() {
  console.log('Asking the AI a question...');

  try {
    // 4. Create a chat completion
    const completion = await openai.chat.completions.create({
      // The model to use for the completion
      model: 'gpt-4o-mini',
      // The messages to send to the model
      messages: [
        { 
          role: 'system',
          content: 'You are a helpful assistant who provides concise and witty responses.' 
        },
        { 
          role: 'user', 
          content: 'What is the best thing about developing with Node.js?' 
        },
      ],
    });

    // 5. Log the response from the model
    const aiResponse = completion.choices[0].message.content;
    console.log('AI says:', aiResponse);

  } catch (error) {
    console.error('An error occurred:', error);
  }
}

// Run the main function
main();

Breaking Down the Code

1. Environment Setup: require('dotenv').config() loads the variables from your .env file (like your API key) into process.env.
2. Import: We import the necessary OpenAI class from the library.
3. Instantiation: new OpenAI() creates a client instance. By default, it looks for the OPENAI_API_KEY environment variable, so you don't need to pass it in manually. Clean and secure!
4. API Call: openai.chat.completions.create() is the core function. We pass it an object with two key properties:
   • model: Specifies which AI model to use.
   • messages: An array of message objects that provide context for the conversation. The system role sets the AI's persona, while the user role is for your prompts.
5. Accessing the Response: The AI's reply is nested inside the response object. You can find the text content at completion.choices[0].message.content.

Ready to see it in action? Run the script from your terminal:

node index.js

You should see a clever response from the AI printed in your console. Congratulations, you've just integrated a powerful language model into your Node.js application!

Going Further: Generating Images with DALL-E 3

The OpenAI library isn't just for text. You can also generate stunning images with DALL-E 3. The process is just as simple. Let's create a new file, generateImage.js, to try it out.

require('dotenv').config();
const { OpenAI } = require('openai');

const openai = new OpenAI();

async function generateImage() {
  console.log('Generating an image with DALL-E 3...');

  try {
    const response = await openai.images.generate({
      model: 'dall-e-3',
      prompt: 'A photorealistic image of a majestic lion wearing a tiny, colorful party hat in a lush jungle.',
      n: 1, // Number of images to generate
      size: '1024x1024', // Image size
    });

    const imageUrl = response.data[0].url;
    console.log('Image generated! You can view it here:', imageUrl);

  } catch (error) {
    console.error('Error generating image:', error);
  }
}

generateImage();

Run this script with node generateImage.js. The console will output a URL. Copy and paste it into your browser to see the unique image you just created with code!

What's Next?

You've successfully set up the OpenAI Node.js library, made a chat completion call, and even generated an image. You now have the fundamental building blocks to create amazing AI-powered features.

The possibilities are endless. You could build:

• A customer service chatbot for your website.
• A tool that summarizes long articles or transcripts.
• A creative writing assistant that helps overcome writer's block.
• An application that generates custom social media visuals on the fly.

The best place to continue your journey is the official OpenAI API documentation. Explore the other endpoints, experiment with different models, and start building the future. Happy coding!