ราคา OpenAI API | การคำนวณค่าใช้จ่ายอัตโนมัติ

OpenAI API คือ API (Application Programming Interface) สำหรับบริการภายใต้แบรนด์ OpenAI เช่น ChatGPT และ DALL·E 3 ด้วยโมเดล AI ที่ทรงพลังเช่นนี้ OpenAI API จึงกลายเป็นหนึ่งใน API ที่ถูกใช้งานมากที่สุดในสาขาของตน อย่างไรก็ตาม API เหล่านี้ไม่ได้ใช้งานได้ฟรี

บทความนี้จะให้รายละเอียดเกี่ยวกับการแบ่งประเภทราคาของแต่ละโมเดล API ของ OpenAI รวมถึงวิธีการคำนวณจำนวนโทเค็นและค่าใช้จ่ายโดยอัตโนมัติเมื่อใช้ OpenAI API

OpenAI API คืออะไร?

OpenAI API คือ API (Application Programming Interface) ที่ OpenAI มอบให้ ด้วย OpenAI API นักพัฒนาสามารถใช้บริการโมเดล AI เช่น GPT API และ DALLE 3 API ผ่าน OpenAI API

ด้วย OpenAI API ทำให้นักพัฒนาสามารถสร้างแอปโดยใช้โมเดล AI ของ OpenAI เช่น ChatGPT และ Dalle3 หรือใช้โมเดล AI เหล่านี้เพื่อสร้างของคุณเอง - ทั้งหมดนี้โดยไม่ต้องเข้าถึงหน้าเว็บจริงเพื่อเข้าถึงฟังก์ชันการทำงาน

เจาะลึก: ราคา OpenAI API

ณ เวลาที่เขียน มีโมเดล AI ที่แนะนำเจ็ดรุ่นที่ให้บริการ API ภายใต้ OpenAI ซึ่งได้แก่:

• GPT-4o
• GPT-4 Turbo
• GPT-4
• GPT-3.5 Turbo
• Assistants API
• Fine-tuning models
• Embedding models และ basic models
• Image generation models (DALL·E 3)
• Audio models และอื่นๆ

GPT-4o

GPT-4o (“o” สำหรับ “omni”) เป็นรุ่นล่าสุดจนถึงวันที่ 13 พฤษภาคม 2024 นอกจากนี้ยังเป็นโมเดลเรือธงที่เร็วที่สุดและราคาไม่แพงที่สุด นอกจากนี้ GPT-4o ยังมีวิสัยทัศน์และประสิทธิภาพที่ดีที่สุดในภาษาที่ไม่ใช่ภาษาอังกฤษในบรรดาโมเดลของเรา GPT-4o พร้อมใช้งานใน OpenAI API สำหรับลูกค้าที่ชำระเงิน

ราคา GPT-4 Turbo

GPT-4 Turbo มีสามรุ่น: gpt-4-0125-preview, gpt-4-1106-preview และ gpt-4-1106-vision-preview ทั้งหมดมีราคา $10.00 ต่อ 1M โทเค็นอินพุตและ 1M โทเค็นเอาต์พุต ราคาตั้งไว้ที่ $30.00 ต่อรายการ

แม้ว่า GPT-4 Turbo จะเป็นโมเดลประมวลผลภาษาธรรมชาติที่มีประสิทธิภาพสูง แต่ก็สามารถเห็นได้ว่าค่าธรรมเนียมการใช้งานอาจสูงกว่าเนื่องจากประสิทธิภาพที่ดีกว่า

ราคา GPT-4

มีตัวเลือกราคาสำหรับโมเดลภาษา GPT-4 สองแบบ

1. gpt-4: นี่คือรุ่นมาตรฐานของ GPT-4 มีค่าธรรมเนียม $30.00 ต่อ 1M โทเค็นอินพุต และ $60.00 ต่อ 1M โทเค็นเอาต์พุต
2. gpt-4-32k: นี่คือรุ่นขั้นสูงของ GPT-4 ที่มีความยาวบริบทที่ยาวขึ้น มีราคา $60.00 ต่อ 1M โทเค็นอินพุต และ $120.00 ต่อ 1M โทเค็นเอาต์พุต ซึ่งเป็นสองเท่าของราคา gpt-4 มาตรฐาน

