Overview

Provider Type

API

API Endpoint


                                                        https://generativelanguage.googleapis.com/v1beta

Free Tier Highlights

5-30 RPM (varies by model)

Why Choose Google AI Studio?

Google AI Studio stands out for its exceptional performance and speed. With a developer-friendly API and comprehensive documentation, you can integrate AI capabilities into your applications within minutes.

Quick Start Guide

Sign in to Google AI Studio

Get API Key

Start Building

Available Models

Model Name	ID	Context	Capabilities
Gemini 3.1 Flash-Lite Free	`gemini-3.1-flash-lite`	1 000 000 Context	-
Gemini 3.5 Flash-Lite Free	`gemini-3.5-flash-lite`	1 000 000 Context	-
Gemini 3.5 Flash Free	`gemini-3.5-flash`	1 000 000 Context	-
Gemini 3.6 Flash Free	`gemini-3.6-flash`	1 000 000 Context	-
Gemini 3.7 Flash Free	`gemini-3.7-flash`	1 000 000 Context	-
Gemini 3.8 Flash Free	`gemini-3.8-flash`	1 000 000 Context	-
Gemini 3.1 Pro No Longer Free	`gemini-3.1-pro`	2 000 000 Context5 Requests per minute	Thinking Reasoning Multimodal
Gemini 3.1 Flash No Longer Free	`gemini-3.1-flash`	1 000 000 Context15 Requests per minute	Thinking Multimodal
Gemini 3.0 Flash No Longer Free	`gemini-3.0-flash`	1 000 000 Context30 Requests per minute	Multimodal
Gemini 3.0 Flash-Lite No Longer Free	`gemini-3.0-flash-lite`	1 000 000 Context30 Requests per minute	-
Gemini 2.5 Flash Free	`gemini-2.5-flash`	1 000 000 Context15 Requests per minute	Thinking Multimodal
Gemini 2.5 Pro Free	`gemini-2.5-pro`	1 000 000 Context5 Requests per minute	Thinking Reasoning Multimodal
Gemini 2.0 Flash No Longer Free	`gemini-2.0-flash`	1 000 000 Context15 Requests per minute	Multimodal
Gemini 2.0 Flash Thinking No Longer Free	`gemini-2.0-flash-thinking-exp`	1 000 000 Context10 Requests per minute	Thinking Reasoning
Gemini 1.5 Flash No Longer Free	`gemini-1.5-flash`	1 000 000 Context15 Requests per minute	Multimodal
Gemini 1.5 Pro No Longer Free	`gemini-1.5-pro`	2 000 000 Context2 Requests per minute	Reasoning

Integration Examples

Ready-to-use code snippets for your applications.

Select a Model

Select Model

main.py

import requests
import os

# Get your API key from https://aistudio.google.com/
api_key = "YOUR_API_KEY"
url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-3.1-flash-lite:generateContent?key={api_key}"

headers = {
    "Content-Type": "application/json"
}

data = {
    "contents": [{
        "parts": [{"text": "Explain how AI works"}]
    }]
}

response = requests.post(url, headers=headers, json=data)
print(response.json())

index.js

// Get your API key from https://aistudio.google.com/
const apiKey = 'YOUR_API_KEY';
const url = `https://generativelanguage.googleapis.com/v1beta/models/gemini-3.1-flash-lite:generateContent?key=${apiKey}`;

const response = await fetch(url, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    contents: [{
      parts: [{ text: 'Explain how AI works' }]
    }]
  })
});

const data = await response.json();
console.log(data);

terminal

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.1-flash-lite:generateContent?key=YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
  "contents": [{
    "parts": [{"text": "Explain how AI works"}]
  }]
}'

example.php

<?php
$apiKey = 'YOUR_API_KEY';
$url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.1-flash-lite:generateContent?key=$apiKey";

