Gemini API 使用教程：免费 API 接口接入指南【2026完整版】

Gemini API 完整使用教程

作为开发者，如果你想将 Gemini 的强大能力集成到自己的应用中，使用 API 是最佳选择。本教程将详细介绍如何使用免费的 Gemini API 接口，包括完整的代码示例和最佳实践。

🚀 免费 Gemini API 入口

大可AI - 免费 Gemini API： https://free.dakeai.cc

✅ 完全免费，无需付费 ✅ 支持 Gemini 3 Pro、2.5 Pro ✅ 稳定可靠，响应快速 ✅ 完整文档和示例

大可AI - 网页版测试： http://dakegpt.shuangrenchengxing.com/chat.php

先在网页版测试效果，再集成 API

一、为什么选择 Gemini API？

Gemini API 的核心优势

1. 强大的能力

多模态支持： 处理文本、图像、视频
逻辑推理： 强大的推理和分析能力
代码生成： 支持20+种编程语言
长上下文： 支持超长对话历史
多语言： 优秀的多语言支持

2. 易于集成

RESTful API： 标准的 HTTP 接口
多语言SDK： Python、JavaScript、Java等
详细文档： 完整的API文档和示例
快速响应： 毫秒级响应时间

3. 免费使用

通过大可AI提供的免费 API：

✅ 完全免费
✅ 无调用次数限制
✅ 支持最新模型
✅ 稳定可靠

二、API 快速入门

获取 API 访问

步骤1：访问 API 平台 打开：https://free.dakeai.cc

步骤2：查看文档 阅读 API 文档，了解接口规范

步骤3：获取接口地址 记录 API endpoint 和调用方法

步骤4：开始调用 使用任何编程语言调用 API

基础调用示例

Python 示例

import requests
import json

def call_gemini_api(prompt, model="gemini-3-pro"):
    """
    调用 Gemini API

    参数:
        prompt: 用户输入的问题
        model: 使用的模型（gemini-3-pro, gemini-2.5-pro等）

    返回:
        API 响应结果
    """
    # API 端点
    api_url = "https://free.dakeai.cc/api/chat"

    # 请求数据
    payload = {
        "model": model,
        "messages": [
            {
                "role": "user",
                "content": prompt
            }
        ],
        "temperature": 0.7,
        "max_tokens": 2000
    }

    # 请求头
    headers = {
        "Content-Type": "application/json"
    }

    try:
        # 发送请求
        response = requests.post(
            api_url,
            headers=headers,
            data=json.dumps(payload),
            timeout=30
        )

        # 检查响应
        if response.status_code == 200:
            result = response.json()
            return result['choices'][0]['message']['content']
        else:
            return f"Error: {response.status_code}"

    except Exception as e:
        return f"Exception: {str(e)}"

# 使用示例
if __name__ == "__main__":
    # 提问
    question = "用Python写一个快速排序算法"

    # 调用API
    answer = call_gemini_api(question)

    # 输出结果
    print("问题：", question)
    print("\n回答：", answer)

JavaScript (Node.js) 示例

const axios = require('axios');

/**
 * 调用 Gemini API
 * @param {string} prompt - 用户问题
 * @param {string} model - 模型名称
 * @returns {Promise<string>} - API响应
 */
async function callGeminiAPI(prompt, model = 'gemini-3-pro') {
    const apiUrl = 'https://free.dakeai.cc/api/chat';

    const payload = {
        model: model,
        messages: [
            {
                role: 'user',
                content: prompt
            }
        ],
        temperature: 0.7,
        max_tokens: 2000
    };

    try {
        const response = await axios.post(apiUrl, payload, {
            headers: {
                'Content-Type': 'application/json'
            },
            timeout: 30000
        });

        if (response.status === 200) {
            return response.data.choices[0].message.content;
        } else {
            return `Error: ${response.status}`;
        }
    } catch (error) {
        return `Exception: ${error.message}`;
    }
}

// 使用示例
async function main() {
    const question = "解释一下JavaScript的闭包概念";
    const answer = await callGeminiAPI(question);

    console.log('问题：', question);
    console.log('\n回答：', answer);
}

main();

cURL 示例

curl -X POST https://free.dakeai.cc/api/chat \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3-pro",
    "messages": [
      {
        "role": "user",
        "content": "介绍一下量子计算"
      }
    ],
    "temperature": 0.7,
    "max_tokens": 2000
  }'

三、API 参数详解

请求参数

参数	类型	必填	说明	示例
model	string	是	使用的模型名称	“gemini-3-pro”
messages	array	是	对话消息数组	见下方说明
temperature	float	否	温度参数(0-1)	0.7
max_tokens	int	否	最大生成长度	2000
top_p	float	否	核采样参数(0-1)	0.9
stream	boolean	否	是否流式返回	false