ความรู้ทั่วไปและโดเมนที่กว้างขวางของ GPT-4 และความสามารถในการแก้ปัญหาที่ยากได้อย่างแม่นยำโดยทำตามคำแนะนำที่ซับซ้อนในภาษาธรรมชาติเป็นสิ่งที่ควรค่าแก่การจดจำ อย่างไรก็ตาม เพื่อให้ได้ gpt-4-32k ที่มีประสิทธิภาพสูงกว่า คุณจะต้องจ่ายสองเท่าของรุ่นมาตรฐาน

ราคา GPT-3.5 Turbo

ตระกูลโมเดล GPT-3.5 Turbo มีสมาชิกสองคน โมเดล gpt-3.5-turbo-0125 เป็นโมเดลเรือธงที่รองรับหน้าต่างบริบท 16K และได้รับการปรับให้เหมาะสมสำหรับการโต้ตอบ โมเดล gpt-3.5-turbo-instruct เป็นโมเดลที่ได้รับคำแนะนำและรองรับหน้าต่างบริบท 4K เท่านั้น ค่าธรรมเนียมที่เกี่ยวข้องคือ USD 0.5 และ USD 1.5 สำหรับ 1M โทเค็นอินพุต ในขณะที่ USD 1.5 และ USD 2 สำหรับ 1M โทเค็นเอาต์พุต

ราคา Assistants API

นักพัฒนาสามารถใช้ Assistants API และเครื่องมือเพื่อสร้างแอปพลิเคชันผู้ช่วย AI ของตนเองได้ คุณสมบัติการค้นหาจะเรียกเก็บค่าธรรมเนียมการจัดเก็บไฟล์สำหรับผู้ช่วยแต่ละราย โดยราคาจะขึ้นอยู่กับค่าธรรมเนียมโทเค็นสำหรับโมเดลภาษาที่เลือก สองรุ่นย่อยคือ Code Interpreter และ Retrieval มีราคา $0.03/session และ $0.2/GB/assistant/day

ราคา Fine-tuning Model

เมื่อใช้โมเดล fine-tuning ผู้ใช้จะถูกเรียกเก็บเงินเฉพาะการใช้โมเดลดั้งเดิมเท่านั้น ค่าธรรมเนียมที่เกี่ยวข้องสำหรับสามรุ่น เช่น gpt-3.5-turbo, davinci-002 และ babbage-002 จะเป็น 8 USD, 6 USD และ 0.41M ต่อ 1M โทเค็นการฝึกอบรม และ 3 USD และ 12 USD ต่อ 1M โทเค็นอินพุต USD และ 1.6 USD และสำหรับ 1M โทเค็นเอาต์พุต จะเป็น 6 USD, 12 USD และ 1.6 USD

ราคา Embedding และ Base Models

โมเดล Embedding มีราคาไม่แพงมาก โดย text-embedding-3-small มีราคา $0.02 ต่อ 1M โทเค็น text-embedding-3-large มีราคา $0.13 ต่อ 1M โทเค็น และ ada v2 มีราคา $0.10 ต่อ 1M โทเค็น

ค่าธรรมเนียมโมเดลพื้นฐานคือ $2.00 ต่อ 1M โทเค็นสำหรับ davinci-002 และ $0.40 สำหรับ babbage-002

ราคาโมเดลสร้างภาพ (DALL·E 3)

คุณภาพมาตรฐานของ DALL-E 3 ความละเอียด 1024x1024 มีราคา $0.04 ต่อภาพ และความละเอียดเดียวกันใน HD มีราคา $0.08 DALL-E 2 มีราคาถูกกว่าที่ความละเอียดต่ำกว่า: 1024x1024 ที่ $0.02, 512x512 ที่ $0.018 และ 256x256 ที่ $0.016

สรุปตารางสำหรับราคาโมเดล OpenAI API แต่ละรุ่น

หากคุณต้องการทราบค่าธรรมเนียมการใช้งานสำหรับทุกรุ่น โปรดไปที่เว็บไซต์ ChatGPT API อย่างเป็นทางการและตรวจสอบ รายการราคา OpenAI API

ข้อกำหนดเบื้องต้นสำหรับการคำนวณต้นทุนอัตโนมัติด้วย Apidog

เพื่อให้ทำงานได้อย่างมีประสิทธิภาพมากขึ้นเกี่ยวกับ API เราขอแนะนำให้คุณใช้ Apidog