$data = [
    "contents" => [
        ["parts" => [["text" => "Explain quantum mechanics"]]]
    ]
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>

main.go

package main

import (
    "context"
    "fmt"
    "log"
    "github.com/google/generative-ai-go/genai"
    "google.golang.org/api/option"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, option.WithAPIKey("YOUR_API_KEY"))
    if err != nil { log.Fatal(err) }
    defer client.Close()

    model := client.GenerativeModel("gemini-3.1-flash-lite")
    resp, err := model.GenerateContent(ctx, genai.Text("Explain quantum mechanics"))
    if err != nil { log.Fatal(err) }
    
    // ...
}

main.py

import requests
import os

# Get your API key from https://aistudio.google.com/
api_key = "YOUR_API_KEY"
url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-3.5-flash-lite:generateContent?key={api_key}"

headers = {
    "Content-Type": "application/json"
}

data = {
    "contents": [{
        "parts": [{"text": "Explain how AI works"}]
    }]
}

response = requests.post(url, headers=headers, json=data)
print(response.json())

index.js

// Get your API key from https://aistudio.google.com/
const apiKey = 'YOUR_API_KEY';
const url = `https://generativelanguage.googleapis.com/v1beta/models/gemini-3.5-flash-lite:generateContent?key=${apiKey}`;

const response = await fetch(url, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    contents: [{
      parts: [{ text: 'Explain how AI works' }]
    }]
  })
});

const data = await response.json();
console.log(data);

terminal

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.5-flash-lite:generateContent?key=YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
  "contents": [{
    "parts": [{"text": "Explain how AI works"}]
  }]
}'

example.php

<?php
$apiKey = 'YOUR_API_KEY';
$url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.5-flash-lite:generateContent?key=$apiKey";

$data = [
    "contents" => [
        ["parts" => [["text" => "Explain quantum mechanics"]]]
    ]
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>

main.go

package main

import (
    "context"
    "fmt"
    "log"
    "github.com/google/generative-ai-go/genai"
    "google.golang.org/api/option"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, option.WithAPIKey("YOUR_API_KEY"))
    if err != nil { log.Fatal(err) }
    defer client.Close()

    model := client.GenerativeModel("gemini-3.5-flash-lite")
    resp, err := model.GenerateContent(ctx, genai.Text("Explain quantum mechanics"))
    if err != nil { log.Fatal(err) }
    
    // ...
}

main.py

import requests
import os

# Get your API key from https://aistudio.google.com/
api_key = "YOUR_API_KEY"
url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-3.5-flash:generateContent?key={api_key}"

headers = {
    "Content-Type": "application/json"
}

data = {
    "contents": [{
        "parts": [{"text": "Explain how AI works"}]
    }]
}

response = requests.post(url, headers=headers, json=data)
print(response.json())

index.js

// Get your API key from https://aistudio.google.com/
const apiKey = 'YOUR_API_KEY';
const url = `https://generativelanguage.googleapis.com/v1beta/models/gemini-3.5-flash:generateContent?key=${apiKey}`;

const response = await fetch(url, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    contents: [{
      parts: [{ text: 'Explain how AI works' }]
    }]
  })
});

const data = await response.json();
console.log(data);

terminal

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.5-flash:generateContent?key=YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
  "contents": [{
    "parts": [{"text": "Explain how AI works"}]
  }]
}'

example.php

<?php
$apiKey = 'YOUR_API_KEY';
$url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.5-flash:generateContent?key=$apiKey";

$data = [
    "contents" => [
        ["parts" => [["text" => "Explain quantum mechanics"]]]
    ]
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>

main.go

package main

import (
    "context"
    "fmt"
    "log"
    "github.com/google/generative-ai-go/genai"
    "google.golang.org/api/option"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, option.WithAPIKey("YOUR_API_KEY"))
    if err != nil { log.Fatal(err) }
    defer client.Close()

    model := client.GenerativeModel("gemini-3.5-flash")
    resp, err := model.GenerateContent(ctx, genai.Text("Explain quantum mechanics"))
    if err != nil { log.Fatal(err) }
    
    // ...
}