Messages 数组格式

{
  "messages": [
    {
      "role": "system",
      "content": "你是一个专业的编程助手"
    },
    {
      "role": "user",
      "content": "用户的问题"
    },
    {
      "role": "assistant",
      "content": "AI的回答"
    },
    {
      "role": "user",
      "content": "继续提问"
    }
  ]
}

角色说明：

system: 系统提示，设定AI的行为和角色
user: 用户的输入
assistant: AI的回答

可用模型列表

模型名称	说明	适用场景
gemini-3-pro	最新旗舰模型	复杂任务、高要求场景
gemini-2.5-pro	强大均衡模型	通用场景、日常使用
gemini-2.5-flash	快速响应模型	需要快速回复的场景
gemini-2.0-flash	轻量高效模型	简单任务、高并发

温度参数（Temperature）

0.0 - 0.3: 更确定性，适合事实性问答
0.4 - 0.7: 平衡，适合大多数场景
0.8 - 1.0: 更创造性，适合创意写作

四、高级功能

多轮对话

def chat_with_history(messages_history):
    """
    支持上下文的多轮对话

    参数:
        messages_history: 历史消息列表
    """
    api_url = "https://free.dakeai.cc/api/chat"

    payload = {
        "model": "gemini-3-pro",
        "messages": messages_history,
        "temperature": 0.7
    }

    response = requests.post(
        api_url,
        headers={"Content-Type": "application/json"},
        json=payload
    )

    return response.json()['choices'][0]['message']['content']

# 使用示例
messages = []

# 第一轮
messages.append({"role": "user", "content": "什么是机器学习?"})
answer1 = chat_with_history(messages)
messages.append({"role": "assistant", "content": answer1})
print("回答1:", answer1)

# 第二轮
messages.append({"role": "user", "content": "它和深度学习有什么区别?"})
answer2 = chat_with_history(messages)
messages.append({"role": "assistant", "content": answer2})
print("回答2:", answer2)

# 第三轮
messages.append({"role": "user", "content": "举个实际应用的例子"})
answer3 = chat_with_history(messages)
print("回答3:", answer3)

流式响应

import requests

def stream_gemini_api(prompt):
    """
    流式调用 Gemini API，逐字返回结果
    """
    api_url = "https://free.dakeai.cc/api/chat"

    payload = {
        "model": "gemini-3-pro",
        "messages": [{"role": "user", "content": prompt}],
        "stream": True
    }

    response = requests.post(
        api_url,
        headers={"Content-Type": "application/json"},
        json=payload,
        stream=True
    )

    for line in response.iter_lines():
        if line:
            # 处理每一行数据
            chunk = line.decode('utf-8')
            print(chunk, end='', flush=True)

# 使用示例
stream_gemini_api("写一首关于春天的诗")

系统提示（System Prompt）

def call_with_system_prompt(prompt, system_message):
    """
    使用系统提示调用API
    """
    messages = [
        {
            "role": "system",
            "content": system_message
        },
        {
            "role": "user",
            "content": prompt
        }
    ]

    payload = {
        "model": "gemini-3-pro",
        "messages": messages
    }

    response = requests.post(
        "https://free.dakeai.cc/api/chat",
        headers={"Content-Type": "application/json"},
        json=payload
    )

    return response.json()['choices'][0]['message']['content']

# 示例：设定AI为Python专家
system_msg = "你是一位有20年经验的Python高级工程师，擅长代码优化和最佳实践。"
answer = call_with_system_prompt(
    "如何优化Python代码的性能？",
    system_msg
)
print(answer)

五、实战应用场景

场景1：聊天机器人

class GeminiChatBot:
    def __init__(self):
        self.api_url = "https://free.dakeai.cc/api/chat"
        self.conversation_history = []

    def chat(self, user_message):
        """发送消息并获取回复"""
        # 添加用户消息
        self.conversation_history.append({
            "role": "user",
            "content": user_message
        })

        # 调用API
        payload = {
            "model": "gemini-3-pro",
            "messages": self.conversation_history
        }

        response = requests.post(
            self.api_url,
            headers={"Content-Type": "application/json"},
            json=payload
        )

        # 获取回复
        reply = response.json()['choices'][0]['message']['content']

        # 添加到历史
        self.conversation_history.append({
            "role": "assistant",
            "content": reply
        })

        return reply

    def reset(self):
        """重置对话历史"""
        self.conversation_history = []

# 使用示例
bot = GeminiChatBot()
print(bot.chat("你好，请介绍一下自己"))
print(bot.chat("你能帮我做什么？"))
print(bot.chat("写一段Python代码"))

场景2：内容生成工具