Apidog เป็นแพลตฟอร์มการพัฒนา API แบบครบวงจรที่รองรับนักพัฒนา API ตลอดวงจรชีวิตของ API ซึ่งหมายความว่า Apidog ช่วยคุณในกระบวนการต่างๆ ในการดูแล API ตั้งแต่การออกแบบ ไปจนถึงการทดสอบและการจัดทำเอกสาร

ในการสร้างเครื่องคำนวณอัตโนมัติสำหรับต้นทุนการเรียกใช้ OpenAI API เราจำเป็นต้องใช้ไลบรารีการแปลงบุคคลที่สามเพื่อแปลงอินพุตและเอาต์พุตเป็นค่าโทเค็นได้อย่างแม่นยำ

นอกจากนี้ เราจะสามารถแปลงเป็นสกุลเงินใดก็ได้ เช่น JPY (เยนญี่ปุ่น) เป็นตัวอย่าง

ไลบรารีการแปลงจำนวนโทเค็น

สิ่งนี้ใช้ ไลบรารี Open AI GPT Token Counter เพื่อแปลงข้อมูลอินพุต/เอาต์พุตเป็นจำนวนโทเค็นในระหว่างกระบวนการดีบัก API

ตัวอย่างโค้ด Node.js:

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

const text = process.argv[2]; // รับเนื้อหาการทดสอบจากอาร์กิวเมนต์บรรทัดคำสั่ง
const model = "gpt-4"; // แทนที่ด้วยโมเดล OpenAI ที่คุณต้องการใช้

const tokenCount = openaiTokenCounter.text(text, model);
const characterCount = text.length; // คำนวณจำนวนอักขระ

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

จากนั้นคุณควรเปลี่ยนชื่อสคริปต์ Node.js เป็น gpt-tokens-counter.js และวางไว้ในไดเรกทอรีโปรแกรมภายนอกของ Apidog เพื่อเรียกใช้

ถัดไป คุณจะต้องติดตั้ง OpenAI GPT Token Counter บนคอมพิวเตอร์ของคุณ ในการดำเนินการดังกล่าว คุณสามารถใช้คำสั่งต่อไปนี้ในเทอร์มินัลของคุณ:

npm install openai-gpt-token-counter

API อัตราแลกเปลี่ยนแบบเรียลไทม์​

หลังจากได้รับค่าโทเค็นสำหรับอินพุตและเอาต์พุต จำเป็นต้องประมาณต้นทุนเป็น JPY โดยใช้ API อัตราแลกเปลี่ยนแบบเรียลไทม์ บทความนี้จะเรียก API Currencylayer เพื่อรับอัตราแลกเปลี่ยนแบบเรียลไทม์ ลงทะเบียน สำหรับบัญชีและรับ API Key

การแปลงค่าอินพุตเป็นโทเค็นโดยใช้ Apidog

ค่าอินพุตสามารถเข้าใจได้ว่าเป็นคำถามและพรอมต์เมื่อผู้ใช้ให้มาในระหว่างการสอบถามแอปพลิเคชัน AI เพื่อใช้ประโยชน์จากสิ่งนี้ จำเป็นต้องเพิ่มสคริปต์แบบกำหนดเองใน Pre-Processors เพื่อดึงพารามิเตอร์ query จาก body ของคำขอ ตามด้วยการแปลงเป็นค่าโทเค็น

นี่คือตัวอย่างโค้ดสำหรับการเพิ่มสคริปต์การแปลงค่าโทเค็นในส่วน Pre-Processors:

try {
  var jsonData = JSON.parse(pm.request.body.raw);
  var content = jsonData.messages[0].content; // ได้รับเนื้อหาของข้อความ
  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("Input Tokens count: " + pm.environment.get("RESULT_INPUT_TOKENS"));
} catch (e) {
    console.log(e);
}

หลังจากกด Send ค่าอินพุตที่คำนวณได้ควรจะมองเห็นได้ในส่วนคอนโซล Apidog

แปลงโทเค็นเป็นต้นทุน JPY