main.py

import requests
import os

# Get your API key from https://aistudio.google.com/
api_key = "YOUR_API_KEY"
url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-3.6-flash:generateContent?key={api_key}"

headers = {
    "Content-Type": "application/json"
}

data = {
    "contents": [{
        "parts": [{"text": "Explain how AI works"}]
    }]
}

response = requests.post(url, headers=headers, json=data)
print(response.json())

index.js

// Get your API key from https://aistudio.google.com/
const apiKey = 'YOUR_API_KEY';
const url = `https://generativelanguage.googleapis.com/v1beta/models/gemini-3.6-flash:generateContent?key=${apiKey}`;

const response = await fetch(url, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    contents: [{
      parts: [{ text: 'Explain how AI works' }]
    }]
  })
});

const data = await response.json();
console.log(data);

terminal

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.6-flash:generateContent?key=YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
  "contents": [{
    "parts": [{"text": "Explain how AI works"}]
  }]
}'

example.php

<?php
$apiKey = 'YOUR_API_KEY';
$url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.6-flash:generateContent?key=$apiKey";

$data = [
    "contents" => [
        ["parts" => [["text" => "Explain quantum mechanics"]]]
    ]
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>

main.go

package main

import (
    "context"
    "fmt"
    "log"
    "github.com/google/generative-ai-go/genai"
    "google.golang.org/api/option"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, option.WithAPIKey("YOUR_API_KEY"))
    if err != nil { log.Fatal(err) }
    defer client.Close()

    model := client.GenerativeModel("gemini-3.6-flash")
    resp, err := model.GenerateContent(ctx, genai.Text("Explain quantum mechanics"))
    if err != nil { log.Fatal(err) }
    
    // ...
}

main.py

import requests
import os

# Get your API key from https://aistudio.google.com/
api_key = "YOUR_API_KEY"
url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-3.7-flash:generateContent?key={api_key}"

headers = {
    "Content-Type": "application/json"
}

data = {
    "contents": [{
        "parts": [{"text": "Explain how AI works"}]
    }]
}

response = requests.post(url, headers=headers, json=data)
print(response.json())

index.js

// Get your API key from https://aistudio.google.com/
const apiKey = 'YOUR_API_KEY';
const url = `https://generativelanguage.googleapis.com/v1beta/models/gemini-3.7-flash:generateContent?key=${apiKey}`;

const response = await fetch(url, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    contents: [{
      parts: [{ text: 'Explain how AI works' }]
    }]
  })
});

const data = await response.json();
console.log(data);

terminal

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.7-flash:generateContent?key=YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
  "contents": [{
    "parts": [{"text": "Explain how AI works"}]
  }]
}'

example.php

<?php
$apiKey = 'YOUR_API_KEY';
$url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.7-flash:generateContent?key=$apiKey";

$data = [
    "contents" => [
        ["parts" => [["text" => "Explain quantum mechanics"]]]
    ]
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>

main.go

package main

import (
    "context"
    "fmt"
    "log"
    "github.com/google/generative-ai-go/genai"
    "google.golang.org/api/option"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, option.WithAPIKey("YOUR_API_KEY"))
    if err != nil { log.Fatal(err) }
    defer client.Close()

    model := client.GenerativeModel("gemini-3.7-flash")
    resp, err := model.GenerateContent(ctx, genai.Text("Explain quantum mechanics"))
    if err != nil { log.Fatal(err) }
    
    // ...
}

main.py

import requests
import os

# Get your API key from https://aistudio.google.com/
api_key = "YOUR_API_KEY"
url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash:generateContent?key={api_key}"

headers = {
    "Content-Type": "application/json"
}

data = {
    "contents": [{
        "parts": [{"text": "Explain how AI works"}]
    }]
}

response = requests.post(url, headers=headers, json=data)
print(response.json())

index.js

