Multi-Language Code Examples — Complete Guide

In this tutorial, you will learn about Multi. We cover key concepts, practical examples, and best practices to help you master this topic.

Multi-language code examples show developers how to call the same API endpoint in different programming languages, with consistent variable names, the same request data, and identical expected output so developers can compare implementations and choose their preferred language.

What You'll Learn

How to structure multi-language code examples, which languages to include, how to keep examples consistent across languages, how to show expected output for each language, how to handle language-specific features like async/await, and how to test examples automatically.

Why It Matters

Developers evaluate APIs by scanning code examples in their preferred language. Showing only Python examples excludes JavaScript, Go, and Java developers. Each added language expands your addressable developer audience and reduces integration friction.

Real-World Use

Stripe's API docs show examples in cURL, Python, JavaScript, Ruby, PHP, Java, Go, and .NET for every endpoint. All examples use the same variable names and request structure. The DodaTech SDK docs provide cURL, Python, JavaScript, and Go examples for every endpoint.

Multi-Language Strategy

flowchart TD
  A[Code Examples] --> B[cURL]
  A --> C[Python]
  A --> D[JavaScript]
  A --> E[Go]
  A --> F[Additional Languages]
  B --> G[Universal, no SDK needed]
  C --> H[Most readable, data science]
  D --> I[Web development]
  E --> J[Cloud infrastructure]
  F --> K[Java, Ruby, PHP, .NET]
  A:::current
  classDef current fill:#f90,color:#fff,stroke:#333,stroke-width:2px

cURL Examples

cURL is universal. Every API endpoint should have a working cURL example.

curl -X POST https://api.dodatech.com/v2/files/compress \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "file_url": "https://example.com/report.pdf",
    "format": "zip",
    "level": 6
  }'

Python Examples

Python is the most readable language for documentation. It works well for non-Python developers too.

import os
from dodatech import Client

client = Client(api_key=os.environ["DODATECH_API_KEY"])

job = client.files.compress(
    file_url="https://example.com/report.pdf",
    format="zip",
    level=6
)

print(f"Job ID: {job.job_id}")
print(f"Status: {job.status}")

# Poll for completion
import time
while job.status not in ("completed", "failed"):
    time.sleep(2)
    job = client.jobs.get(job.job_id)

if job.status == "completed":
    print(f"Compressed size: {job.output_size} bytes")
    print(f"Download: {job.download_url}")
else:
    print(f"Failed: {job.error}")

# Expected output:
# Job ID: c7f3a2b1-...-1d2e3f4a5b6c
# Status: pending
# Compressed size: 258432 bytes
# Download: https://api.dodatech.com/v2/download/c7f3a2b1

JavaScript Examples

JavaScript is essential for web developers. Use modern ES6+ syntax with async/await.

import DodaTech from "dodatech-sdk";

const client = new DodaTech.Client({
  apiKey: process.env.DODATECH_API_KEY,
});

async function compressFile() {
  const job = await client.files.compress({
    fileUrl: "https://example.com/report.pdf",
    format: "zip",
    level: 6,
  });

  console.log(`Job ID: ${job.jobId}`);
  console.log(`Status: ${job.status}`);

  // Poll for completion
  while (job.status !== "completed" && job.status !== "failed") {
    await new Promise((resolve) => setTimeout(resolve, 2000));
    const updated = await client.jobs.get(job.jobId);
    job.status = updated.status;
    job.outputSize = updated.outputSize;
    job.downloadUrl = updated.downloadUrl;
  }

  if (job.status === "completed") {
    console.log(`Compressed size: ${job.outputSize} bytes`);
    console.log(`Download: ${job.downloadUrl}`);
  } else {
    console.log(`Failed: ${job.error}`);
  }
}

compressFile().catch(console.error);

Go Examples

Go is important for cloud infrastructure and backend services.

package main

import (
    "fmt"
    "github.com/dodatech/dodatech-go"
)

func main() {
    client := dodatech.NewClient("YOUR_API_KEY")

    job, err := client.Files.Compress(dodatech.CompressRequest{
        FileURL: "https://example.com/report.pdf",
        Format:  "zip",
        Level:   6,
    })
    if err != nil {
        panic(err)
    }

    fmt.Printf("Job ID: %s\n", job.JobID)
    fmt.Printf("Status: %s\n", job.Status)
}

Keeping Examples Consistent

All examples must use the same variable names, request data, and expected output.

# Python
client = Client(api_key="YOUR_KEY")
result = client.files.compress(file_url="https://example.com/file.pdf")

// JavaScript
const client = new Client({apiKey: "YOUR_KEY"});
const result = await client.files.compress({fileUrl: "https://example.com/file.pdf"});

// Go
client := NewClient("YOUR_KEY")
result := client.Files.Compress(URL: "https://example.com/file.pdf")

Testing Code Examples

Automate testing of code examples to catch broken examples before publishing.

# Test Python examples
pytest tests/test_api_examples.py

# Test JavaScript examples
npm run test:examples

# Test cURL examples by extracting and running them
bash scripts/test-curl-examples.sh

Common Mistakes

1. Inconsistent Variable Names

Using job_id in Python, jobId in JavaScript, and JobID in Go for the same data. Use consistent naming conventions per language but keep concepts aligned.

2. No Expected Output

Showing code without expected output leaves developers wondering if their code worked correctly. Always show what the output should look like.

3. Untested Examples

Examples with typos, missing imports, or syntax errors destroy developer trust. Test every example automatically in CI.

4. Language-Specific Idioms That Confuse

Using list comprehensions in Python or Promise.all in JavaScript without explanation. Use simple, readable patterns that translate well across languages.

5. Showing Only Raw HTTP

Not providing SDK examples when SDKs exist. Developers prefer SDK examples. Show both raw HTTP (cURL) and SDK examples.

6. Hardcoded Credentials

Examples with real API keys teach bad security habits. Always use placeholder values and environment variables.

7. Incomplete Code Blocks

Examples that do not include imports, client initialization, or error handling. Every example should be a complete, runnable snippet.

Practice Questions

1. What are the four primary languages for API code examples?

cURL (universal, no SDK), Python (most readable), JavaScript (web development), and Go (cloud infrastructure). Add Java, Ruby, PHP, or .NET based on your audience.

2. Why is cURL always included in API documentation?

cURL works on any platform without installing an SDK. It shows the raw HTTP request including headers, method, and body. Every developer can run a cURL command directly from the terminal.

3. How do you keep examples consistent across languages?

Use the same conceptual variable names (adapting to language conventions), the same request data values, and the same expected output. Review examples side by side before publishing.

4. Why test code examples automatically?

Untested examples contain typos, use outdated SDK versions, or call deprecated endpoints. Automated testing catches these issues before they reach documentation readers.

5. Challenge: Write the same API endpoint call in cURL, Python, JavaScript, and Go. Use consistent request data and show expected output for each language.

FAQ

Mini Project: Multi-Language Example Page

Pick an API endpoint and write code examples in five languages (cURL, Python, JavaScript, Go, and one more of your choice). Use consistent variable names and request data across all examples. Show expected output for each language. Test every example before finalizing.

What's Next

Code examples show how to use the API. Now learn to document SDKs and Client Libraries for developers who prefer SDKs. Then explore Changelog and Release Notes for communicating API changes.