Preços da API OpenAI | Cálculo de Custo Automático

A API OpenAI é uma API (Interface de Programação de Aplicações) para serviços sob a marca OpenAI, como ChatGPT e DALL·E 3. Com modelos de IA tão poderosos, as APIs da OpenAI estão se tornando uma das APIs mais utilizadas em seus respectivos campos. No entanto, não são gratuitas para uso.

Este artigo fornecerá uma análise de cada um dos modelos de preços da API da OpenAI, bem como um método automatizado para calcular o número de tokens e seu custo ao usar a API da OpenAI.

O que é a API OpenAI?

A API OpenAI é a API de programa (Interface de Programação de Aplicações) fornecida pela OpenAI. Com a API da OpenAI, os desenvolvedores podem usar serviços de modelos de IA como a API GPT e a API DALLE 3 por meio da API da OpenAI.

Com a API da OpenAI, permite que os desenvolvedores criem aplicativos utilizando os modelos de IA da OpenAI, como ChatGPT e Dalle3, ou utilizem esses modelos de IA para criar os seus próprios - tudo sem ter que acessar a página web real para obter sua funcionalidade.

Detalhes: Preço da API OpenAI

No momento da escrita, existem sete modelos de IA recomendados que fornecem serviços de API sob a OpenAI, que são:

• GPT-4o
• GPT-4 Turbo
• GPT-4
• GPT-3.5 Turbo
• Assistants API
• Modelos de Fine-tuning
• Modelos de Embedding e modelos básicos
• Modelos de geração de imagem (DALL·E 3)
• Modelos de áudio, e mais.

GPT-4o

GPT-4o (“o” para “omni”) é a versão mais recente do modelo até 13 de maio de 2024. É também o modelo líder mais rápido e acessível. Além disso, o GPT-4o tem a melhor visão e desempenho em idiomas não ingleses entre todos os nossos modelos. O GPT-4o está disponível na API da OpenAI para clientes pagantes.

Preço do GPT-4 Turbo

O GPT-4 Turbo vem em três modelos: gpt-4-0125-preview, gpt-4-1106-preview e gpt-4-1106-vision-preview, todos com preço de $10.00 por 1M de tokens de entrada e 1M de tokens de saída. O preço é definido em $30.00 por item.

Embora o GPT-4 Turbo seja um modelo de processamento de linguagem natural de alto desempenho, pode-se perceber que a taxa de uso pode ser maior, devido ao melhor desempenho.

Preço do GPT-4

Existem duas opções de preço para o modelo de linguagem GPT-4.

1. gpt-4: Esta é a versão padrão do GPT-4. Há uma taxa de $30.00 por 1M de tokens de entrada e $60.00 por 1M de tokens de saída.
2. gpt-4-32k: Esta é uma versão avançada do GPT-4 com um comprimento de contexto maior. É precificada em $60.00 por 1M de tokens de entrada e $120.00 por 1M de tokens de saída, o dobro do preço do gpt-4 padrão.

O amplo conhecimento geral e de domínio do GPT-4 e a capacidade de resolver problemas difíceis com precisão, seguindo instruções complexas em linguagem natural, é digno de nota; no entanto, para obter o gpt-4-32k de melhor desempenho, você terá que pagar o dobro da versão padrão.

Preço do GPT-3.5 Turbo

A família de modelos GPT-3.5 Turbo tem dois membros. O modelo gpt-3.5-turbo-0125 é o modelo líder que suporta janelas de contexto de 16K e é otimizado para interação. O modelo gpt-3.5-turbo-instruct é um modelo instruído e suporta apenas janelas de contexto de 4K. As respectivas taxas serão USD 0.5 e USD 1.5 por 1M de tokens de entrada, enquanto USD 1.5 e USD 2 por 1M de tokens de saída.

Preço da Assistants API

Os desenvolvedores podem usar a Assistants API e ferramentas para criar suas próprias aplicações de assistente de IA. O recurso de busca incorrerá em uma taxa de armazenamento de arquivo para cada assistente, onde o preço é baseado na taxa de token para o modelo de linguagem selecionado. Os dois submodelos, Code Interpreter e Retrieval, são precificados em USD 0.03/sessão e USD 0.2/GB/assistente/dia.

Preço dos Modelos de Fine-tuning

Ao usar modelos de fine-tuning, os usuários serão cobrados apenas pelo uso do modelo original. As taxas respectivas para os três modelos, como gpt-3.5-turbo, davinci-002 e babbage-002, serão 8 USD, 6 USD e 0.41M por 1M de tokens de treinamento, e 3 USD e 12 USD por 1M de tokens de entrada. USD e 1.6 USD e, para 1M de tokens de saída, será 6 USD, 12 USD e 1.6 USD.