หลังจากได้รับค่าโทเค็นที่ใช้ไปจากอินพุต จำเป็นต้องขอ API อัตราแลกเปลี่ยนแบบเรียลไทม์เพื่อรับตัวประกอบการแปลง ปัจจัยนี้จะถูกคูณด้วยค่าโทเค็นเพื่อคำนวณต้นทุนจริงเป็น JPY เพิ่มสคริปต์ต่อไปนี้ในการดำเนินการล่วงหน้า:

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");
    // ดึงตัวแปร RESULT_INPUT_TOKENS จากสคริปต์ก่อนหน้า
    var RESULT_INPUT_TOKENS = pm.environment.get("RESULT_INPUT_TOKENS");

    // คำนวณค่าอัตราแลกเปลี่ยนโทเค็น
    const tokensExchangeRate = 0.03; // ราคาของ 1000 โทเค็นใน USD (โดยมีราคาอินพุตบริบท GPT-4-8k เป็นข้อมูลอ้างอิง)

    // คำนวณราคาโดยประมาณเป็น JPY
    const JPYPrice = ((RESULT_INPUT_TOKENS / 1000) * tokensExchangeRate * USDJPY_RATE).toFixed(2);

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

    console.log("Estimated cost: " + "¥" + JPYPrice);
  }
});

การแปลงค่าเอาต์พุตเป็นโทเค็นโดยใช้ Apidog

Apidog จะแยกวิเคราะห์ข้อมูลที่ส่งคืนโดยอัตโนมัติเป็นเหตุการณ์ SSE (Server-Sent Events) เมื่อพารามิเตอร์ content-type ในการตอบสนองที่ส่งคืนโดย API มีบางอย่างเช่น text/event-stream

เริ่มต้นด้วยการไปที่ส่วน Post-Processors ในคำจำกัดความ API และเพิ่มสคริปต์แบบกำหนดเองสำหรับการดึงเนื้อหาการตอบสนองและการต่อข้อมูลให้เสร็จสมบูรณ์

// รับข้อความตอบสนอง
const text = pm.response.text()
// แยกข้อความเป็นบรรทัด
var lines = text.split('\n');
// สร้างอาร์เรย์เปล่าเพื่อจัดเก็บพารามิเตอร์ "content"
var contents = [];
// ทำซ้ำแต่ละบรรทัด
for (var i = 0; i < lines.length; i++) {
    const line = lines[i];
    // ข้ามบรรทัดที่ไม่ขึ้นต้นด้วย "data:"
    if (!line.startsWith('data:')) {
        continue;
    }
    // พยายามแยกวิเคราะห์ข้อมูล JSON
    try {
        var data = JSON.parse(line.substring(5).trim());  // ลบ "data: " ที่นำหน้า
        // รับพารามิเตอร์ "content" จากอาร์เรย์ "choices" และเพิ่มลงในอาร์เรย์
        contents.push(data.choices[0].delta.content);
    } catch (e) {
        // ละเว้นบรรทัดปัจจุบันหากไม่ใช่ข้อมูล JSON ที่ถูกต้อง
    }
}
// รวมพารามิเตอร์ "content" โดยใช้วิธี join()
var result = contents.join('');
// แสดงผลลัพธ์ในแท็บ "Visualize" ของเนื้อหา
pm.visualizer.set(result);
// พิมพ์ผลลัพธ์ไปยังคอนโซล
console.log(result);

หลังจากสร้างคำขอ คุณสามารถดึงเนื้อหาการตอบสนองทั้งหมดในคอนโซลได้!

การแปลงโทเค็นจากค่าเอาต์พุตโดยใช้ Apidog

เมื่อคุณได้รับเนื้อหาการตอบสนองแล้ว จำเป็นต้องแปลงเป็นค่าโทเค็น สิ่งนี้เป็นไปได้ด้วยไลบรารีของบุคคลที่สาม

เพิ่มสคริปต์แบบกำหนดเองในการดำเนินการหลังการประมวลผลเพื่อให้ Apidog สามารถเรียกใช้สคริปต์ gpt-toejsn-counter.js ภายนอกเพื่อรับค่าโทเค็น

ใช้หน้านี้เพื่อดูโค้ดเฉพาะ:

ด้วยตัวเลขที่คุณได้รับจากคอนโซล คุณสามารถประมาณได้ว่าจะมีค่าใช้จ่ายเท่าใด!

