TL;DR
ใช้ Gemini 4 Carbon API ใน CometAPI เพื่อเพิ่มความสามารถด้านการให้เหตุผลและการวิเคราะห์เอกสารให้กับแอปของคุณผ่านอินเทอร์เฟซ GenerateContent แบบเนทีฟของ Gemini เริ่มจากคำขอสั้นๆ ตรวจสอบให้แน่ใจว่าการสร้างผลลัพธ์เสร็จสมบูรณ์ และบันทึกคำตอบ ก่อนค่อยเพิ่มอินพุตแบบ PDF, รูปภาพ, สตรีมมิง หรือ JSON ที่มีโครงสร้าง คู่มือนี้มีโค้ดการตั้งค่าและการจัดการผลลัพธ์สำหรับแต่ละขั้นตอน
Key Takeaways
- Model ID:
gemini-4-carbonไม่มีฟรีติ어 — ต้องมีการชำระเงินผ่าน Gemini API / Cloud Billing - หน้าต่างแบบรวม 1M โทเคน (อินพุต + การคิด + เอาต์พุต) ค่าดีฟอลต์ของเอาต์พุตสูงสุด ~65K; long decode ขยายได้เกือบ 1M
- ระดับการคิด:
low(เร็ว/ประหยัด),medium(ดีฟอลต์ สมดุล),high(ให้เหตุผลลึก) - ราคาแนะนำจนถึง 30 พ.ย. 2026: $2 / $10 ต่อ 1M โทเคน (อินพุตที่แคช $0.10) จะเพิ่มเป็นสองเท่าวันที่ 1 ธ.ค.
- เหมาะอย่างยิ่งสำหรับงานโค้ดเชิงตัวแทนระยะยาว การให้เหตุผลเชิงวิทยาศาสตร์ งานความรู้ และงานด้านความปลอดภัยไซเบอร์
- มี SDK ทางการ (google-genai) + เอ็นด์พอยต์ที่เข้ากันได้กับ OpenAI
- CometAPI มอบการเข้าถึงโปรดักชันที่ง่ายที่สุดด้วยคีย์เดียว อัตราแข่งขันได้ และสลับใช้ระหว่าง Gemini 4 Carbon, Claude และอีกกว่า 500 รุ่นได้อย่างราบรื่น
งานศิลป์เปิดตัว Gemini 4 Carbon ภาพ: Google ผลงานต้นฉบับ
What Is Gemini 4 Carbon API?
Gemini 4 Carbon คือโมเดลให้เหตุผลระดับแนวหน้าของ Google สำหรับเวิร์กโฟลว์ตัวแทนระยะยาว วิศวกรรมซอฟต์แวร์ที่ซับซ้อน ความปลอดภัยไซเบอร์ และการวิจัยทางวิทยาศาสตร์ สร้างบน Gemini 4 Argon โดยใช้การให้เหตุผลที่ลึกกว่าและวงจรการตรวจทานเพิ่มเติมเพื่อจัดการงานหลายขั้นตอนที่ต้องอาศัยการแก้ปัญหาอย่างต่อเนื่องมากกว่าคำตอบครั้งเดียว เมื่อเทียบกับ Argon แล้ว Carbon ถูกออกแบบมาสำหรับงานที่ต้องการมากกว่า ซึ่งให้ความสำคัญกับความแม่นยำและการทำงานให้สำเร็จมากกว่าการลดการใช้โทเคน Google ประกาศ การเข้าถึงสำหรับนักพัฒนาที่ต้องชำระเงินเมื่อ 10 พฤศจิกายน 2026 ความสามารถ มัลติโหมดของอินพุต ให้คุณผสานข้อความกับภาพและมีเดียอื่นๆ ได้ โดยเอาต์พุตที่สร้างเป็นข้อความ CometAPI มีการเข้าถึง API ในราคาพิเศษ
สำหรับการผสาน API ให้เริ่มจากงานเดียวที่คุณตรวจสอบผลได้: สรุปเอกสาร ดึงฟิลด์จากโน้ตเหตุการณ์ หรือรีวิวสกรีนช็อต เวิร์กโฟลว์ตัวแทนที่กว้างขึ้นสามารถต่อยอดจากคำขอที่ใช้งานได้จริงนั้นหลังจากคุณยืนยันเครื่องมือและพฤติกรรมการตอบที่รองรับแล้ว
Other Ways to Use It
- Google AI Studio Playground: เลือกรุ่นและทดสอบพรอมป์ตแบบอินเทอร์แอ็กทีฟ (ต้องมีการเข้าถึงแบบชำระเงินสำหรับ Carbon)
- Gemini app / AI Mode / Antigravity: ใช้ได้หากคุณมี Google AI Ultra (เลือกรุ่นในที่ที่รองรับ)
- องค์กร / คลาวด์: ใช้งานผ่าน Gemini Enterprise Agent Platform หรือเอ็นด์พอยต์สไตล์ Vertex ด้วย Model ID เดียวกัน (ตั้งค่าโปรเจ็กต์ + โลเคชัน)
- นักวิทยาศาสตร์/นักวิจัยอาจสมัครขอการเข้าถึงฟรีแบบจำกัดในบางกรณี
What Are the Gemini 4 Carbon API Specifications ?
สเปกของโมเดลอย่างเป็นทางการ แยกงบประมาณบริบทร่วมออกจากขีดจำกัดเอาต์พุตของแต่ละเซกเมนต์ foreground ข้อจำกัดเหล่านี้เป็นระดับโมเดล; เกตเวย์ของคุณอาจมีข้อจำกัดด้านขนาดคำขอและฟีเจอร์เพิ่มเติม
Limitations and API Considerations
ก่อนขยายการผสาน ตรวจสอบว่า Carbon จัดการบริบท การตั้งค่าการสร้าง การแคช และการเข้าถึงอย่างไร ตารางต่อไปนี้จับคู่ข้อจำกัดกับแนวทางปฏิบัติจริงเพื่อหลีกเลี่ยงคำขอไม่ถูกต้อง ผลลัพธ์ไม่ครบถ้วน และค่าใช้จ่ายที่ไม่คาดคิด
คู่มือสำหรับนักพัฒนาของ Google เกี่ยวกับ Carbon อยู่ที่ ลิงก์นี้ และ model card กล่าวถึงความน่าเชื่อถือและข้อจำกัดการเข้าถึงเฉพาะ ตรวจสอบฟีเจอร์บนเส้นทาง CometAPI ของคุณก่อนเปิดใช้จริง
Thinking Levels: How to Choose the Right Setting
เริ่มจาก MEDIUM จากนั้นปรับระดับตามงานและคุณภาพที่คุณต้องการ
- LOW: ใช้สำหรับงานง่ายๆ เช่น การดึงข้อมูล การจัดประเภท และสรุป เมื่อให้ความสำคัญกับเวลาและต้นทุน ลองใช้กับงานอย่างการติดป้ายทิกเก็ตซัพพอร์ต และตรวจสอบว่ายังตรงเป้าความแม่นยำที่ต้องการ
- MEDIUM: จุดเริ่มต้นดีฟอลต์สำหรับงานโค้ดทั่วไป การวิเคราะห์เอกสาร และการให้เหตุผลเป็นประจำ เป็นฐานที่ดีสำหรับประเมินว่าการเปลี่ยนระดับช่วยให้งานของคุณดีขึ้นหรือไม่
- HIGH: ใช้สำหรับดีบักซับซ้อน งานวิจัยหลายขั้น และการให้เหตุผลเชิงวิทยาศาสตร์ที่ได้ประโยชน์จากการสำรวจลึก อนุญาตโทเคนการคิดเพิ่ม และใช้ต่อเมื่อคุณภาพที่เพิ่มขึ้นคุ้มกับต้นทุนและเวลา
ระดับที่สูงกว่าไม่ได้การันตีผลลัพธ์ที่ดีกว่าสำหรับทุกงาน ทดสอบเวิร์กโหลดของคุณเองและเปรียบเทียบคุณภาพการทำงานเสร็จ เวลาหน่วง และการใช้โทเคนรวมก่อนเปลี่ยนค่าในโปรดักชัน
How Does Gemini 4 Carbon Perform on AI Benchmarks?
Selected Benchmark Results
หน้า Artificial Analysis Carbon (High) และ Argon (High) แสดงสแน็ปช็อตนี้ ตรวจเมื่อ 12 พฤศจิกายน 2026 นี่คือผลเบนช์มาร์ก ไม่ใช่การวัดเวลาแฝงของ CometAPI
ยอดรวมโทเคนเอาต์พุตครอบคลุมการประเมิน ไม่ใช่คำขอเดียว ต้นทุนต่อภารกิจใช้สมมติฐานราคาของ Artificial Analysis ไม่ใช่อัตราส่วนลดปัจจุบันของ CometAPI Carbon รอนานกว่าก่อนโทเคนคำตอบแรก แต่ทำงานเสร็จเร็วกว่าพร้อมต้นทุนที่รายงานต่ำกว่า; ปริมาณโทเคนเพียงอย่างเดียวไม่ได้กำหนดมูลค่า
ใช้ Carbon เมื่อการตรวจทานลึกช่วยให้งานที่ยาก เช่น โค้ดรีวิว งานวิจัย หรือสิ่งที่ผิดพลาดแล้วมีต้นทุนสูงดีขึ้น ทดสอบ Argon กับงานโค้ดและความรู้ประจำ แต่ยืนยันการประหยัดบนเวิร์กโหลดของคุณเอง ใช้พรอมป์ตเดียวกันและเปรียบเทียบค่าใช้จ่ายรวมต่อผลลัพธ์ที่ยอมรับ พร้อมทั้งเวลาเสร็จและอัตราความล้มเหลว
How Do You start with the Gemini 4 Carbon API in CometAPI?
คุณจะต้องมีบัญชี CometAPI ที่เข้าถึงรุ่นนี้และมีเครดิตเพียงพอ สภาพแวดล้อม Python และความคุ้นเคยเบื้องต้นในการรันสคริปต์ ใช้ไดเรกทอรีโปรเจ็กต์สำหรับไฟล์ด้านล่างเพื่อให้แต่ละตัวอย่างนำเข้าการตั้งค่าคลไคลเอนต์เดียวกันได้
Why Use Gemini 4 Carbon API Through CometAPI?
CometAPI มีประโยชน์เมื่อคุณต้องการประเมิน Carbon ควบคู่กับรุ่นอื่นๆ พร้อมจัดการการเข้าถึงและการเรียกเก็บเงินผ่านผู้ให้บริการรายเดียว เส้นทาง Carbon ของมันมีทั้ง GenerateContent แบบเนทีฟของ Gemini และอินเทอร์เฟซ Chat ที่เข้ากันได้กับ OpenAI เพื่อให้คุณเลือกฟอร์แมตคำขอที่เหมาะกับแอปของคุณ
สำหรับคู่มือนี้ เส้นทางแบบเนทีฟช่วยให้คุณใช้ซ้ำ Google Gen AI SDK ด้วยคีย์และ base URL ของ CometAPI ราคากลุ่มดีฟอลต์ปัจจุบันต่ำกว่าราคาแนะนำของ Google 20% เก็บ Model ID ไว้ในการตั้งค่าเพื่อให้คุณเปรียบเทียบ Carbon และ Argon ได้โดยไม่ต้องเขียนแอปใหม่ และตรวจสอบการรองรับเฉพาะเส้นทางก่อนเพิ่มเครื่องมือ อัปโหลดไฟล์ หรือการต่อเนื่องที่ยาว
Step 1: Create Your Account and Set Your API Key
ลงชื่อเข้าใช้ CometAPI สร้างหรือเปิดคีย์ API และเก็บไว้เป็นตัวแปรสภาพแวดล้อม หลีกเลี่ยงการใส่คีย์ไว้ในซอร์สโค้ดหรือคอมมิตลงรีโป
ใช้คำสั่งตามเชลล์ของคุณ ตั้งค่าตัวแปรในเทอร์มินัลเดียวกับที่คุณจะใช้รัน Python; แทนที่คีย์ตัวอย่างด้วยคีย์ของคุณเอง
ตั้งค่าคีย์และโมเดลใน PowerShell
$env:COMETAPI_KEY = "YOUR_COMETAPI_KEY"
$env:COMETAPI_MODEL = "gemini-4-carbon"
ตั้งค่าคีย์และโมเดลใน Bash
export COMETAPI_KEY="YOUR_COMETAPI_KEY"
export COMETAPI_MODEL="gemini-4-carbon"
Step 2: Install the SDK and Configure the Endpoint
ติดตั้ง SDK ในสภาพแวดล้อมโปรเจ็กต์ของคุณ การใช้ python -m pip ช่วยให้ตัวติดตั้งผูกกับตัวอินเตอร์พรีเตอร์ที่ใช้รันตัวอย่าง
ติดตั้งหรืออัปเดต Google Gen AI SDK
python -m pip install --upgrade google-genai
CometAPI มีเอกสาร เอ็นด์พอยต์ Gemini แบบเนทีฟ พร้อม base URL แบบกำหนดเองใน SDK ใช้คีย์ CometAPI ของคุณกับเอ็นด์พอยต์นี้ การตั้งค่าด้านล่างใช้กับคำขอ GenerateContent
Step 3: Create a Reusable Client and Validate Responses
บันทึกการตั้งค่านี้เป็น carbon_client.py สคริปต์จะกำหนดไคลเอนต์ครั้งเดียวและเตรียม completed_text สำหรับการตอบแบบข้อความที่ใช้ในคู่มือนี้ ตัวช่วยจะตรวจสอบ เหตุผลการสิ้นสุดของผู้สมัคร ก่อนคืนข้อความคำตอบ ดังนั้นผลลัพธ์ที่ว่างหรือถูกตัดจะไม่ถูกปฏิบัติเป็นความสำเร็จโดยไม่ตั้งใจ
สร้าง carbon_client.py พร้อมไคลเอนต์ CometAPI และตัวตรวจสอบการตอบแบบข้อความ
import os
from google import genai
from google.genai import types
client = genai.Client(
api_key=os.environ["COMETAPI_KEY"],
http_options={
"api_version": "v1beta",
"base_url": "https://api.cometapi.com",
},
)
model = os.getenv("COMETAPI_MODEL", "gemini-4-carbon")
def completed_text(response):
if not response.candidates:
raise RuntimeError("No candidate returned; inspect prompt feedback.")
candidate = response.candidates[0]
reason = getattr(candidate.finish_reason, "value", candidate.finish_reason)
if reason != "STOP":
raise RuntimeError(f"Generation did not finish normally: {reason}")
parts = candidate.content.parts if candidate.content else []
text = "".join(
part.text or "" for part in (parts or []) if not part.thought
)
if not text.strip():
raise RuntimeError("The completed candidate contains no answer text.")
return text
Step 4: Send Your First Request and Check the Result
สร้าง first_request.py ข้าง carbon_client.py และเพิ่มโค้ดด้านล่าง ส่งพรอมป์ตเช็กลิสต์สั้นๆ โดยใช้การคิดระดับ MEDIUM และงบเอาต์พุต 4,096 โทเคน ตรวจสอบการเสร็จสิ้นด้วย completed_text(response) และบันทึกคำตอบเป็น answer.txt แบบ UTF-8 รัน python first_request.py จากไดเรกทอรีโปรเจ็กต์ จากนั้นเปิด answer.txt และยืนยันว่าทั้งห้าข้อในการรีวิวนั้นเกี่ยวข้องและใช้ได้ ตรวจสอบเมทาดาตาการใช้งานที่พิมพ์ออกมาเกี่ยวกับการใช้โทเคนรวมถึงการคิด; การสิ้นสุดปกติไม่ได้ยืนยันคุณภาพคำตอบ หากคำขอล้มเหลวหรือเอาต์พุตไม่ครบถ้วน ให้ใช้ส่วนแก้ไขปัญหาเพื่อตรวจสอบข้อมูลรับรอง รายละเอียดข้อผิดพลาด และเหตุผลการสิ้นสุดก่อนลองใหม่
from pathlib import Path
from carbon_client import client, model, types, completed_text
response = client.models.generate_content(
model=model,
contents="Give me a five-point checklist for reviewing a Python API client.",
config=types.GenerateContentConfig(
max_output_tokens=4096,
thinking_config=types.ThinkingConfig(thinking_level="MEDIUM"),
),
)
answer = completed_text(response)
Path("answer.txt").write_text(answer, encoding="utf-8")
print(answer)
print("Saved answer.txt")
if response.usage_metadata:
print(response.usage_metadata.model_dump(exclude_none=True))
python first_request.py
## How Can Gemini 4 Carbon API Analyze Files?
รันตัวอย่างเหล่านี้จากไดเรกทอรีเดียวกับ carbon_client.py สคริปต์จะโหลดไฟล์โลคอลเป็นอินพุตแบบ inline ทำให้เวิร์กโฟลว์เริ่มต้นไม่ต้องพึ่งบริการอัปโหลดไฟล์แยกต่างหาก
ความเข้าใจ PDF รวมเนื้อหาภาพ: Gemini สามารถตีความข้อความ ตาราง ชาร์ต และรูปภาพร่วมกันได้ [คู่มือประมวลผลเอกสารของ Google](https://ai.google.dev/gemini-api/docs/document-processing) อธิบายการรองรับ PDF สูงสุด 1,000 หน้า ภายใต้ข้อจำกัดขนาดไฟล์และบริบท จำนวนหน้าคือเพดาน ไม่ใช่การรับประกันว่าเอกสารทุกฉบับจะพอดีกับคำขอผ่านเกตเวย์
ใช้การป้อนแบบ inline สำหรับ PDF ขนาดเล็กและชั่วคราว สำหรับไฟล์ใหญ่หรือคำถามหลายรอบที่ซ้ำๆ Google แนะนำ Files API เพื่อลดการส่งไฟล์เต็มทุกครั้ง ก่อนใช้เวิร์กโฟลว์นั้นผ่าน CometAPI ให้ยืนยันเอ็นด์พอยต์อัปโหลดและการรองรับการอ้างอิงไฟล์ก่อน ตัวอย่างแบบ inline ด้านล่างยังเป็นจุดเริ่มต้นที่ใช้งานได้จริง
### Summarize a local PDF
Google มีเอกสารสำหรับ [อินพุต PDF แบบ inline](https://ai.google.dev/gemini-api/docs/document-processing) สำหรับ GenerateContent วางไฟล์ report.pdf ที่มีขนาดเล็กและไม่อ่อนไหวในไดเรกทอรีโปรเจ็กต์ แล้วบันทึกสคริปต์ต่อไปนี้เป็น analyze_pdf.py และรัน python analyze_pdf.py
ส่ง PDF โลคอลและบันทึกสรุปที่เสร็จสมบูรณ์
from pathlib import Path
from carbon_client import client, model, types, completed_text
response = client.models.generate_content(
model=model,
contents=[
types.Part.from_bytes(
data=Path("report.pdf").read_bytes(),
mime_type="application/pdf",
),
"Summarize this report in five bullets. Do not invent missing figures.",
],
config=types.GenerateContentConfig(max_output_tokens=4096),
)
summary = completed_text(response)
Path("report_summary.txt").write_text(summary, encoding="utf-8")
print(summary)
ตรวจสอบสรุปกับไฟล์ก่อนขยายไปยังเอกสารที่ใหญ่ขึ้น ขนาดคำขอและการรองรับการอ้างอิงไฟล์ขึ้นกับเกตเวย์ การรองรับฟอร์แมต Office หรือการอ้างอิง Cloud Storage ของ Google ไม่ได้ยืนยันโดยตัวมันเองว่ารองรับผ่านเส้นทาง CometAPI ของคุณ
### Review a local screenshot
สำหรับ [อินพุตรูปภาพแบบ inline](https://ai.google.dev/gemini-api/docs/image-understanding) ให้ MIME type ตรงกับไฟล์ วาง PNG ชื่อ screen.png ข้างสคริปต์ บันทึกตัวอย่างนี้เป็น analyze_image.py และรัน python analyze_image.py เพื่อรีวิวข้อความและเลย์เอาต์ที่มองเห็นได้
วิเคราะห์ PNG สกรีนช็อตโดยไม่ต้องพึ่ง URL สาธารณะ
from pathlib import Path
from carbon_client import client, model, types, completed_text
response = client.models.generate_content(
model=model,
contents=[
types.Part.from_bytes(
data=Path("screen.png").read_bytes(),
mime_type="image/png",
),
"Review this screenshot for unreadable text and overlapping elements. "
"Describe only visible issues and identify their locations.",
],
config=types.GenerateContentConfig(max_output_tokens=4096),
)
print(completed_text(response))
เทียบทุกปัญหาที่รายงานกับสกรีนช็อต หากคุณส่ง JPEG ให้เปลี่ยนทั้งชื่อไฟล์และ MIME type ให้ตรงกัน; การเปลี่ยนแค่นามสกุลไฟล์ไม่แปลงภาพ
## How Do You Stream Gemini 4 Carbon Responses ?
### Display streamed text and check completion
การสตรีมส่งชิ้นส่วนผลลัพธ์กลับมาเป็น Server-Sent Events (SSE) ช่วยให้แอปแสดงเอาต์พุตบางส่วนระหว่างที่การสร้างยังดำเนินต่อ
SDK เปิดเผย [การสร้างข้อความแบบสตรีม](https://ai.google.dev/gemini-api/docs/text-generation) ผ่าน generate_content_stream สำหรับ HTTP โดยตรง CometAPI ใช้ streamGenerateContent ด้วย alt=sse
บันทึกสคริปต์ต่อไปนี้เป็น stream_response.py และรัน python stream_response.py สคริปต์จะแสดงข้อความตามที่มาถึง จากนั้นตรวจสอบว่าโฟลว์จบด้วยเหตุผลการสิ้นสุดปกติ ข้อยกเว้นจะทำให้ข้อความที่แสดงเป็นผลลัพธ์บางส่วน ไม่ใช่คำตอบที่ยอมรับ
อ่านข้อความสตรีมและกำหนดให้สิ้นสุดปกติก่อนยอมรับ
from carbon_client import client, model, types
finish_reason = None
received_text = False
for chunk in client.models.generate_content_stream(
model=model,
contents="Write a concise checklist for investigating intermittent API timeouts.",
config=types.GenerateContentConfig(max_output_tokens=4096),
):
if not chunk.candidates:
continue
candidate = chunk.candidates[0]
if candidate.finish_reason is not None:
finish_reason = getattr(candidate.finish_reason, "value", candidate.finish_reason)
parts = candidate.content.parts if candidate.content else []
for part in parts or []:
if part.text and not part.thought:
received_text = True
print(part.text, end="", flush=True)
print()
if finish_reason != "STOP" or not received_text:
raise RuntimeError(f"Stream not accepted as complete: {finish_reason}")
### Extract structured JSON
สำหรับ [เอาต์พุตแบบมีสคีมาบังคับ](https://ai.google.dev/gemini-api/docs/structured-output) ให้ร้องขอ application/json และกำหนดฟิลด์ที่แอปของคุณคาดหวัง ตัวอย่างนี้ดึงสองฟิลด์จากโน้ตเหตุการณ์สั้นๆ จากนั้นตรวจสอบชนิดก่อนพิมพ์ผลลัพธ์
บันทึกตัวอย่างนี้เป็น structured_output.py และรัน python structured_output.py สคริปต์ใช้ตัวตรวจสอบการตอบก่อนจะแปลง JSON
ดึงฟิลด์เหตุการณ์ ตรวจสอบการเสร็จสิ้น และยืนยันชนิดของฟิลด์
import json
from carbon_client import client, model, types, completed_text
response = client.models.generate_content(
model=model,
contents=(
"Extract the service and impact from this incident note: "
"The checkout API returned errors for ten minutes during a database restart."
),
config=types.GenerateContentConfig(
max_output_tokens=4096,
response_mime_type="application/json",
response_schema={
"type": "OBJECT",
"properties": {
"service": {"type": "STRING"},
"impact": {"type": "STRING"},
},
"required": ["service", "impact"],
},
),
)
data = json.loads(completed_text(response))
if not isinstance(data, dict) or not all(
isinstance(data.get(field), str) for field in ("service", "impact")
):
raise ValueError("The response does not match the expected field types.")
print(json.dumps(data, indent=2))
คุณควรได้รับอ็อบเจ็กต์ที่มี service และ impact การสอดคล้องสคีมาไม่ได้ยืนยันความถูกต้องของข้อเท็จจริง: เทียบค่าที่ดึงออกมากับอินพุต และใช้กฎธุรกิจก่อนจัดเก็บหรือดำเนินการต่อ
## Gemini 4 Carbon API Price
[ราคาแนะนำของ Google](https://blog.google/innovation-and-ai/models-and-research/gemini-models/gemini-4-carbon-now-available/) มีผลถึง 30 พฤศจิกายน 2026; อัตรามาตรฐานมีผล 1 ธันวาคม ตรวจอัตราปัจจุบันในบัญชีของคุณก่อนวางงบประมาณคำขอถัดไป
ทั้งสองรุ่นอยู่ในตระกูล Gemini 4 แต่มุ่งเน้นเวิร์กโหลดต่างกัน
| API pricing tier | Input / 1M tokens | Output / 1M tokens |
| ------------------------- | ----------------- | ------------------ |
| Standard (through Nov 30) | $2.00 | $10.00 |
| Standard (from Dec 1) | $4.00 | $20.00 |
| Batch (through Nov 30) | $1.00 | $5.00 |
| Batch (from Dec 1) | $2.00 | $10.00 |
| Flex (through Nov 30) | $1.00 | $5.00 |
| Priority (through Nov 30) | $3.60 | $18.00 |
รายละเอียดราคาเพิ่มเติม:
* อินพุตที่แคช: $0.10 ต่อหนึ่งล้านโทเคนถึง 30 พฤศจิกายน เพิ่มเป็น $0.20 ตั้งแต่ 1 ธันวาคม
* Batch และ Flex ให้การประมวลผลต้นทุนต่ำกว่าสำหรับเวิร์กโหลดที่ยอมรับคุณลักษณะการให้บริการของพวกมันได้
* โทเคนการคิดถูกคิดราคาเป็นเอาต์พุต
* โทเคนที่ใช้โดยคำสั่งเครื่องมือภายในและประกาศฟังก์ชันก็อาจคิดราคาได้เช่นกัน
Google แนะนำ Argon สำหรับงานวิศวกรรมซอฟต์แวร์และงานความรู้ส่วนใหญ่ โดยสำรอง Carbon ไว้สำหรับงานที่ต้องการการให้เหตุผลลึกและการตรวจทานขยาย
ข้อแนะนำเชิงปฏิบัติ: เลือก Carbon เมื่อต้นทุนของคำตอบที่ผิดมีค่าสูง หรือเมื่องานต้องการการสำรวจและการตรวจทานอย่างมาก เลือก Argon เมื่อคุณต้องการการให้เหตุผลที่แข็งแกร่งด้วยงบโทเคนที่มีประสิทธิภาพกว่า
### CometAPI Price
เมื่อเช็คเมื่อ 12 พฤศจิกายน 2026 [ตารางราคากลุ่มดีฟอลต์ของ CometAPI](https://www.cometapi.com/models/google/gemini-4-carbon/) ระบุ $1.60 ต่อหนึ่งล้านโทเคนสำหรับอินพุต $8.00 ต่อหนึ่งล้านโทเคนสำหรับเอาต์พุตรวมการคิด และ $0.08 ต่อหนึ่งล้านโทเคนสำหรับอินพุตที่แคชเมื่อแคชฮิต อัตราเหล่านี้ต่ำกว่าราคาแนะนำของ Google 20%
ราคาของ CometAPI อาจเปลี่ยนตามอัตราทางการของ Google เปรียบเทียบอัตราทางการปัจจุบันกับส่วนลดในบัญชีของคุณ แทนที่จะถือว่าราคาวันนี้คงที่ หากส่วนลด 20% เดิมยังคงอยู่หลังการเปลี่ยนราคา อัตราของคุณจะเท่ากับอัตราทางการใหม่ × 0.80; ยืนยันอัตราจริงของ CometAPI ก่อนวางงบประมาณ กลุ่มบัญชีอื่นๆ อาจมีส่วนลดต่างกัน
สำหรับคำขอที่มีอินพุต 100,000 โทเคน (ไม่แคช) และเอาต์พุต 10,000 โทเคน รวมการคิด ต้นทุนเฉพาะโทเคนคือ $0.24 ที่อัตรา CometAPI ที่ระบุ: $0.16 สำหรับอินพุต และ $0.08 สำหรับเอาต์พุต ปริมาณเดียวกันมีต้นทุน $0.30 ที่อัตราแนะนำของ Google หรือ $0.60 ที่อัตราเดือนธันวาคม โทเคนรวม 110,000 อยู่ในงบประมาณร่วมของโมเดล
การประมาณนี้ไม่รวมเครื่องมือ รีไทร และการปรับราคาเฉพาะบัญชี ต้นทุนเอาต์พุตรวมโทเคนการคิด ดังนั้นระดับการให้เหตุผลที่สูงขึ้นอาจเพิ่มบิลได้ แม้คำตอบที่มองเห็นจะสั้น
### How to Optimize Gemini 4 Carbon API Costs?
ปรับให้เหมาะกับต้นทุนของผลลัพธ์ที่ถูกต้องและใช้งานได้ คำขอที่ถูกกว่าไม่คุ้มค่าหากคุณต้องทำซ้ำหรือซ่อมคำตอบด้วยมือ
1. เลือกการให้เหตุผลอย่างมีเป้าหมาย เริ่มที่ MEDIUM ทดสอบ LOW สำหรับงานง่าย และใช้ HIGH เมื่อช่วยเพิ่มอัตรายอมรับจนคุ้มกับเวลาและโทเคน
2. ใช้ซ้ำบริบทที่คงที่ผ่านการแคชโดยปริยาย เวิร์กโฟลว์ของ [Argon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-argon) และ [Carbon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-carbon) ของ Google ไม่รองรับการสร้างแคชบริบทแบบชัดแจ้ง; รองรับการแคชโดยปริยาย วางคำแนะนำและเอกสารที่ใช้ซ้ำได้ไว้ก่อน ตามด้วยคำถามที่เปลี่ยนแปลง Google ระบุสิทธิ์สำหรับคำนำร่วมอย่างน้อย 4,096 โทเคน ยืนยันการฮิตของแคชและค่าบนเส้นทาง CometAPI ของคุณ; การทำซ้ำไม่ได้การันตีส่วนลด
3. ลดงานที่ไม่จำเป็น ส่งหน้า/ส่วนที่เกี่ยวข้อง ขอเฉพาะฟิลด์เอาต์พุตที่ต้องใช้ และตั้งงบเอาต์พุตให้เพียงพอ โทเคนการคิดนับรวมเอาต์พุต ดังนั้นการจำกัดน้อยเกินไปอาจทำให้ถูกตัดและต้องรีไทร
4. วัดทั้งเวิร์กโฟลว์ รวมการให้เหตุผล การใช้เครื่องมือ รีไทร และคำตอบที่ถูกปฏิเสธในค่าใช้จ่ายรวม บันทึกการตอบที่ถูกต้องเพื่อไม่ให้ความล้มเหลวปลายทางไปกระตุ้นการสร้างใหม่
5. เลือกเส้นทางตามคุณค่าที่พิสูจน์ได้ เปรียบเทียบ Carbon และ Argon กับงานเดียวกัน พิจารณา Batch หรือ Flex เมื่อผู้ให้บริการรองรับและเวิร์กโหลดยอมรับลักษณะการให้บริการของพวกมันได้
ติดตามต้นทุนต่อผลลัพธ์ที่ยอมรับ = ค่าใช้จ่ายเวิร์กโฟลว์ทั้งหมด ÷ ผลลัพธ์ที่ยอมรับ ทบทวนร่วมกับเวลาและคุณภาพหลังการเปลี่ยนโมเดล พรอมป์ต หรือระดับการให้เหตุผล
## Which API Format Should You Use for Gemini 4 Carbon?
นักพัฒนาสามารถเข้าถึง [Gemini 4 Carbon API ใน CometAPI](https://www.cometapi.com/models/google/gemini-4-carbon/) ผ่าน Gemini API แบบเนทีฟและ OpenAI-compatible Chat API ใช้อินเทอร์เฟซที่ตรงกับฟอร์แมตคำขอของแอปคุณและความต้องการฟีเจอร์ตามเอกสาร
| Interface | When it fits | Integration check |
| ----------------------------- | ---------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- |
| Gemini-native GenerateContent | ตัวอย่าง Python และ REST ในคู่มือนี้; แอปที่ใช้งาน contents และ generationConfig อยู่แล้ว | ใช้ Gemini base URL และชื่อฟิลด์ตามที่แสดงด้านบน |
| OpenAI-compatible Chat API | แอปที่มีโครงสร้างรอบข้อความแชทอยู่แล้ว | ตรวจสอบเอ็นด์พอยต์ เส้นทาง ฟิลด์ และฟีเจอร์ที่รองรับของ Carbon ก่อนดัดแปลงโค้ด |
ความเข้ากันได้อ้างถึงเอ็นด์พอยต์และรูปแบบคำขอที่เฉพาะเจาะจง อย่าส่งฟิลด์ของ OpenAI Responses ไปยังเอ็นด์พอยต์ Gemini แบบเนทีฟ หรือสันนิษฐานว่าเส้นทาง Chat-compatible จะรองรับ Responses ด้วย แอปที่เปิดใช้เครื่องมือต้องมีรอบการทำงานตั้งแต่การเรียกฟังก์ชันไปจนถึงผลลัพธ์ที่เข้าคู่กันอย่างยืนยันได้ ไม่ใช่เพียงพรอมป์ตข้อความที่สำเร็จ
## How to Migrate from Gemini 4 Argon to Gemini 4 Carbon API?
หากแอป Argon ของคุณใช้เส้นทาง GenerateContent แบบเนทีฟของ CometAPI อยู่แล้ว เริ่มจากสลับโมเดลที่ตั้งค่าเป็น gemini-4-carbon คงคีย์ base URL พรอมป์ต และลอจิกการตรวจสอบผลเหมือนเดิมสำหรับการเปรียบเทียบครั้งแรก ทั้ง [Argon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-argon) และ [Carbon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-carbon) แชร์ธรรมเนียมคำขอ Gemini 4 จำนวนมาก; ทำความสะอาดพารามิเตอร์แบบ legacy เฉพาะเมื่อฟิลด์เหล่านั้นยังอยู่ในแอปของคุณ
### 1. Change the model and run a controlled comparison
ในชุดการตั้งค่าของคู่มือนี้ เปลี่ยน COMETAPI_MODEL จาก gemini-4-argon เป็น gemini-4-carbon แล้วรีสตาร์ทโปรเซส Python เพื่อโหลดตัวแปรใหม่ ใช้พรอมป์ตตัวแทนและระดับการคิดเดียวกันสำหรับทั้งสองรุ่น ตัวอย่างสแตนด์อโลนต่อไปนี้ใช้ carbon_client.py และเลือก Carbon โดยชัดเจน:
from carbon_client import client, types, completed_text
response = client.models.generate_content(
model="gemini-4-carbon",
contents="Review this function for correctness: def add(a, b): return a + b",
config=types.GenerateContentConfig(
max_output_tokens=4096,
thinking_config=types.ThinkingConfig(thinking_level="MEDIUM"),
),
)
print(completed_text(response))
### 2. Check request settings and conversation history
คงค่า LOW, MEDIUM หรือ HIGH บน GenerateContent ลบ thinking_budget, MINIMAL หรือการใช้ cached_content แบบชัดแจ้งที่ยังเหลือออก อย่าใช้ temperature, top_p หรือ top_k เพื่อควบคุมผลลัพธ์ ลบค่า frequency_penalty, presence_penalty และ candidate_count ที่มากกว่า 1 หากคุณเรียกเครื่องมือ ให้คง ID การเรียกฟังก์ชัน ชื่อ และลำดับการตอบที่เข้าคู่กันไว้ เหล่านี้คือการตรวจสอบความเข้ากันได้ ไม่ใช่ฟีเจอร์ที่ Argon เพิ่งลบออก
### 3. Validate quality, cost, and latency before rollout
รันชุดทดสอบเดียวกันผ่านทั้งสองรุ่น ตรวจสอบความสำเร็จของงาน การตรวจ JSON การรันเครื่องมือ การเสร็จสมบูรณ์ ค่าโทเคนที่คิดเงิน และเวลาที่ใช้ เก็บการตั้งค่า Argon ไว้ เส้นทางทราฟฟิกส่วนเล็กไปยัง Carbon และขยายต่อเมื่อมันตรงกับเกณฑ์การยอมรับและงบประมาณของคุณ
### 4. Keep long-output support separate from the model switch
เริ่มจากคำขอที่จบในหนึ่งเซกเมนต์ foreground หากคุณต้องการการต่อเนื่อง ให้ยืนยันก่อนว่า CometAPI รองรับเอ็นด์พอยต์และฟิลด์การตอบที่ต้องการ การเปลี่ยนชื่อโมเดลเพียงอย่างเดียวไม่เปิดใช้งานเวิร์กโฟลว์การต่อเนื่อง v1beta1 ของ Google บนเกตเวย์ v1beta ในคู่มือนี้ เก็บเอาต์พุตบางส่วนไว้ว่าไม่สมบูรณ์จนกว่าการสร้างจะเสร็จสมบูรณ์ตามปกติ
## Conclusion
ใช้คำขอที่สำเร็จครั้งแรกเป็นจุดเริ่มต้นของการทดสอบการผสาน เพิ่มเฉพาะประเภทอินพุตและรูปแบบการตอบที่แอปของคุณต้องการ จากนั้นตรวจสอบเอาต์พุตที่ครบถ้วน การจัดการข้อผิดพลาด และต้นทุนกับงานตัวแทน ส่งทราฟฟิกส่วนเล็กผ่านการผสานใหม่ก่อนขยาย และคงการตั้งค่าที่ทราบว่าใช้งานได้ไว้เผื่อผลลัพธ์เปลี่ยน
## Gemini 4 Carbon FAQ
### How large is Gemini 4 Carbon's context window?
Gemini 4 Carbon รองรับขีดจำกัดบริบทแบบรวมอินพุตและเอาต์พุต 1,048,576 โทเคน งบประมาณนี้รวมอินพุต การให้เหตุผล การเรียกฟังก์ชัน และเอาต์พุตที่สร้าง
### What are Gemini 4 Carbon's strongest benchmarks?
ผลที่โดดเด่นตามรายงาน ได้แก่ 88.2% บน SEC-bench Pro, 54.8% บน ExploitGym, 71.0% บน CWE-bench และ 96.2% บน GraphWalks ซึ่งเน้นความสามารถด้านความปลอดภัยไซเบอร์ บริบทยาว และการให้เหตุผลเชิงตัวแทน
### How does Gemini 4 Carbon compare with Gemini 4 Argon?
Carbon ปรับปรุงอย่างมากเหนือ Argon บนหลายเบนช์มาร์กที่รายงาน รวมถึง Artificial Analysis Intelligence Index (59 เทียบกับ 50), SWE-sweep (9.6% เทียบกับ 4.3%) และ SEC-bench Pro (88.2% เทียบกับ 83.4%) ความแตกต่างหลักคือประสิทธิภาพที่แข็งแกร่งกว่าในการให้เหตุผลแบบขยายและงานตัวแทนที่ซับซ้อน
### Is Gemini 4 Carbon better than Claude Opus 5.5?
ไม่มีรุ่นใดนำทุกเบนช์มาร์ก Carbon ทำคะแนนสูงกว่าใน Artificial Analysis Intelligence Index, Terminal-Bench 4.0, GraphWalks และการประเมินด้านความปลอดภัยไซเบอร์ ขณะที่ Claude Opus 5.5 นำใน OSWorld-2.1 และ FrontierSWE 2 ตามการเปรียบเทียบที่ Google เผยแพร่
### What thinking levels does Gemini 4 Carbon support?
Gemini 4 Carbon รองรับระดับ LOW, MEDIUM และ HIGH โดย MEDIUM เป็นค่าเริ่มต้น นักพัฒนาสามารถใช้การตั้งค่าเหล่านี้เพื่อปรับสมดุลความลึกของการให้เหตุผล เวลาหน่วง และการใช้โทเคน
### Can Gemini 4 Carbon process images, audio, and video?
ได้ โมเดลการ์ดระบุการรองรับอินพุตแบบข้อความ รูปภาพ เสียง และวิดีโอ โดยโหมดเอาต์พุตที่เอกสารไว้คือข้อความ
### What is Gemini 4 Carbon's knowledge cutoff?
โมเดลการ์ดเดือนพฤศจิกายน 2026 ของ Google ระบุจุดตัดความรู้ที่มีนาคม 2026 ดังนั้นโมเดลอาจไม่มีความรู้เหตุการณ์และพัฒนาการหลังจากนั้น เว้นแต่จะจัดให้ผ่านเครื่องมือภายนอกหรือบริบทที่ผู้ใช้ให้มา