Preço dos Modelos de Embedding e Modelos Base

Os modelos de embedding são bastante acessíveis, onde text-embedding-3-small é $0.02 por 1M de token, text-embedding-3-large é $0.13 por 1M de token, e ada v2 é $0.10 por 1M de token.

A taxa do modelo base é $2.00 por 1M de token para davinci-002 e $0.40 para babbage-002.

Preço do modelo de geração de imagem (DALL·E 3)

A qualidade padrão do DALL-E 3 com resolução de 1024x1024 custa $0.04 por imagem, e a mesma resolução em HD custa $0.08. O DALL-E 2 é mais barato em resoluções mais baixas: 1024x1024 a $0.02, 512x512 a $0.018, e 256x256 a $0.016.

Resumo Tabulado para Cada Modelo de Preço da API OpenAI

Se você deseja saber as taxas de uso para todos os modelos, visite o site oficial da API ChatGPT e consulte a lista de preços da API OpenAI.

Pré-requisitos para Cálculo de Custo Automatizado com Apidog

Para trabalhar mais eficientemente com APIs, recomendamos fortemente que você use o Apidog.

O Apidog é uma plataforma de desenvolvimento de API tudo-em-um que apoia os desenvolvedores de API durante todo o ciclo de vida da API. Isso significa que o Apidog cobre todos os processos relacionados a APIs, desde o design até os testes e documentação.

Para criar uma calculadora automática para o custo de execução da API OpenAI, precisamos de uma biblioteca de conversão de terceiros para converter com precisão os inputs e outputs em valores de token.

Além disso, seremos capazes de convertê-los para qualquer moeda, vamos usar JPY (iene japonês) como exemplo.

Biblioteca de Contagem de Tokens

Isso utiliza a biblioteca Open AI GPT Token Counter para converter dados de entrada/saída em contagens de tokens durante o processo de depuração da API.

Exemplos de código Node.js:

const openaiTokenCounter = require('openai-gpt-token-counter');

const text = process.argv[2]; // Obter o conteúdo de teste a partir dos argumentos da linha de comando
const model = "gpt-4"; // Substitua pelo modelo OpenAI que deseja usar

const tokenCount = openaiTokenCounter.text(text, model);
const characterCount = text.length; // Calcular o número de caracteres

console.log(`${tokenCount}`);

Você deve então renomear o script Node.js como gpt-tokens-counter.js, e colocá-lo no diretório do programa externo do Apidog para chamá-lo.

Em seguida, você precisará instalar o OpenAI GPT Token Counter no seu computador. Para isso, você pode usar o seguinte comando no seu terminal:

npm install openai-gpt-token-counter

API de Taxa de Câmbio em Tempo Real​

Após obter os valores de tokens para a entrada e saída, é necessário estimar o custo em JPY usando uma API de taxa de câmbio em tempo real. Este artigo chamará a API Currencylayer para obter a taxa de câmbio em tempo real. Cadastre-se para obter uma conta e uma chave de API.

Convertendo Valores de Entrada em Tokens Usando Apidog

Os valores de entrada podem ser entendidos como perguntas e instruções quando fornecidos pelo usuário durante a consulta ao aplicativo de IA. Para aproveitar isso, um script personalizado precisa ser adicionado nos Pré-Processadores para extrair o parâmetro query do corpo da solicitação body, seguido da conversão para valores de token.

Este é o código de exemplo para adicionar o script de conversão de valor de token na seção de Pré-Processadores:

try {
  var jsonData = JSON.parse(pm.request.body.raw);
  var content = jsonData.messages[0].content; // obtém o conteúdo das mensagens
  var result_input_tokens_js = pm.execute('./gpt-tokens/gpt-tokens-counter.js',[content])
  console.log(content);
  pm.environment.set("RESULT_INPUT_TOKENS", result_input_tokens_js);
  console.log("Contagem de Tokens de Entrada: " + pm.environment.get("RESULT_INPUT_TOKENS"));
} catch (e) {
    console.log(e);
}

Depois de pressionar Send, os valores de entrada calculados devem ser visíveis na seção do console do Apidog.

Converter Tokens em Custo JPY

Após obter o valor dos tokens consumidos a partir da entrada, é necessário solicitar uma API de taxa de câmbio em tempo real para obter um fator de conversão. Esse fator é então multiplicado pelo valor dos tokens para calcular o custo real em JPY. Adicione o seguinte script à pré-operação:

pm.sendRequest("http://apilayer.net/api/live?access_key=YOUR-API-KEY&currencies=JPY&source=USD&format=1", (err, res) => {
  if (err) {
    console.log(err);
  } else {
    const quotes = res.json().quotes;
    const rate = parseFloat(quotes.USDJPY).toFixed(3);
    pm.environment.set("USDJPY_RATE", rate); 
    var USDJPY_RATE = pm.environment.get("USDJPY_RATE");
    // Recuperar a variável RESULT_INPUT_TOKENS do script anterior
    var RESULT_INPUT_TOKENS = pm.environment.get("RESULT_INPUT_TOKENS");

    // Calcular o valor da taxa de câmbio de tokens
    const tokensExchangeRate = 0.03; // Preço de 1000 tokens em USD (com a precificação de entrada do GPT-4-8k como referência)

    // Calcular o preço estimado em JPY
    const JPYPrice = ((RESULT_INPUT_TOKENS / 1000) * tokensExchangeRate * USDJPY_RATE).toFixed(2);

    pm.environment.set("INPUT_PRICE", JPYPrice); 

    console.log("Custo estimado: " + "¥" + JPYPrice);
  }
});

Convertendo Valores de Saída em Tokens Usando Apidog

O Apidog analisa automaticamente os dados retornados como um evento SSE (Server-Sent Events) quando o parâmetro content-type na resposta retornada pela API contém algo como text/event-stream.

Comece indo para a seção de Pós-Processadores na definição da API e adicione um script personalizado para extrair o conteúdo da resposta e concluir a concatenação.

// Obter o texto da resposta
const text = pm.response.text()
// Dividir o texto em linhas
var lines = text.split('\n');
// Criar um array vazio para armazenar o parâmetro "content"
var contents = [];
// Iterar por cada linha
for (var i = 0; i < lines.length; i++) {
    const line = lines[i];
    // Ignorar linhas que não começam com "data:"
    if (!line.startsWith('data:')) {
        continue;
    }
    // Tentar analisar os dados JSON
    try {
        var data = JSON.parse(line.substring(5).trim());  // Remover o "data: " no início
        // Obter o parâmetro "content" do array "choices" e adicioná-lo ao array
        contents.push(data.choices[0].delta.content);
    } catch (e) {
        // Ignorar a linha atual se não for dados JSON válidos
    }
}
// Juntar os parâmetros "content" usando o método join()
var result = contents.join('');
// Exibir o resultado na aba "Visualizar" do corpo
pm.visualizer.set(result);
// Imprimir o resultado no console
console.log(result);

Após criar a solicitação, você pode recuperar o conteúdo completo da resposta no console!

Convertendo Tokens do Valor de Saída Usando Apidog

Uma vez que você tenha recebido o conteúdo da resposta, é necessário convertê-lo no valor de Tokens. Isso é possibilitado por uma biblioteca de terceiros.

Adicione o script personalizado na operação de pós-processamento para que o Apidog possa chamar o script externo gpt-toejsn-counter.js para obter o valor de Tokens.

Use esta página para ver o código específico:

Com os números obtidos do console, você pode estimar quanto custará!

// Obter o texto da resposta
const text = pm.response.text()
// Dividir o texto em linhas
var lines = text.split('\n');
// Criar um array vazio para armazenar o parâmetro "content"
var contents = [];
// Iterar por cada linha
for (var i = 0; i < lines.length; i++) {
    const line = lines[i];
    // Ignorar linhas que não começam com "data:"
    if (!line.startsWith('data:')) {
        continue;
    }
    // Tentar analisar os dados JSON
    try {
        var data = JSON.parse(line.substring(5).trim());  // Remover o "data: " no início
        // Obter o parâmetro "content" do array "choices" e adicioná-lo ao array
        contents.push(data.choices[0].delta.content);
    } catch (e) {
        // Ignorar a linha atual se não for dados JSON válidos
    }
}
// Juntar os parâmetros "content" usando o método join()
var result = contents.join('');
// Exibir o resultado na aba "Visualizar" do corpo
pm.visualizer.set(result);
// Imprimir o resultado no console
console.log(result);

// Calcular o número de tokens de saída.
var RESULT_OUTPUT_TOKENS = pm.execute('./gpt-tokens/gpt-tokens-counter.js', [result])
pm.environment.set("RESULT_OUTPUT_TOKENS", RESULT_OUTPUT_TOKENS);

console.log("Contagem de Tokens de Saída: " + pm.environment.get("RESULT_OUTPUT_TOKENS")); 