class ContentGenerator:
    def __init__(self):
        self.api_url = "https://free.dakeai.cc/api/chat"

    def generate_article(self, topic, word_count=800):
        """生成文章"""
        prompt = f"写一篇关于'{topic}'的文章，字数约{word_count}字，要求内容专业、结构清晰、有深度。"

        return self._call_api(prompt)

    def generate_title(self, content):
        """生成标题"""
        prompt = f"为以下内容生成一个吸引人的标题（10-20字）：\n\n{content[:500]}"

        return self._call_api(prompt, temperature=0.9)

    def optimize_seo(self, content):
        """SEO优化"""
        prompt = f"分析以下内容，提供SEO优化建议（关键词、meta描述等）：\n\n{content}"

        return self._call_api(prompt)

    def _call_api(self, prompt, temperature=0.7):
        """内部API调用方法"""
        payload = {
            "model": "gemini-3-pro",
            "messages": [{"role": "user", "content": prompt}],
            "temperature": temperature
        }

        response = requests.post(
            self.api_url,
            headers={"Content-Type": "application/json"},
            json=payload
        )

        return response.json()['choices'][0]['message']['content']

# 使用示例
generator = ContentGenerator()

# 生成文章
article = generator.generate_article("人工智能的未来")
print("文章：\n", article)

# 生成标题
title = generator.generate_title(article)
print("\n标题：", title)

# SEO优化
seo_tips = generator.optimize_seo(article)
print("\nSEO建议：", seo_tips)

场景3：代码助手

class CodeAssistant:
    def __init__(self):
        self.api_url = "https://free.dakeai.cc/api/chat"
        self.system_prompt = "你是一位资深的全栈开发工程师，精通多种编程语言和框架。"

    def generate_code(self, description, language="Python"):
        """生成代码"""
        prompt = f"用{language}实现以下功能：{description}\n\n要求：\n1. 代码规范\n2. 添加注释\n3. 包含使用示例"

        return self._call_api(prompt)

    def debug_code(self, code, error_message):
        """调试代码"""
        prompt = f"以下代码出现错误，请帮我找出问题并提供修复方案：\n\n代码：\n```\n{code}\n```\n\n错误信息：\n{error_message}"

        return self._call_api(prompt)

    def optimize_code(self, code):
        """优化代码"""
        prompt = f"请优化以下代码，提高性能和可读性：\n\n```\n{code}\n```"

        return self._call_api(prompt)

    def explain_code(self, code):
        """解释代码"""
        prompt = f"详细解释以下代码的功能和实现原理：\n\n```\n{code}\n```"

        return self._call_api(prompt)

    def _call_api(self, prompt):
        """调用API"""
        messages = [
            {"role": "system", "content": self.system_prompt},
            {"role": "user", "content": prompt}
        ]

        payload = {
            "model": "gemini-3-pro",
            "messages": messages
        }

        response = requests.post(
            self.api_url,
            headers={"Content-Type": "application/json"},
            json=payload
        )

        return response.json()['choices'][0]['message']['content']

# 使用示例
assistant = CodeAssistant()

# 生成代码
code = assistant.generate_code("实现一个LRU缓存")
print("生成的代码：\n", code)

# 解释代码
explanation = assistant.explain_code(code)
print("\n代码解释：\n", explanation)

六、最佳实践

1. 错误处理

import time

def robust_api_call(prompt, max_retries=3):
    """
    带重试机制的API调用
    """
    for attempt in range(max_retries):
        try:
            response = requests.post(
                "https://free.dakeai.cc/api/chat",
                headers={"Content-Type": "application/json"},
                json={
                    "model": "gemini-3-pro",
                    "messages": [{"role": "user", "content": prompt}]
                },
                timeout=30
            )

            if response.status_code == 200:
                return response.json()['choices'][0]['message']['content']
            elif response.status_code == 429:  # 速率限制
                wait_time = 2 ** attempt  # 指数退避
                print(f"速率限制，等待{wait_time}秒后重试...")
                time.sleep(wait_time)
            else:
                print(f"API错误: {response.status_code}")
                return None

        except requests.exceptions.Timeout:
            print(f"请求超时，重试第{attempt + 1}次...")
            time.sleep(2)
        except Exception as e:
            print(f"异常: {str(e)}")
            return None

    return None

2. 性能优化

import asyncio
import aiohttp

async def async_api_call(session, prompt):
    """
    异步API调用
    """
    api_url = "https://free.dakeai.cc/api/chat"

    payload = {
        "model": "gemini-3-pro",
        "messages": [{"role": "user", "content": prompt}]
    }

    async with session.post(api_url, json=payload) as response:
        result = await response.json()
        return result['choices'][0]['message']['content']