// Get your API key from https://aistudio.google.com/
const apiKey = 'YOUR_API_KEY';
const url = `https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash:generateContent?key=${apiKey}`;

const response = await fetch(url, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    contents: [{
      parts: [{ text: 'Explain how AI works' }]
    }]
  })
});

const data = await response.json();
console.log(data);

terminal

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash:generateContent?key=YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
  "contents": [{
    "parts": [{"text": "Explain how AI works"}]
  }]
}'

example.php

<?php
$apiKey = 'YOUR_API_KEY';
$url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash:generateContent?key=$apiKey";

$data = [
    "contents" => [
        ["parts" => [["text" => "Explain quantum mechanics"]]]
    ]
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>

main.go

package main

import (
    "context"
    "fmt"
    "log"
    "github.com/google/generative-ai-go/genai"
    "google.golang.org/api/option"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, option.WithAPIKey("YOUR_API_KEY"))
    if err != nil { log.Fatal(err) }
    defer client.Close()

    model := client.GenerativeModel("gemini-3.8-flash")
    resp, err := model.GenerateContent(ctx, genai.Text("Explain quantum mechanics"))
    if err != nil { log.Fatal(err) }
    
    // ...
}

main.py

import requests
import os

# Get your API key from https://aistudio.google.com/
api_key = "YOUR_API_KEY"
url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-3.1-pro:generateContent?key={api_key}"

headers = {
    "Content-Type": "application/json"
}

data = {
    "contents": [{
        "parts": [{"text": "Explain how AI works"}]
    }]
}

response = requests.post(url, headers=headers, json=data)
print(response.json())

index.js

// Get your API key from https://aistudio.google.com/
const apiKey = 'YOUR_API_KEY';
const url = `https://generativelanguage.googleapis.com/v1beta/models/gemini-3.1-pro:generateContent?key=${apiKey}`;

const response = await fetch(url, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    contents: [{
      parts: [{ text: 'Explain how AI works' }]
    }]
  })
});

const data = await response.json();
console.log(data);

terminal

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.1-pro:generateContent?key=YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
  "contents": [{
    "parts": [{"text": "Explain how AI works"}]
  }]
}'

example.php

<?php
$apiKey = 'YOUR_API_KEY';
$url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.1-pro:generateContent?key=$apiKey";

$data = [
    "contents" => [
        ["parts" => [["text" => "Explain quantum mechanics"]]]
    ]
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>

main.go

package main

import (
    "context"
    "fmt"
    "log"
    "github.com/google/generative-ai-go/genai"
    "google.golang.org/api/option"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, option.WithAPIKey("YOUR_API_KEY"))
    if err != nil { log.Fatal(err) }
    defer client.Close()

    model := client.GenerativeModel("gemini-3.1-pro")
    resp, err := model.GenerateContent(ctx, genai.Text("Explain quantum mechanics"))
    if err != nil { log.Fatal(err) }
    
    // ...
}

main.py

import requests
import os

# Get your API key from https://aistudio.google.com/
api_key = "YOUR_API_KEY"
url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-3.1-flash:generateContent?key={api_key}"

headers = {
    "Content-Type": "application/json"
}

data = {
    "contents": [{
        "parts": [{"text": "Explain how AI works"}]
    }]
}

response = requests.post(url, headers=headers, json=data)
print(response.json())

index.js

// Get your API key from https://aistudio.google.com/
const apiKey = 'YOUR_API_KEY';
const url = `https://generativelanguage.googleapis.com/v1beta/models/gemini-3.1-flash:generateContent?key=${apiKey}`;

const response = await fetch(url, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    contents: [{
      parts: [{ text: 'Explain how AI works' }]
    }]
  })
});

const data = await response.json();
console.log(data);

terminal

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.1-flash:generateContent?key=YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
  "contents": [{
    "parts": [{"text": "Explain how AI works"}]
  }]
}'

example.php

