Developers · SDKs & Code Libraries

Sports Betting API SDKs
for Every Stack.

Official client libraries for Python, Node.js, PHP, Java, .NET, Go, and Ruby. Built with type safety, automatic retries, and rate-limit handling — so you can focus on building features, not plumbing.

  • Official SDKs and client libraries
  • Faster API integration
  • REST & WebSocket support
  • Enterprise-grade developer tools
  • Comprehensive documentation
Download SDK View Documentation Get API Key
7 Official SDKs Open Source on GitHub Semantic Versioning Built-In Rate Limit Handling
install & fetch — pick your language 
# pip install techmagnetics-sdk
from techmagnetics import Client

client = Client(api_key="YOUR_API_KEY")

odds = client.prematch.get_odds(
    sport="football",
    league="premier-league"
)

print(odds.fixtures[0].markets)
// npm install @techmagnetics/sdk
import { Client } from '@techmagnetics/sdk';

const client = new Client({ apiKey: 'YOUR_API_KEY' });

const odds = await client.prematch.getOdds({
  sport: 'football',
  league: 'premier-league'
});

console.log(odds.fixtures[0].markets);
// go get github.com/techmagnetics/sdk-go
import tm "github.com/techmagnetics/sdk-go"

client := tm.NewClient("YOUR_API_KEY")

odds, err := client.Prematch.GetOdds(tm.OddsParams{
    Sport:  "football",
    League: "premier-league",
})

fmt.Println(odds.Fixtures[0].Markets)
// composer require techmagnetics/sdk
use TechMagnetics\Client;

$client = new Client('YOUR_API_KEY');

$odds = $client->prematch->getOdds([
    'sport' => 'football',
    'league' => 'premier-league',
]);

print_r($odds->fixtures[0]->markets);
7Official Language SDKs
100%Open Source & MIT Licensed
<10minAverage Time to First Call
WeeklyRelease Cadence on GitHub
Pick Your Stack

Official SDKs for the
Languages You Already Use.

Every SDK wraps the same underlying API with idiomatic, language-native conventions — strong typing, async support, and consistent naming across the board.

Community & Postman

Postman collection, OpenAPI spec, and community SDKs for Rust, Swift & Kotlin.

Open Spec GitHub
View Community Repos

Strongly Typed Models.
Zero Guesswork.

Every fixture, market, and stat object ships with full type definitions — your editor autocompletes the response shape before you've even called the endpoint.

Typed Response Models Autocomplete-Ready Compile-Time Safety
Getting Started

From Install
to First Live Call.

Most teams have their first fixture, odds, or score response back inside ten minutes — no support ticket required.

Install

Pull the SDK from your package manager of choice — pip, npm, Maven, NuGet, Go modules, or Composer.

Authenticate

Initialize the client with your API key from the sandbox — no manual header construction needed.

Call

Use typed methods like client.prematch.getOdds() instead of hand-building query strings.

Ship

Built-in retries, pagination, and rate-limit backoff mean your integration is production-ready from day one.

Built for Esports
Integrations Too.

The same SDK methods that pull football fixtures pull esports series, maps, and live scoreboards — one client, one auth flow, every vertical.

Unified Client Interface Live Series & Map Data Same SDK, Every Sport
Built Into Every SDK

The Plumbing
Is Already Handled.

Every official SDK ships with the same production-grade behaviors out of the box, so your integration doesn't fall over the first time a rate limit or network blip hits.

  • Automatic Retries with BackoffTransient network failures and 5xx responses are retried transparently.
  • Rate-Limit AwarenessClients read response headers and throttle requests before you hit a 429.
  • Built-In Pagination HelpersIterate large result sets without hand-rolling offset or cursor logic.
  • Structured Error TypesCatch specific exceptions like RateLimitError or AuthError instead of parsing strings.
error-handling.py 
from techmagnetics import Client
from techmagnetics.errors import RateLimitError, AuthError

client = Client(
    api_key="YOUR_API_KEY",
    max_retries=3,
    timeout=5.0
)

try:
    livescores = client.livescore.stream(
        sport="cricket",
        league="ipl"
    )
    for event in livescores:
        print(event.match_id, event.update_type)

except RateLimitError as e:
    print(f"Retry after {e.retry_after}s")
except AuthError:
    print("Check your API key")

From Sandbox Stats
to Production Dashboards.

The exact response objects you test against in the sandbox are what your production dashboards render — no schema surprises between environments.

Consistent Response Schemas Sandbox-to-Prod Parity Stats & Analytics Ready
Built For

Whoever's Holding
the Keyboard.

From solo indie builders to platform teams shipping at scale, the SDKs are designed to fit how you already write code.

Backend Engineers

Drop typed clients straight into existing services without hand-writing an HTTP wrapper.

Mobile & App Developers

Lightweight clients built for low-latency calls from native and cross-platform apps.

Indie & Startup Builders

Get from idea to working prototype in an afternoon, not a sprint.

Platform & Data Teams

Standardize on one client library across services instead of maintaining bespoke HTTP code.

Open Source.
Open to Contributions.

Every SDK repository is public on GitHub under the MIT license — file an issue, open a PR, or fork it for your own internal tooling.

