Google Gemini Free code examples in C#, Python, Java and JavaScript

google-genai is the current SDK. If you find google-generativeai in a tutorial, that is the previous one — the import path and the client shape both changed.

pip install google-genai

export GEMINI_API_KEY="..."      # macOS / Linux
setx GEMINI_API_KEY "..."        # Windows, then open a new shell

The client picks up GEMINI_API_KEY (or GOOGLE_API_KEY) on its own. response.text concatenates every text part, so there is no block loop to write.

from google import genai

client = genai.Client()

response = client.models.generate_content(
    model="gemini-flash-latest",
    contents="Explain a database index in two sentences.",
)

print(response.text)
print(response.usage_metadata.prompt_token_count,
      response.usage_metadata.candidates_token_count)

A separate method, not a flag. Some chunks carry no text — a safety block or a tool call — so guard before writing.

for chunk in client.models.generate_content_stream(
    model="gemini-flash-latest",
    contents="Write a haiku about indexes.",
):
    if chunk.text:
        print(chunk.text, end="", flush=True)

print()

No OCR step, no separate vision endpoint. Mix parts freely in contents: a prompt, an image, a document. For anything over about 20 MB, upload it first with client.files.upload and pass the handle.

from google import genai
from google.genai import types

client = genai.Client()

with open("invoice.png", "rb") as f:
    image_bytes = f.read()

response = client.models.generate_content(
    model="gemini-flash-latest",
    contents=[
        "Extract the total and the due date as JSON.",
        types.Part.from_bytes(data=image_bytes, mime_type="image/png"),
    ],
)
print(response.text)

# Large or reused files: upload once, reference by handle.
handbook = client.files.upload(file="handbook.pdf")
summary = client.models.generate_content(
    model="gemini-flash-latest",
    contents=["Summarise the leave policy.", handbook],
)
print(summary.text)

Pass the Python function itself and the SDK generates the schema from the signature and docstring, calls it, and feeds the result back. No loop to write. Pass a declaration instead when you need to run the call yourself.

from google.genai import types

def get_weather(city: str) -> str:
    # The docstring and type hints BECOME the schema the model sees.
    # A vague description here is the usual reason a tool is never called.
    # Args:
    #     city: City name, e.g. Delhi.
    return "29C, clear"

response = client.models.generate_content(
    model="gemini-flash-latest",
    contents="What is the weather in Delhi?",
    config=types.GenerateContentConfig(tools=[get_weather]),
)

print(response.text)

Gemini returns a finish_reason on the candidate. SAFETY means the answer was blocked, and response.text will be empty rather than raising — check before you print it.

from google.genai import errors

try:
    response = client.models.generate_content(
        model="gemini-flash-latest",
        contents="...",
    )
except errors.ClientError as e:
    # 400 bad request, 403 key problem, 404 unknown model, 429 rate limit
    raise SystemExit(f"Request rejected ({e.code}): {e.message}")
except errors.ServerError as e:
    raise SystemExit(f"Server error ({e.code}) — safe to retry: {e.message}")

candidate = response.candidates[0]
if candidate.finish_reason and candidate.finish_reason.name != "STOP":
    print("Incomplete:", candidate.finish_reason.name)   # SAFETY, MAX_TOKENS, ...
else:
    print(response.text)

The official Google Gen AI SDK for Java. Gradle: implementation("com.google.genai:google-genai:1.73.0").

<dependency>
    <groupId>com.google.genai</groupId>
    <artifactId>google-genai</artifactId>
    <version>1.73.0</version>
</dependency>

The no-argument constructor reads GOOGLE_API_KEY from the environment — note the name: the Java SDK uses GOOGLE_API_KEY where Python also accepts GEMINI_API_KEY. The third argument is the config, which may be null.

import com.google.genai.Client;
import com.google.genai.types.GenerateContentResponse;

// Reads GOOGLE_API_KEY. Or: Client.builder().apiKey(key).build()
Client client = new Client();

GenerateContentResponse response = client.models.generateContent(
    "gemini-flash-latest",
    "Explain a database index in two sentences.",
    null);

System.out.println(response.text());

ResponseStream is closeable and holds an HTTP connection. Close it, or the pool stalls under load.

import com.google.genai.ResponseStream;
import com.google.genai.types.GenerateContentResponse;

try (ResponseStream<GenerateContentResponse> stream =
         client.models.generateContentStream(
             "gemini-flash-latest",
             "Write a haiku about indexes.",
             null)) {

    for (GenerateContentResponse chunk : stream) {
        System.out.print(chunk.text());
    }
}

System.out.println();