Converter Tokens de Saída em Custo JPY

Semelhante ao esquema de cálculo de custo mencionado na seção anterior, o custo real (JPY) é obtido multiplicando-se o valor dos Tokens pela taxa de câmbio.

Adicione o seguinte script na operação de pós-processamento:

pm.sendRequest("http://apilayer.net/api/live?access_key=YOUR-API-KEY&currencies=JPY&source=USD&format=1", (err, res) => {
  if (err) {
    console.log(err);
  } else {
    const quotes = res.json().quotes;
    const rate = parseFloat(quotes.USDJPY).toFixed(3);
    pm.environment.set("USDJPY_RATE", rate); 
    var USDJPY_RATE = pm.environment.get("USDJPY_RATE");
    // Obter a variável RESULT_OUTPUT_TOKENS do script anterior
    var RESULT_OUTPUT_TOKENS = pm.environment.get("RESULT_OUTPUT_TOKENS");

    // Calcular a taxa de câmbio em tokens
    const tokensExchangeRate = 0.06; // Preço em USD por 1000 tokens (com base na precificação de entrada do GPT-4-8k)

    // Calcular o preço estimado em JPY
    const JPYPrice = ((RESULT_OUTPUT_TOKENS / 1000) * tokensExchangeRate * USDJPY_RATE).toFixed(2);

    pm.environment.set("OUTPUT_PRICE", JPYPrice); 

    console.log("Custo de saída (JPY): " + JPYPrice + "円");
  }
});

Calcular o Custo Total em JPY

Por fim, adicione um script personalizado na fase de pós-processamento que possa calcular automaticamente o custo total de entradas e saídas.

// Somando os custos de entrada e saída

const INPUTPrice = Number(pm.environment.get("INPUT_PRICE"));
// Obter a variável de preço de entrada e convertê-la em número

const OUTPUTPrice = Number(pm.environment.get("OUTPUT_PRICE"));
// Obter a variável de preço de saída e convertê-la em número

console.log("Custo total: " + "￥" + (INPUTPrice + OUTPUTPrice));
// Imprimir o custo total: a soma do preço de entrada e do preço de saída.

Permitindo estimar o custo aproximado da solicitação atual durante o processo de depuração da API.

Trabalhe nas APIs OpenAI com Apidog

Como mencionado anteriormente, Apidog é uma ferramenta abrangente de API que fornece design, documentação, teste e depuração de APIs em um único aplicativo.

Com inúmeras outras APIs como as da OpenAI, você agora pode encontrar e acessar esse tipo de projeto de API de terceiros com o serviço API Hub do Apidog.

Para acessar o projeto Open API no API hub, clique neste link abaixo. Você pode obter acesso a todas as APIs fornecidas pela OpenAI!

Como Chamar e Testar a API OpenAI Online

Para testar a API da OpenAI, siga estas instruções:

Passo 1: Assim que você acessar a página do projeto da API OpenAI, selecione a API que deseja usar no menu à esquerda e clique no botão " Tente agora " no painel direito.

Passo 2: Para usar a API, você precisa de privilégios de acesso à OpenAI e precisa obter uma chave da API, então você deve inserir a API_KEY da OpenAI aqui.

Com o Apidog, informações sensíveis, como chaves de API, nunca serão armazenadas na nuvem - em vez disso, serão armazenadas localmente, para que você possa confiar no Apidog.

Passo 3: Pressione o botão Send para enviar a solicitação ao servidor da OpenAI e receber uma resposta.

Se você gosta de experimentar e personalizar solicitações de API, pode pressionar Executar no Apidog para ativar a ferramenta de gerenciamento de API.

Conclusão

Se você deseja implementar a API OpenAI em seu aplicativo, primeiro precisa entender qual é o seu objetivo com a API. Em seguida, familiarize-se com as várias APIs da OpenAI, lendo e entendendo-as. Cada modelo de IA disponível da OpenAI não é o mesmo, oferecendo especificações e níveis de desempenho diferentes.

Você também pode acessar facilmente as APIs da OpenAI usando o Apidog, uma ferramenta de gerenciamento de API fácil de usar. Se você precisa usar ou testar as APIs da OpenAI, o Apidog é a melhor escolha, especialmente com o projeto API Hub da OpenAI pronto para que os usuários aprendam e implementem. Esta será uma medida eficiente. Consultando o guia apresentado neste artigo, você pode usar a API OpenAI com o Apidog e ao mesmo tempo calcular automaticamente o número de tokens e o custo consumido por ela!