<?php
$apiKey = 'YOUR_API_KEY';
$url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.1-flash:generateContent?key=$apiKey";

$data = [
    "contents" => [
        ["parts" => [["text" => "Explain quantum mechanics"]]]
    ]
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>

main.go

package main

import (
    "context"
    "fmt"
    "log"
    "github.com/google/generative-ai-go/genai"
    "google.golang.org/api/option"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, option.WithAPIKey("YOUR_API_KEY"))
    if err != nil { log.Fatal(err) }
    defer client.Close()

    model := client.GenerativeModel("gemini-3.1-flash")
    resp, err := model.GenerateContent(ctx, genai.Text("Explain quantum mechanics"))
    if err != nil { log.Fatal(err) }
    
    // ...
}

main.py

import requests
import os

# Get your API key from https://aistudio.google.com/
api_key = "YOUR_API_KEY"
url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-3.0-flash:generateContent?key={api_key}"

headers = {
    "Content-Type": "application/json"
}

data = {
    "contents": [{
        "parts": [{"text": "Explain how AI works"}]
    }]
}

response = requests.post(url, headers=headers, json=data)
print(response.json())

index.js

// Get your API key from https://aistudio.google.com/
const apiKey = 'YOUR_API_KEY';
const url = `https://generativelanguage.googleapis.com/v1beta/models/gemini-3.0-flash:generateContent?key=${apiKey}`;

const response = await fetch(url, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    contents: [{
      parts: [{ text: 'Explain how AI works' }]
    }]
  })
});

const data = await response.json();
console.log(data);

terminal

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.0-flash:generateContent?key=YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
  "contents": [{
    "parts": [{"text": "Explain how AI works"}]
  }]
}'

example.php

<?php
$apiKey = 'YOUR_API_KEY';
$url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.0-flash:generateContent?key=$apiKey";

$data = [
    "contents" => [
        ["parts" => [["text" => "Explain quantum mechanics"]]]
    ]
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>

main.go

package main

import (
    "context"
    "fmt"
    "log"
    "github.com/google/generative-ai-go/genai"
    "google.golang.org/api/option"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, option.WithAPIKey("YOUR_API_KEY"))
    if err != nil { log.Fatal(err) }
    defer client.Close()

    model := client.GenerativeModel("gemini-3.0-flash")
    resp, err := model.GenerateContent(ctx, genai.Text("Explain quantum mechanics"))
    if err != nil { log.Fatal(err) }
    
    // ...
}

main.py

import requests
import os

# Get your API key from https://aistudio.google.com/
api_key = "YOUR_API_KEY"
url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-3.0-flash-lite:generateContent?key={api_key}"

headers = {
    "Content-Type": "application/json"
}

data = {
    "contents": [{
        "parts": [{"text": "Explain how AI works"}]
    }]
}

response = requests.post(url, headers=headers, json=data)
print(response.json())

index.js

// Get your API key from https://aistudio.google.com/
const apiKey = 'YOUR_API_KEY';
const url = `https://generativelanguage.googleapis.com/v1beta/models/gemini-3.0-flash-lite:generateContent?key=${apiKey}`;

const response = await fetch(url, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    contents: [{
      parts: [{ text: 'Explain how AI works' }]
    }]
  })
});

const data = await response.json();
console.log(data);

terminal

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.0-flash-lite:generateContent?key=YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
  "contents": [{
    "parts": [{"text": "Explain how AI works"}]
  }]
}'

example.php

<?php
$apiKey = 'YOUR_API_KEY';
$url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.0-flash-lite:generateContent?key=$apiKey";

$data = [
    "contents" => [
        ["parts" => [["text" => "Explain quantum mechanics"]]]
    ]
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>

main.go

package main

import (
    "context"
    "fmt"
    "log"
    "github.com/google/generative-ai-go/genai"
    "google.golang.org/api/option"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, option.WithAPIKey("YOUR_API_KEY"))
    if err != nil { log.Fatal(err) }
    defer client.Close()

    model := client.GenerativeModel("gemini-3.0-flash-lite")
    resp, err := model.GenerateContent(ctx, genai.Text("Explain quantum mechanics"))
    if err != nil { log.Fatal(err) }
    
    // ...
}

