Announcing Official SDKs for JavaScript, Python, and Go

Starting today, we're releasing official SDKs for JavaScript, Python, and Go. These aren't thin wrappers around curl—they're thoughtfully designed libraries that handle retries, rate limiting, response envelopes, and error handling so you don't have to. We've spent the last three months gathering feedback from beta customers and iterating on the API design. Every SDK has been tested in production-like scenarios with thousands of concurrent requests.

JavaScript: forge-js

Install via npm:

npm install @forge-api/sdk

Basic usage:

import { ForgeClient } from '@forge-api/sdk';
const forge = new ForgeClient({
  apiKey: process.env.FORGE_API_KEY
});
const weather = await forge.weather.get({
  lat: 51.51,
  lon: -0.13,
  units: 'metric',
  days: 3
});
console.log(weather.data.temperature);

The JavaScript SDK includes TypeScript definitions out of the box. We generate types from our OpenAPI schema, ensuring they stay in sync with every release. It also ships with built-in rate limit handling—if you hit a 429, the SDK automatically retries with exponential backoff, which is configurable per request. For frontend applications, we provide a browser-compatible build with no Node dependencies. It's fully tree-shakeable too, so unused imports don't bloat your bundle.

Python: forge-python

Install via pip:

pip install forge-api

Usage:

from forge import ForgeClient
forge = ForgeClient(api_key='fg_live_abc123')
weather = forge.weather.get(
    lat=51.51,
    lon=-0.13,
    units='metric',
    days=3
)
print(weather.data.temperature)

The Python SDK is fully async-compatible. For high-throughput applications, you can use ForgeClientAsync and make concurrent requests without blocking. We've tested it with thousands of concurrent requests in production-like scenarios. It supports Python 3.8 through 3.12 and works seamlessly with popular frameworks like FastAPI, Django, and asyncio. Built-in session pooling means you can reuse connections across requests.

Go: forge-go

Go modules support:

go get github.com/forge-api/forge-go

Example:

package main
import (
	"fmt"
	"github.com/forge-api/forge-go"
)
func main() {
	client := forge.NewClient("fg_live_abc123")
	weather, err := client.Weather.Get(context.Background(), &forge.WeatherRequest{
		Lat:   51.51,
		Lon:   -0.13,
		Units: "metric",
		Days:  3,
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(weather.Data.Temperature)
}

The Go SDK is idiomatic—it uses context for cancellation and timeouts, returns errors as the second value, and includes full HTTP client configuration options. We've optimized it for low-latency services and cloud functions where startup time matters. The binary is also particularly small, making it perfect for serverless deployments.

What's in the Box

All three SDKs include:

Automatic retry logic with configurable backoff strategies and jitter
Built-in rate limit handling that reads and respects Retry-After headers
Request ID tracking and distributed tracing support for debugging
Full response envelope access, including meta information about credits and timing
Comprehensive error types that distinguish between client errors, server errors, and network failures
Support for both live and sandbox API keys for safe testing
Detailed docstrings and inline examples in every method
Comprehensive unit and integration test suites

All three are open source on GitHub under the MIT license, so you can inspect the code, run tests locally, or contribute improvements. We welcome pull requests and community feedback.

Migration Path

If you've been writing raw HTTP calls to Forge, switching to an SDK is straightforward. Your authentication, endpoints, and response handling all stay the same—you just get better abstractions and automatic resilience on top. We've published migration guides for each language at our documentation site, with before-and-after examples.

Head to our documentation for installation and API reference guides for each SDK. We're confident these SDKs will make building with Forge faster and more enjoyable. Happy coding.