async def batch_api_calls(prompts):
    """
    批量异步调用API
    """
    async with aiohttp.ClientSession() as session:
        tasks = [async_api_call(session, prompt) for prompt in prompts]
        return await asyncio.gather(*tasks)

# 使用示例
prompts = [
    "介绍Python",
    "介绍JavaScript",
    "介绍Java"
]

results = asyncio.run(batch_api_calls(prompts))
for prompt, result in zip(prompts, results):
    print(f"问题: {prompt}\n回答: {result}\n")

3. 缓存机制

import hashlib
import json
import time

class APICache:
    def __init__(self, cache_dir=".cache"):
        self.cache_dir = cache_dir
        os.makedirs(cache_dir, exist_ok=True)

    def get_cache_key(self, prompt):
        """生成缓存键"""
        return hashlib.md5(prompt.encode()).hexdigest()

    def get(self, prompt, max_age=3600):
        """获取缓存"""
        cache_key = self.get_cache_key(prompt)
        cache_file = os.path.join(self.cache_dir, f"{cache_key}.json")

        if os.path.exists(cache_file):
            with open(cache_file, 'r', encoding='utf-8') as f:
                cache_data = json.load(f)

            # 检查是否过期
            if time.time() - cache_data['timestamp'] < max_age:
                return cache_data['content']

        return None

    def set(self, prompt, content):
        """设置缓存"""
        cache_key = self.get_cache_key(prompt)
        cache_file = os.path.join(self.cache_dir, f"{cache_key}.json")

        cache_data = {
            'prompt': prompt,
            'content': content,
            'timestamp': time.time()
        }

        with open(cache_file, 'w', encoding='utf-8') as f:
            json.dump(cache_data, f, ensure_ascii=False, indent=2)

# 使用示例
cache = APICache()

def cached_api_call(prompt):
    # 先查缓存
    cached = cache.get(prompt)
    if cached:
        print("使用缓存结果")
        return cached

    # 调用API
    result = call_gemini_api(prompt)

    # 存入缓存
    cache.set(prompt, result)

    return result

七、常见问题

Q1: API 是否免费？

A: 是的，大可AI提供的 Gemini API 完全免费，无调用次数限制。

Q2: 有速率限制吗？

A: 免费版本有合理的速率限制，正常使用不受影响。如遇限制，请稍后重试。

Q3: 支持哪些编程语言？

A: 支持所有能发送 HTTP 请求的编程语言，包括：

Python
JavaScript/Node.js
Java
PHP
Go
Ruby
C#
等等

Q4: 如何处理超时？

A: 建议：

设置合理的超时时间（30秒）
实现重试机制
使用指数退避策略

Q5: 可以商用吗？

A: 可以，但请遵守使用规范，不要滥用。

Q6: 数据安全吗？

A: 建议不要发送敏感信息，所有数据请做脱敏处理。

Q7: 支持哪些模型？

A: 支持 Gemini 全系列模型：

Gemini 3 Pro
Gemini 2.5 Pro
Gemini 2.5 Flash
Gemini 2.0 Flash

Q8: 如何获取技术支持？

A: 访问 https://free.dakeai.cc 查看文档和示例。

八、总结

Gemini API 为开发者提供了强大的 AI 能力，通过大可AI的免费接口，您可以：

💎 免费使用最新的 Gemini 3 Pro
💎 无调用次数限制
💎 稳定快速的服务
💎 完整的功能支持
💎 详细的文档和示例

立即开始

🌐 免费 API 接口： https://free.dakeai.cc

💻 网页版测试： http://dakegpt.shuangrenchengxing.com/chat.php

开始将 Gemini 的强大能力集成到您的应用中吧！

最后更新： 2026年1月3日

Gemini API 完整使用教程#

🚀 免费 Gemini API 入口#

一、为什么选择 Gemini API？#

Gemini API 的核心优势#

1. 强大的能力#

2. 易于集成#

3. 免费使用#

二、API 快速入门#

获取 API 访问#

基础调用示例#

Python 示例#

JavaScript (Node.js) 示例#

cURL 示例#

三、API 参数详解#

请求参数#

Messages 数组格式#

可用模型列表#

温度参数（Temperature）#

四、高级功能#

多轮对话#

流式响应#

系统提示（System Prompt）#

五、实战应用场景#

场景1：聊天机器人#

场景2：内容生成工具#

场景3：代码助手#

六、最佳实践#

1. 错误处理#

2. 性能优化#

3. 缓存机制#

七、常见问题#

Q1: API 是否免费？#

Q2: 有速率限制吗？#

Q3: 支持哪些编程语言？#

Q4: 如何处理超时？#

Q5: 可以商用吗？#

Q6: 数据安全吗？#

Q7: 支持哪些模型？#

Q8: 如何获取技术支持？#

八、总结#

立即开始#