main.py

import requests
import os

# Get your API key from https://aistudio.google.com/
api_key = "YOUR_API_KEY"
url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent?key={api_key}"

headers = {
    "Content-Type": "application/json"
}

data = {
    "contents": [{
        "parts": [{"text": "Explain how AI works"}]
    }]
}

response = requests.post(url, headers=headers, json=data)
print(response.json())

index.js

// Get your API key from https://aistudio.google.com/
const apiKey = 'YOUR_API_KEY';
const url = `https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent?key=${apiKey}`;

const response = await fetch(url, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    contents: [{
      parts: [{ text: 'Explain how AI works' }]
    }]
  })
});

const data = await response.json();
console.log(data);

terminal

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent?key=YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
  "contents": [{
    "parts": [{"text": "Explain how AI works"}]
  }]
}'

example.php

<?php
$apiKey = 'YOUR_API_KEY';
$url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent?key=$apiKey";

$data = [
    "contents" => [
        ["parts" => [["text" => "Explain quantum mechanics"]]]
    ]
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>

main.go

package main

import (
    "context"
    "fmt"
    "log"
    "github.com/google/generative-ai-go/genai"
    "google.golang.org/api/option"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, option.WithAPIKey("YOUR_API_KEY"))
    if err != nil { log.Fatal(err) }
    defer client.Close()

    model := client.GenerativeModel("gemini-2.5-flash")
    resp, err := model.GenerateContent(ctx, genai.Text("Explain quantum mechanics"))
    if err != nil { log.Fatal(err) }
    
    // ...
}

main.py

import requests
import os

# Get your API key from https://aistudio.google.com/
api_key = "YOUR_API_KEY"
url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-pro:generateContent?key={api_key}"

headers = {
    "Content-Type": "application/json"
}

data = {
    "contents": [{
        "parts": [{"text": "Explain how AI works"}]
    }]
}

response = requests.post(url, headers=headers, json=data)
print(response.json())

index.js

// Get your API key from https://aistudio.google.com/
const apiKey = 'YOUR_API_KEY';
const url = `https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-pro:generateContent?key=${apiKey}`;

const response = await fetch(url, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    contents: [{
      parts: [{ text: 'Explain how AI works' }]
    }]
  })
});

const data = await response.json();
console.log(data);

terminal

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-pro:generateContent?key=YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
  "contents": [{
    "parts": [{"text": "Explain how AI works"}]
  }]
}'

example.php

<?php
$apiKey = 'YOUR_API_KEY';
$url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-pro:generateContent?key=$apiKey";

$data = [
    "contents" => [
        ["parts" => [["text" => "Explain quantum mechanics"]]]
    ]
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>

main.go

package main

import (
    "context"
    "fmt"
    "log"
    "github.com/google/generative-ai-go/genai"
    "google.golang.org/api/option"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, option.WithAPIKey("YOUR_API_KEY"))
    if err != nil { log.Fatal(err) }
    defer client.Close()

    model := client.GenerativeModel("gemini-2.5-pro")
    resp, err := model.GenerateContent(ctx, genai.Text("Explain quantum mechanics"))
    if err != nil { log.Fatal(err) }
    
    // ...
}

main.py

import requests
import os

# Get your API key from https://aistudio.google.com/
api_key = "YOUR_API_KEY"
url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key={api_key}"

headers = {
    "Content-Type": "application/json"
}

data = {
    "contents": [{
        "parts": [{"text": "Explain how AI works"}]
    }]
}

response = requests.post(url, headers=headers, json=data)
print(response.json())

index.js

// Get your API key from https://aistudio.google.com/
const apiKey = 'YOUR_API_KEY';
const url = `https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=${apiKey}`;