// รับข้อความตอบสนอง
const text = pm.response.text()
// แยกข้อความเป็นบรรทัด
var lines = text.split('\n');
// สร้างอาร์เรย์เปล่าเพื่อจัดเก็บพารามิเตอร์ "content"
var contents = [];
// ทำซ้ำแต่ละบรรทัด
for (var i = 0; i < lines.length; i++) {
    const line = lines[i];
    // ข้ามบรรทัดที่ไม่ขึ้นต้นด้วย "data:"
    if (!line.startsWith('data:')) {
        continue;
    }
    // พยายามแยกวิเคราะห์ข้อมูล JSON
    try {
        var data = JSON.parse(line.substring(5).trim());  // ลบ "data: " ที่นำหน้า
        // รับพารามิเตอร์ "content" จากอาร์เรย์ "choices" และเพิ่มลงในอาร์เรย์
        contents.push(data.choices[0].delta.content);
    } catch (e) {
        // ละเว้นบรรทัดปัจจุบันหากไม่ใช่ข้อมูล JSON ที่ถูกต้อง
    }
}
// รวมพารามิเตอร์ "content" โดยใช้วิธี join()
var result = contents.join('');
// แสดงผลลัพธ์ในแท็บ "Visualize" ของเนื้อหา
pm.visualizer.set(result);
// พิมพ์ผลลัพธ์ไปยังคอนโซล
console.log(result);

// คำนวณจำนวนโทเค็นเอาต์พุต
var RESULT_OUTPUT_TOKENS = pm.execute('./gpt-tokens/gpt-tokens-counter.js', [result])
pm.environment.set("RESULT_OUTPUT_TOKENS", RESULT_OUTPUT_TOKENS);

console.log("Output Tokens count: " + pm.environment.get("RESULT_OUTPUT_TOKENS")); 

แปลงโทเค็นเอาต์พุตเป็นต้นทุน JPY

คล้ายกับรูปแบบการคำนวณต้นทุนที่กล่าวถึงในส่วนก่อนหน้า ต้นทุนจริง (JPY) ได้มาจากการคูณค่าโทเค็นด้วยอัตราแลกเปลี่ยน

เพิ่มสคริปต์ต่อไปนี้ในการดำเนินการหลังการประมวลผล:

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");
    // รับตัวแปร RESULT_OUTPUT_TOKENS จากสคริปต์ postman ก่อนหน้า
    var RESULT_OUTPUT_TOKENS = pm.environment.get("RESULT_OUTPUT_TOKENS");

    // คำนวณอัตราแลกเปลี่ยนโทเค็น
    const tokensExchangeRate = 0.06; // ราคา USD ต่อ 1000 โทเค็น (อิงตามราคาอินพุตบริบท GPT-4-8k)

    // คำนวณราคาโดยประมาณเป็น JPY
    const JPYPrice = ((RESULT_OUTPUT_TOKENS / 1000) * tokensExchangeRate * USDJPY_RATE).toFixed(2);

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

    console.log("Output cost (JPY): " + JPYPrice + "円");
  }
});

คำนวณต้นทุนทั้งหมดเป็น JPY

สุดท้าย เพิ่มสคริปต์แบบกำหนดเองในขั้นตอนหลังการประมวลผลที่สามารถคำนวณต้นทุนทั้งหมดของอินพุตและเอาต์พุตโดยอัตโนมัติ

// การรวมต้นทุนอินพุตและเอาต์พุต

const INPUTPrice = Number(pm.environment.get("INPUT_PRICE"));
// รับตัวแปรราคาอินพุตและแปลงเป็นตัวเลข

const OUTPUTPrice = Number(pm.environment.get("OUTPUT_PRICE"));
// รับตัวแปรราคาเอาต์พุตและแปลงเป็นตัวเลข

console.log("Total cost: " + "￥" + (INPUTPrice + OUTPUTPrice));
// พิมพ์ต้นทุนทั้งหมด: ผลรวมของราคาอินพุตและราคาเอาต์พุต

ช่วยให้ประมาณต้นทุนโดยประมาณของคำขอปัจจุบันในระหว่างกระบวนการดีบัก API

ทำงานบน OpenAI API ด้วย Apidog

ดังที่กล่าวไว้ก่อนหน้านี้ Apidog เป็นเครื่องมือ API ที่ครอบคลุม ซึ่งให้การออกแบบ API การจัดทำเอกสาร การทดสอบ และการดีบักทั้งหมดภายในแอปพลิเคชันเดียว

ด้วย API อื่นๆ อีกนับไม่ถ้วน เช่น OpenAI คุณสามารถค้นหาและเข้าถึงโปรเจกต์ API ของบุคคลที่สามเหล่านี้ได้ด้วยบริการ API Hub ของ Apidog

ในการเข้าถึงโปรเจกต์ Open API บน API hub ให้คลิกลิงก์ด้านล่าง คุณสามารถเข้าถึง API ทั้งหมดที่ OpenAI มอบให้ได้!