> ## Documentation Index
> Fetch the complete documentation index at: https://docs.acedata.cloud/llms.txt
> Use this file to discover all available pages before exploring further.

# Development Sdk

> Platform API guide - Ace Data Cloud

```python theme={null}
from acedatacloud import AceDataCloud

client = AceDataCloud(api_token=os.getenv('ACEDATACLOUD_API_TOKEN'))

t0 = time.time()
res = client.openai.chat.completions.create(
    model='gpt-4o-mini',
    messages=[{'role': 'user', 'content': 'Reply with exactly: ADC_PY_SDK_OK'}],
    max_tokens=20,
    temperature=0
)
print('elapsed_ms', (time.time() - t0) * 1000)
print('id', res.id)
print('model', res.model)
print('content', res.choices[0].message.content)
print('usage', res.usage)
```

> SDK erklärt die Antwort derzeit als `Record[str, Any]`, zur Laufzeit ist es ein gewöhnliches JSON-Objekt, auf das direkt nach Feldern zugegriffen werden kann. In strengen Python-Projekten kann es hilfreich sein, Typfehler zu umgehen, indem man `cast` verwendet oder sich auf [SDK-Aufgabenabfrage und Streaming-Antworten](https://platform.acedata.cloud/documents/sdk-tasks-and-streaming) bezieht, um einen typisierten Wrapper zu erstellen.

Programmausgabe:

```text theme={null}
elapsed_ms 2543
id chatcmpl-DldCcLvkTFaioST8e6SjOl0wJScQA
model gpt-4o-mini
content ADC_PY_SDK_OK
usage {"prompt_tokens":16,"completion_tokens":6,"total_tokens":22}
```

### Go

```go theme={null}
package main

import (
    "context"
    "fmt"
    "time"

    adc "github.com/AceDataCloud/SDK/go"
)

func main() {
    client := adc.NewClient(adc.WithAPIToken(os.Getenv("ACEDATACLOUD_API_TOKEN")))

    t0 := time.Now()
    res, err := client.OpenAI.Chat.Completions.Create(context.Background(), adc.ChatCompletionRequest{
        Model:    "gpt-4o-mini",
        Messages: []adc.ChatMessage{{Role: "user", Content: "Reply with exactly: ADC_GO_SDK_OK"}},
        MaxTokens: 20,
        Temperature: 0,
    })
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("elapsed_ms", time.Since(t0).Milliseconds())
    fmt.Println("id", res.ID)
    fmt.Println("model", res.Model)
    fmt.Println("content", res.Choices[0].Message.Content)
    fmt.Println("usage", res.Usage)
}
```

> SDK behandelt die Antwort derzeit als `map[string]interface{}`, zur Laufzeit ist es ein gewöhnliches JSON-Objekt, auf das direkt nach Feldern zugegriffen werden kann. In strengen Go-Projekten kann es hilfreich sein, Typfehler zu umgehen, indem man `interface{}` verwendet oder sich auf [SDK-Aufgabenabfrage und Streaming-Antworten](https://platform.acedata.cloud/documents/sdk-tasks-and-streaming) bezieht, um einen typisierten Wrapper zu erstellen.

Programmausgabe:

```text theme={null}
elapsed_ms 2543
id chatcmpl-DldCcLvkTFaioST8e6SjOl0wJScQA
model gpt-4o-mini
content ADC_GO_SDK_OK
usage {"prompt_tokens":16,"completion_tokens":6,"total_tokens":22}
```

```python theme={null}
import os, time, json
from acedatacloud import AceDataCloud

client = AceDataCloud(api_token=os.environ["ACEDATACLOUD_API_KEY"])

t0 = time.time()
res = client.openai.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Antworten Sie genau mit: ADC_PY_SDK_OK"}],
    max_tokens=20,
    temperature=0,
)
print("elapsed_ms", int((time.time() - t0) * 1000))
print("id", res["id"])
print("model", res["model"])
print("content", res["choices"][0]["message"]["content"])
print("usage", json.dumps({k: v for k, v in res["usage"].items()
                            if k in ("prompt_tokens","completion_tokens","total_tokens")}))
```

> Python SDK gibt derzeit ein `dict` zurück, daher wird `res["id"]` anstelle von `res.id` verwendet. Dies unterscheidet sich von `openai-python`, was bei der Migration beachtet werden muss.

Programmausgabe:

```text theme={null}
elapsed_ms 2963
id chatcmpl-DldFdnIlhSUXINpupgsUmZL78MnBu
model gpt-4o-mini
content ADC_PY_SDK_OK
usage {"prompt_tokens": 17, "completion_tokens": 7, "total_tokens": 24}
```

### Go

```go theme={null}
package main

import (
    "context"
    "fmt"
    "os"
    "time"

    adc "github.com/AceDataCloud/SDK/go"
)

func main() {
    client, err := adc.NewClient(adc.WithAPIToken(os.Getenv("ACEDATACLOUD_API_KEY")))
    if err != nil {
        panic(err)
    }
    ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
    defer cancel()

    t0 := time.Now()
    res, err := client.OpenAI().Chat().Completions().Create(ctx, adc.ChatCompletionRequest{
        Model:     "gpt-4o-mini",
        Messages:  []map[string]any{{"role": "user", "content": "Antworten Sie genau mit: ADC_GO_SDK_OK"}},
        MaxTokens: 20,
    })
    if err != nil {
        panic(err)
    }
    fmt.Println("elapsed_ms", time.Since(t0).Milliseconds())
    fmt.Println("id", res["id"])
    fmt.Println("model", res["model"])
    choices := res["choices"].([]any)
    msg := choices[0].(map[string]any)["message"].(map[string]any)
    fmt.Println("content", msg["content"])
    usage := res["usage"].(map[string]any)
    fmt.Printf("usage prompt=%v completion=%v total=%v\n",
        usage["prompt_tokens"], usage["completion_tokens"], usage["total_tokens"])
}
```

> Go SDK gibt die Antwort einheitlich als `map[string]any` zurück, es gibt keine stark typisierten Strukturen, daher ist eine Typumwandlung erforderlich. Alle Ressourcen-Accessor sind Methodenketten: `client.OpenAI().Chat().Completions().Create(...)`.

Programmausgabe:

```text theme={null}
elapsed_ms 6436
id chatcmpl-89DHExvFvBc4ciIPfolZYUOy7ivxv
model gpt-4o-mini
content ADC_GO_SDK_OK
usage prompt=16 completion=5 total=21
```

In den Antworten der drei Sprachen stammen `id`, `elapsed_ms` und `usage` aus der gleichen Quelle: Authentifizierung über PlatformGateway → Ziel OpenAI-kompatible API → Aufzeichnung der Abrechnungsdaten. Das Feld `content` ist die tatsächliche Ausgabe des Modells, die feste Kennung `ADC_*_OK` dient dazu, zu beweisen, dass die Antwort nicht vom SDK manipuliert wurde.

## Empfohlene Leseordnung

1. [TypeScript SDK Integrationshandbuch](https://platform.acedata.cloud/documents/sdk-typescript) —— Code, der nach `npm install` sofort ausgeführt werden kann.
2. [Python SDK Integrationshandbuch](https://platform.acedata.cloud/documents/sdk-python) —— Synchron, asynchron, drei Arten der Verwendung.
3. [Go SDK Integrationshandbuch](https://platform.acedata.cloud/documents/sdk-go) —— Go-Stil `context.Context` und kanalbasierte Streams.
4. [SDK Aufgaben-Polling und Streaming-Antworten](https://platform.acedata.cloud/documents/sdk-tasks-and-streaming) —— Unterschiede in der Einheit TaskHandle, Details zur SSE-Implementierung, Retry-Backoff.
5. [SDK + X402 Zahlungs-Hooks](https://platform.acedata.cloud/documents/sdk-x402-payment) —— Keine Token, Abrechnung basierend auf Aufruf.

## So überprüfen Sie das verbleibende Guthaben

Über [Ace Data Cloud Konsole - Anwendungsübersicht](https://platform.acedata.cloud/console/applications) können Sie das aktuelle verbleibende Guthaben Ihres Kontos einsehen.

Über [Ace Data Cloud Konsole - Nutzungshistorie](https://platform.acedata.cloud/console/usages) können Sie alle Nutzungshistorien und Abrechnungsdetails einsehen.

## Erfahren Sie mehr

* 📦 [SDK Monorepo Quellcode](https://github.com/AceDataCloud/SDK)
* 🔌 [X402 Integrationsleitfaden](https://platform.acedata.cloud/documents/x402-integration)
* 🛠 MCP Servers Tutorial
* 📊 [Diensteliste und Preisgestaltung](https://platform.acedata.cloud/services)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.