const response = await fetch(url, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    contents: [{
      parts: [{ text: 'Explain how AI works' }]
    }]
  })
});

const data = await response.json();
console.log(data);

terminal

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
  "contents": [{
    "parts": [{"text": "Explain how AI works"}]
  }]
}'

example.php

<?php
$apiKey = 'YOUR_API_KEY';
$url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$apiKey";

$data = [
    "contents" => [
        ["parts" => [["text" => "Explain quantum mechanics"]]]
    ]
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>

main.go

package main

import (
    "context"
    "fmt"
    "log"
    "github.com/google/generative-ai-go/genai"
    "google.golang.org/api/option"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, option.WithAPIKey("YOUR_API_KEY"))
    if err != nil { log.Fatal(err) }
    defer client.Close()

    model := client.GenerativeModel("gemini-2.0-flash")
    resp, err := model.GenerateContent(ctx, genai.Text("Explain quantum mechanics"))
    if err != nil { log.Fatal(err) }
    
    // ...
}

main.py

import requests
import os

# Get your API key from https://aistudio.google.com/
api_key = "YOUR_API_KEY"
url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash-thinking-exp:generateContent?key={api_key}"

headers = {
    "Content-Type": "application/json"
}

data = {
    "contents": [{
        "parts": [{"text": "Explain how AI works"}]
    }]
}

response = requests.post(url, headers=headers, json=data)
print(response.json())

index.js

// Get your API key from https://aistudio.google.com/
const apiKey = 'YOUR_API_KEY';
const url = `https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash-thinking-exp:generateContent?key=${apiKey}`;

const response = await fetch(url, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    contents: [{
      parts: [{ text: 'Explain how AI works' }]
    }]
  })
});

const data = await response.json();
console.log(data);

terminal

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash-thinking-exp:generateContent?key=YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
  "contents": [{
    "parts": [{"text": "Explain how AI works"}]
  }]
}'

example.php

<?php
$apiKey = 'YOUR_API_KEY';
$url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash-thinking-exp:generateContent?key=$apiKey";

$data = [
    "contents" => [
        ["parts" => [["text" => "Explain quantum mechanics"]]]
    ]
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>

main.go

package main

import (
    "context"
    "fmt"
    "log"
    "github.com/google/generative-ai-go/genai"
    "google.golang.org/api/option"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, option.WithAPIKey("YOUR_API_KEY"))
    if err != nil { log.Fatal(err) }
    defer client.Close()

    model := client.GenerativeModel("gemini-2.0-flash-thinking-exp")
    resp, err := model.GenerateContent(ctx, genai.Text("Explain quantum mechanics"))
    if err != nil { log.Fatal(err) }
    
    // ...
}

main.py

import requests
import os

# Get your API key from https://aistudio.google.com/
api_key = "YOUR_API_KEY"
url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key={api_key}"

headers = {
    "Content-Type": "application/json"
}

data = {
    "contents": [{
        "parts": [{"text": "Explain how AI works"}]
    }]
}

response = requests.post(url, headers=headers, json=data)
print(response.json())

index.js

// Get your API key from https://aistudio.google.com/
const apiKey = 'YOUR_API_KEY';
const url = `https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=${apiKey}`;

const response = await fetch(url, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    contents: [{
      parts: [{ text: 'Explain how AI works' }]
    }]
  })
});

const data = await response.json();
console.log(data);

terminal

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
  "contents": [{
    "parts": [{"text": "Explain how AI works"}]
  }]
}'

example.php

<?php
$apiKey = 'YOUR_API_KEY';
$url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=$apiKey";