Public GitHub Repos MIT Licensed Community PRs Welcome
Versioning & Support

Predictable Releases.
No Breaking Surprises.

Every SDK follows strict semantic versioning, with deprecation notices shipped at least one minor version ahead of removal.

Semantic VersioningPredictable Major/Minor/Patch
Detailed ChangelogsPer-Release Migration Notes
12-Month Support WindowFor Each Major Version
Active Dev CommunityGitHub Discussions & Discord
Open Source on GitHub Published on pip, npm, Maven & NuGet OpenAPI Spec Included Ready-Made Postman Collection

One Client.
Every Sport You Cover.

Football, cricket, basketball, tennis, esports — the same SDK methods and typed objects carry across all 30+ sports, so adding a new vertical doesn't mean learning a new client.

30+ Sports, One Client Consistent Method Naming Less Code to Maintain
FAQs

Common Questions from
Developers Using SDKs.

Sports API SDKs (Software Development Kits) are client libraries that simplify integration with the Tech Magnetics sports data API. They handle authentication, request building, response parsing, error handling, and rate limiting, allowing developers to focus on building features instead of dealing with HTTP plumbing.

Tech Magnetics provides official SDKs for Python, Node.js/TypeScript, PHP, Java, .NET, Go, and Ruby. Community SDKs and libraries are also available for other languages, and the REST API can be used directly from any language that supports HTTP requests.

SDKs are available through standard package managers: pip for Python, npm for Node.js, Composer for PHP, Maven for Java, NuGet for .NET, Go modules for Go, and RubyGems for Ruby. Installation commands are provided on each SDK's GitHub repository and documentation page.

Yes. Tech Magnetics provides officially maintained client libraries for Python, Node.js/TypeScript, PHP, Java, .NET, Go, and Ruby. All libraries are open source, MIT licensed, and available on GitHub.

Yes. The Tech Magnetics API can be consumed directly from any language or tool that supports HTTP requests. SDKs are optional but recommended for faster integration, type safety, and built-in reliability features.

Yes. The Node.js, Python, Go, and Java SDKs include WebSocket client support for real-time data streaming. The .NET, PHP, and Ruby SDKs provide WebSocket functionality through community-contributed modules or can be used with standard WebSocket clients.

SDKs authenticate using API keys. Simply pass your API key when initializing the client. The SDK will automatically include the API key in the X-API-Key header for every request. For WebSocket connections, authentication is performed during the initial handshake.

SDKs can be downloaded from their respective package managers or directly from GitHub. Links to each repository are available on the SDKs & Libraries page. All SDKs are open source and free to use under the MIT license.

Yes. Each SDK includes comprehensive code examples covering common use cases such as fetching live scores, retrieving odds, accessing player statistics, and subscribing to real-time WebSocket streams. Examples are available in each SDK's documentation and GitHub repository.

SDK versions are updated through your package manager (pip update, npm update, etc.). We follow semantic versioning, and release notes are provided on GitHub. We recommend updating to the latest minor version regularly to benefit from improvements and bug fixes.

Yes. The REST and WebSocket APIs are fully compatible with mobile platforms. Community-contributed SDKs and libraries are available for Android, iOS, Flutter, and React Native. The REST API can also be consumed directly from any mobile application that supports HTTP requests.

Yes. All official Tech Magnetics SDKs are open source and available on GitHub under the MIT license. This allows you to review the code, contribute improvements, and adapt the libraries to your specific needs.

Yes. Each SDK has its own GitHub repository with source code, issue tracking, contribution guidelines, and release notes. Links to all repositories are available on the SDKs & Libraries page.

Yes. The SDKs include methods for accessing historical sports data, including past match results, player performance archives, and historical odds movements. All SDKs support the same endpoints as the REST API.

SDKs follow security best practices including API key authentication, TLS 1.3 encryption, and secure credential handling. All requests are made over HTTPS, and sensitive data is never logged or stored. The platform is ISO 27001 certified.

Yes. Each SDK includes examples for working with the sandbox environment. Sandbox endpoints use a separate base URL and include simulated data for testing integration without affecting production usage.

Yes. Technical support is available through multiple channels including documentation, GitHub issues, Discord community, and email support. Dedicated developer support is available for enterprise customers.

Yes. You can request a personalized demo through our website. Our developer relations team will walk you through the SDK capabilities, sandbox environment, and integration options tailored to your development needs.

With our SDKs and quick start guide, most developers can have their first API call working within 10 minutes. Full production integration typically takes 1-2 days, depending on the complexity of your application and data requirements.

Tech Magnetics delivers enterprise-grade SDKs with broad language support, open source licensing, and comprehensive documentation. Our developer-first approach, coupled with reliable APIs and dedicated support, makes integration fast and frictionless.
Free Sandbox Access

Install the SDK.
Make Your First Call in Minutes.

Grab a sandbox API key, pick your language, and get a real response back before your coffee's done — no contracts, no sales calls required to start.

7 official SDKs, MIT licensed Full sandbox environment Live in under 10 minutes
Get Your API Key Read the Docs

No credit card required · Free sandbox tier · Response within 24 hours for support

7 Official SDKs · 100% Open Source · Weekly GitHub Releases · 99.99% API Uptime