import os
import requests
url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent"
headers = {
"Authorization": f"Bearer {os.environ['GEMINI_API_KEY']}",
"Content-Type": "application/json"
}
data = {
"contents": [{"parts": [{"text": "Write a poem about AI."}]}]
}
response = requests.post(url, headers=headers, json=data)
response.raise_for_status()
print(response.json())
import os
import httpx
url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent"
headers = {
"Authorization": f"Bearer {os.environ['GEMINI_API_KEY']}",
"Content-Type": "application/json"
}
data = {
"contents": [{"parts": [{"text": "Write a poem about AI."}]}]
}
with httpx.Client() as client:
response = client.post(url, headers=headers, json=data)
response.raise_for_status()
print(response.json())
const fetch = require('node-fetch');
const url = 'https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent';
const headers = {
'Authorization': `Bearer ${process.env.GEMINI_API_KEY}`,
'Content-Type': 'application/json'
};
const data = {
contents: [{ parts: [{ text: 'Write a poem about AI.' }] }]
};
fetch(url, {
method: 'POST',
headers,
body: JSON.stringify(data)
})
.then(res => {
if (!res.ok) throw new Error(`HTTP error! status: ${res.status}`);
return res.json();
})
.then(console.log)
.catch(console.error);
const axios = require('axios');
const url = 'https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent';
const headers = {
'Authorization': `Bearer ${process.env.GEMINI_API_KEY}`,
'Content-Type': 'application/json'
};
const data = {
contents: [{ parts: [{ text: 'Write a poem about AI.' }] }]
};
axios.post(url, data, { headers })
.then(response => {
console.log(response.data);
})
.catch(error => {
console.error('Error:', error.message);
});
package main
import (
"fmt"
"log"
"net/http"
"os"
"io/ioutil"
"encoding/json"
)
type RequestBody struct {
Contents []struct {
Parts []struct {
Text string `json:"text"`
} `json:"parts"`
} `json:"contents"`
}
type ResponseBody struct {
Candidates []interface{} `json:"candidates"`
}
func main() {
url := "https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent"
apiKey := os.Getenv("GEMINI_API_KEY")
if apiKey == "" {
log.Fatal("GEMINI_API_KEY environment variable not set")
}
body := RequestBody{
Contents: []struct {
Parts []struct {
Text string `json:"text"`
} `json:"parts"`
}{
{
Parts: []struct {
Text string `json:"text"`
}{
{Text: "Write a poem about AI."},
},
},
},
}
jsonBody, err := json.Marshal(body)
if err != nil {
log.Fatal(err)
}
req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonBody))
if err != nil {
log.Fatal(err)
}
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
log.Fatal(err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
log.Fatalf("Request failed with status: %s", resp.Status)
}
respBody, err := ioutil.ReadAll(resp.Body)
if err != nil {
log.Fatal(err)
}
var result ResponseBody
if err := json.Unmarshal(respBody, &result); err != nil {
log.Fatal(err)
}
fmt.Println(string(respBody))
}
<?php
$url = 'https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent';
$apiKey = getenv('GEMINI_API_KEY');
if (empty($apiKey)) {
die('GEMINI_API_KEY environment variable not set');
}
$data = [
'contents' => [
['parts' => [
['text' => 'Write a poem about AI.']
]]
]
];
$options = [
'http' => [
'header' => [
"Authorization: Bearer $apiKey",
"Content-Type: application/json"
],
'method' => 'POST',
'content' => json_encode($data),
'ignore_errors' => true
]
];
$context = stream_context_create($options);
$result = file_get_contents($url, false, $context);
if ($result === FALSE) {
die('Request failed');
}
$response = json_decode($result, true);
print_r($response);
require 'net/http'
require 'json'
require 'uri'
url = URI.parse('https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent')
api_key = ENV['GEMINI_API_KEY']
raise 'GEMINI_API_KEY environment variable not set' unless api_key
request_body = {
contents: [{
parts: [{
text: 'Write a poem about AI.'
}]
}]
}
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url.request_uri, {
'Authorization' => "Bearer #{api_key}",
'Content-Type' => 'application/json'
})
request.body = request_body.to_json
response = http.request(request)
unless response.is_a?(Net::HTTPSuccess)
raise "HTTP request failed: #{response.code} #{response.message}"
end
puts JSON.parse(response.body)
import Foundation
let url = URL(string: "https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
let apiKey = ProcessInfo.processInfo.environment["GEMINI_API_KEY"] ?? ""
if apiKey.isEmpty {
fatalError("GEMINI_API_KEY environment variable not set")
}
request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
let requestBody: [String: Any] = [
"contents": [
["parts": [
["text": "Write a poem about AI."]
]]
]
]
do {
request.httpBody = try JSONSerialization.data(withJSONObject: requestBody)
} catch {
fatalError("Failed to serialize request body: \(error)")
}
let task = URLSession.shared.dataTask(with: request) { data, response, error in
if let error = error {
fatalError("Request failed: \(error)")
}
guard let httpResponse = response as? HTTPURLResponse, (200...299).contains(httpResponse.statusCode) else {
fatalError("Request failed with status code: \((response as? HTTPURLResponse)?.statusCode ?? 0)")
}
guard let data = data else {
fatalError("No data received")
}
do {
if let json = try JSONSerialization.jsonObject(with: data) as? [String: Any] {
print(json)
}
} catch {
fatalError("Failed to parse response: \(error)")
}
}
task.resume()
// Keep the program running to allow the async task to complete
RunLoop.main.run()
use std::env;
use reqwest::blocking::Client;
use serde_json::json;
fn main() -> Result<(), Box<dyn std::error::Error>> {
let url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent";
let api_key = env::var("GEMINI_API_KEY")?;
let client = Client::new();
let response = client
.post(url)
.header("Authorization", format!("Bearer {}", api_key))
.header("Content-Type", "application/json")
.json(&json!({
"contents": [{"parts": [{"text": "Write a poem about AI."}]}]
}))
.send()?;
if !response.status().is_success() {
return Err(format!("Request failed with status: {}", response.status()).into());
}
let body = response.text()?;
println!("{}", body);
Ok(())
}
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using System.Text.Json;
class Program
{
static async Task Main(string[] args)
{
var url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent";
var apiKey = Environment.GetEnvironmentVariable("GEMINI_API_KEY");
if (string.IsNullOrEmpty(apiKey))
{
Console.WriteLine("GEMINI_API_KEY environment variable not set");
return;
}
using var client = new HttpClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var requestBody = new
{
contents = new[]
{
new
{
parts = new[]
{
new { text = "Write a poem about AI." }
}
}
}
};
var response = await client.PostAsJsonAsync(url, requestBody);
response.EnsureSuccessStatusCode();
var responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
}
public static class HttpClientExtensions
{
public static async Task<HttpResponseMessage> PostAsJsonAsync<T>(
this HttpClient httpClient, string url, T data)
{
var content = new StringContent(JsonSerializer.Serialize(data), System.Text.Encoding.UTF8, "application/json");
return await httpClient.PostAsync(url, content);
}
}