$data = [
    "contents" => [
        ["parts" => [["text" => "Explain quantum mechanics"]]]
    ]
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>

main.go

package main

import (
    "context"
    "fmt"
    "log"
    "github.com/google/generative-ai-go/genai"
    "google.golang.org/api/option"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, option.WithAPIKey("YOUR_API_KEY"))
    if err != nil { log.Fatal(err) }
    defer client.Close()

    model := client.GenerativeModel("gemini-1.5-flash")
    resp, err := model.GenerateContent(ctx, genai.Text("Explain quantum mechanics"))
    if err != nil { log.Fatal(err) }
    
    // ...
}

main.py

import requests
import os

# Get your API key from https://aistudio.google.com/
api_key = "YOUR_API_KEY"
url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-pro:generateContent?key={api_key}"

headers = {
    "Content-Type": "application/json"
}

data = {
    "contents": [{
        "parts": [{"text": "Explain how AI works"}]
    }]
}

response = requests.post(url, headers=headers, json=data)
print(response.json())

index.js

// Get your API key from https://aistudio.google.com/
const apiKey = 'YOUR_API_KEY';
const url = `https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-pro:generateContent?key=${apiKey}`;

const response = await fetch(url, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    contents: [{
      parts: [{ text: 'Explain how AI works' }]
    }]
  })
});

const data = await response.json();
console.log(data);

terminal

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-pro:generateContent?key=YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
  "contents": [{
    "parts": [{"text": "Explain how AI works"}]
  }]
}'

example.php

<?php
$apiKey = 'YOUR_API_KEY';
$url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-pro:generateContent?key=$apiKey";

$data = [
    "contents" => [
        ["parts" => [["text" => "Explain quantum mechanics"]]]
    ]
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>

main.go

package main

import (
    "context"
    "fmt"
    "log"
    "github.com/google/generative-ai-go/genai"
    "google.golang.org/api/option"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, option.WithAPIKey("YOUR_API_KEY"))
    if err != nil { log.Fatal(err) }
    defer client.Close()

    model := client.GenerativeModel("gemini-1.5-pro")
    resp, err := model.GenerateContent(ctx, genai.Text("Explain quantum mechanics"))
    if err != nil { log.Fatal(err) }
    
    // ...
}

Free Tier Pricing & Limits

Rate Limit

Requests per minute

5-30 Requests per minute (varies by model)

Daily Quota

Requests per day

Varies by model (Flash / Flash-Lite only; Pro models are paid)

Token Limit

Tokens per minute

1 000 000 Tokens per minute (Flash) / 2B Tokens per minute (3.1 Pro)

Monthly Quota

Per month limit

Free of charge

Use Cases

Content Generation

Data Extraction

Image & Video Analysis

Code Generation

chat bots

Limitations & Considerations

Data used for training (Unpaid tier)

Rate limits are enforced per minute/day

No SLA for free tier

Community Hub

Live

Join the discussion, share tips, and rate Google AI Studio.

Quick Reactions

Add Discussion

Display Name

Email (optional, to get notified when reviewed)

Comment

Comments are moderated. Be helpful and respectful.

Recent Activity

0 comments

Cookie Consent

Google AI Studio

Overview

Provider Type

API Endpoint

Free Tier Highlights

Why Choose Google AI Studio?

Quick Start Guide

Sign in to Google AI Studio

Get API Key

Start Building

Available Models

Integration Examples

Select Model

Free Tier Pricing & Limits

Rate Limit

Daily Quota

Token Limit

Monthly Quota

Use Cases

Limitations & Considerations

Community Hub

Quick Reactions

Add Discussion

Recent Activity

Ready to Get Started?

Cookie Consent

Google AI Studio

Overview

Provider Type

API Endpoint

Free Tier Highlights

Why Choose Google AI Studio?

Quick Start Guide

Sign in to Google AI Studio

Get API Key

Start Building

Available Models

Integration Examples

Select Model

Free Tier Pricing & Limits

Rate Limit

Daily Quota

Token Limit

Monthly Quota

Use Cases

Limitations & Considerations

Community Hub

Quick Reactions

Add Discussion

Recent Activity

Suggest an Edit

Report an Issue

Ready to Get Started?