Part.fromBytes takes the raw bytes and a mime type. No OCR step and no separate vision endpoint.

import com.google.genai.types.Content;
import com.google.genai.types.GenerateContentResponse;
import com.google.genai.types.Part;

import java.nio.file.Files;
import java.nio.file.Path;

byte[] image = Files.readAllBytes(Path.of("invoice.png"));

Content content = Content.fromParts(
    Part.fromText("Extract the total and the due date as JSON."),
    Part.fromBytes(image, "image/png"));

GenerateContentResponse response = client.models.generateContent(
    "gemini-flash-latest", content, null);

System.out.println(response.text());

A blocked answer is not an exception — the response simply carries no text. Check the finish reason before printing.

import com.google.genai.errors.ClientException;
import com.google.genai.errors.ServerException;
import com.google.genai.types.GenerateContentResponse;

try {
    GenerateContentResponse response = client.models.generateContent(
        "gemini-flash-latest", "...", null);

    response.candidates().ifPresent(candidates -> candidates.stream()
        .findFirst()
        .flatMap(candidate -> candidate.finishReason())
        .ifPresent(reason -> {
            if (!"STOP".equals(reason.toString())) {
                System.err.println("Incomplete: " + reason);
            }
        }));

    System.out.println(response.text());
} catch (ClientException e) {
    // 400 malformed, 403 key problem, 404 unknown model, 429 rate limited
    System.err.println("Request rejected: " + e.getMessage());
} catch (ServerException e) {
    System.err.println("Server error — safe to retry: " + e.getMessage());
}

@google/genai is the current SDK. @google/generative-ai is the previous one — different import, different client.

npm install @google/genai

export GEMINI_API_KEY="..."

Pass the key explicitly here: the Node client does not read the environment on its own the way the Python one does.

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });

const response = await ai.models.generateContent({
  model: "gemini-flash-latest",
  contents: "Explain a database index in two sentences.",
});

console.log(response.text);
console.log(response.usageMetadata.promptTokenCount,
            response.usageMetadata.candidatesTokenCount);

A separate method, and it returns an async iterable. Some chunks carry no text, so guard before writing.

const stream = await ai.models.generateContentStream({
  model: "gemini-flash-latest",
  contents: "Write a haiku about indexes.",
});

for await (const chunk of stream) {
  if (chunk.text) process.stdout.write(chunk.text);
}

inlineData takes base64. No OCR step and no separate vision endpoint — the image is just another part of the prompt.

import { GoogleGenAI } from "@google/genai";
import fs from "node:fs";

const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });

const imageBase64 = fs.readFileSync("invoice.png", { encoding: "base64" });

const response = await ai.models.generateContent({
  model: "gemini-flash-latest",
  contents: [
    { text: "Extract the total and the due date as JSON." },
    { inlineData: { mimeType: "image/png", data: imageBase64 } },
  ],
});

console.log(response.text);

Declare the function, read response.functionCalls, run it yourself, then send the result back as a functionResponse part. The model has produced no answer until that second call.

import { Type } from "@google/genai";

const getWeather = {
  name: "get_weather",
  description: "Current weather for a city.",
  parameters: {
    type: Type.OBJECT,
    properties: { city: { type: Type.STRING } },
    required: ["city"],
  },
};

const contents = [
  { role: "user", parts: [{ text: "What is the weather in Delhi?" }] },
];

const first = await ai.models.generateContent({
  model: "gemini-flash-latest",
  contents,
  config: { tools: [{ functionDeclarations: [getWeather] }] },
});

for (const call of first.functionCalls ?? []) {
  contents.push({ role: "model", parts: [{ functionCall: call }] });
  contents.push({
    role: "user",
    parts: [{
      functionResponse: {
        name: call.name,
        response: { celsius: 29, sky: "clear" },
      },
    }],
  });
}

const second = await ai.models.generateContent({
  model: "gemini-flash-latest",
  contents,
  config: { tools: [{ functionDeclarations: [getWeather] }] },
});
console.log(second.text);

A blocked answer is not an exception: finishReason comes back as SAFETY and response.text is empty. Check it before displaying anything.

try {
  const response = await ai.models.generateContent({
    model: "gemini-flash-latest",
    contents: "...",
  });

  const finish = response.candidates?.[0]?.finishReason;
  if (finish && finish !== "STOP") {
    console.warn("Incomplete:", finish);   // SAFETY, MAX_TOKENS, ...
  } else {
    console.log(response.text);
  }
} catch (error) {
  // The SDK throws with a status for 400 / 403 / 404 / 429.
  console.error(`Request failed (${error.status ?? "?"}): ${error.message}`);
}