# Backend SDKs

Stream ships seven backend SDKs. Each one covers every Stream product: one client object gives you chat, video, feeds and moderation from the same process, authenticated with your API key and secret. The code tabs across this Platform section assume you have constructed that client.

Backend SDKs run on your server and hold your API secret. Anything that runs on a user's device belongs in a [client SDK](https://getstream.io/) instead.

## The SDKs

| Language | Package                                | Registry      |
| -------- | -------------------------------------- | ------------- |
| Node.js  | `@stream-io/node-sdk`                  | npm           |
| Python   | `getstream`                            | PyPI          |
| Go       | `github.com/GetStream/getstream-go/v4` | Go modules    |
| Java     | `io.getstream:stream-sdk-java`         | Maven Central |
| Ruby     | `getstream-ruby`                       | RubyGems      |
| PHP      | `getstream/getstream-php`              | Packagist     |
| .NET     | `getstream-net`                        | NuGet         |

Full source code for every SDK is on the [GetStream GitHub organization](https://github.com/GetStream). If Stream has no SDK for your language, use the [REST API](https://getstream.github.io/protocol/) directly.

## Installation

<Tabs>

```bash label="Node.js"
npm install @stream-io/node-sdk
# or
yarn add @stream-io/node-sdk
```

```bash label="Python"
pip install getstream
```

```bash label="Ruby"
gem install getstream-ruby
# or in your Gemfile
gem 'getstream-ruby'
```

```bash label="PHP"
composer require getstream/getstream-php
```

```bash label="Go"
go get github.com/GetStream/getstream-go/v4
```

```bash label="C#"
dotnet add package getstream-net
```

```kotlin label="Java"
// Gradle
dependencies {
    implementation("io.getstream:stream-sdk-java:$version")
}
```

</Tabs>

## Creating a client

Construct the client with your API key and secret. Both are in your [Stream Dashboard](https://getstream.io/signin/). The secret grants full access to the API, so it must never leave your server.

<Tabs>

```js label="Node.js"
import { StreamClient } from "@stream-io/node-sdk";
// or: const { StreamClient } = require("@stream-io/node-sdk");

const client = new StreamClient("your_api_key", "your_api_secret");
```

```python label="Python"
from getstream import Stream

client = Stream(api_key="your_api_key", api_secret="your_api_secret")
```

```ruby label="Ruby"
require 'getstream_ruby'

client = GetStreamRuby::Client.new(
  api_key: 'your_api_key',
  api_secret: 'your_api_secret'
)
```

```php label="PHP"
use GetStream\ClientBuilder;

$client = (new ClientBuilder())
    ->apiKey('your_api_key')
    ->apiSecret('your_api_secret')
    ->build();
```

```go label="Go"
import "github.com/GetStream/getstream-go/v4"

client, err := getstream.NewClient("your_api_key", "your_api_secret")
```

```csharp label="C#"
using GetStream;

var client = new StreamClient("your_api_key", "your_api_secret");
```

```java label="Java"
import io.getstream.services.framework.StreamSDKClient;

// Reads credentials from the STREAM_API_KEY and STREAM_API_SECRET
// environment variables, or from the io.getstream.apiKey and
// io.getstream.apiSecret properties:
var client = new StreamSDKClient();

// Or pass them explicitly:
var client = new StreamSDKClient("your_api_key", "your_api_secret");
```

</Tabs>

Construct one client when your process starts and reuse it everywhere. The client is safe to share and maintains one HTTP connection pool for all products. See [Connection pooling](https://getstream.io/docs/platform/connection-pooling/) for the pool and timeout settings you can pass at construction.

## One client, every product

App-level operations live directly on the client: users, tokens, app settings and async tasks. Product-specific operations hang off a product namespace, such as `client.chat` in Python or `client.Chat()` in Go.

The first server-side task in most integrations is minting a token that lets a user connect from your app. [Authentication and tokens](https://getstream.io/docs/platform/authentication/) covers that end to end.

## Shared behavior

The SDKs behave the same way across languages, and this section documents that behavior once:

- [Error handling](https://getstream.io/docs/platform/error-handling/): the typed exception hierarchy every SDK raises.
- [Logging](https://getstream.io/docs/platform/logging/): structured log events with identical field names in every language.
- [Async operations](https://getstream.io/docs/platform/async-operations/): waiting on long-running tasks.
- [Rate limits](https://getstream.io/docs/platform/rate-limits/): reading limit headers and handling 429 responses.


---

This page was last updated at 2026-08-07T13:10:45.260Z.

For the most recent version of this documentation, visit [https://getstream.io/docs/platform/backend-sdks/](https://getstream.io/docs/platform/backend-sdks/).