Authentifizierungsleitfaden

Erfahren Sie, wie Sie sich mit der Smart Money API über API-Schlüssel, JWT-Token und OAuth 2.0 authentifizieren. Sichern Sie Ihre Integrationen mit branchenüblichen Authentifizierungsmethoden und Best Practices.

Übersicht

Die Smart Money API unterstützt mehrere Authentifizierungsmethoden für verschiedene Anwendungsfälle. Wählen Sie die Methode, die am besten zu Ihrer Integration passt:

API-Schlüssel (primär): Senden Sie Ihren Schlüssel im X-API-Key Request-Header für alle REST-API-Aufrufe. Dies ist die empfohlene Methode für Bots und Server-zu-Server-Anwendungen.

Session-JWT (Fallback): Browser-/Dashboard-Sessions authentifizieren sich mit einem Session-JWT über Authorization: Bearer, gültig für 24 Stunden. Programmatische Clients sollten bevorzugt X-API-Key.

OAuth 2.0: Enterprise-fähige Authentifizierung für Multi-User-Anwendungen und Drittanbieter-Integrationen. Benutzer autorisieren Ihre App, auf ihre Daten zuzugreifen.

Alle API-Anfragen müssen über HTTPS erfolgen. Unverschlüsselte HTTP-Anfragen werden abgelehnt. Geben Sie API-Schlüssel niemals in die Versionskontrolle ein oder teilen Sie sie öffentlich.

API-Schlüssel

API-Schlüssel sind eindeutige Anmeldeinformationen für Ihr Konto. Jeder Schlüssel repräsentiert einen Satz von Berechtigungen und Kontingenten. Sie können mehrere Schlüssel für verschiedene Anwendungen oder Umgebungen (Entwicklung, Staging, Produktion) generieren.

Generieren eines API-Schlüssels

Generieren Sie API-Schlüssel über Ihre Account-Konsole:

Navigieren Sie zur Smart Money Console
Wählen Sie "API-Schlüssel" aus der Seitenleiste
Klicken Sie auf "Neuen Schlüssel generieren"
Wählen Sie den Schlüsseltyp (Entwicklung, Staging, Produktion)
Setzen Sie Rate-Limit und Funktionen
Kopieren und speichern Sie den Schlüssel sicher

Speichern Sie Ihren API-Schlüssel sofort! Sie können ihn später nicht mehr einsehen. Wenn Sie ihn verlieren, müssen Sie einen neuen Schlüssel generieren.

Schlüsselformat

API-Schlüssel folgen einem Standardformat:

Schlüsselformat

sk_live_4e3e4d0f1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9t0u1v2w3x4y5z
sk_test_8f4g5h6i7j8k9l0m1n2o3p4q5r6s7t8u9v0w1x2y3z4a5b6c7d8e9f
sk_dev_a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9t0u1v2w3x4y5z6a7b

Schlüsselpräfixe zeigen die Umgebung an:

sk_live_ — Produktionsschlüssel mit vollem Kontingent

sk_test_ — Testschlüssel mit reduziertem Kontingent und Entwicklungsdaten

sk_dev_ — Persönliche Entwicklungsschlüssel mit Sandbox-Daten

X-API-Key-Header (primär)

Senden Sie Ihren API-Schlüssel im X-API-Key Request-Header für alle API-Anfragen. Platzieren Sie Ihren Schlüssel niemals in einer URL.

HTTP-Header

HTTP

GET /v1/whales/events HTTP/1.1
Host: api.smartmoneyapi.com
X-API-Key: sm_your_key
Content-Type: application/json

cURL-Beispiel

Shell

curl -X GET https://api.smartmoneyapi.com/v1/whales/events \
  -H "X-API-Key: sm_your_key" \
  -H "Content-Type: application/json"

Python-Beispiel

Python

import requests

api_key = "sm_your_key"
headers = {
    "X-API-Key": api_key,
    "Content-Type": "application/json"
}

response = requests.get(
    "https://api.smartmoneyapi.com/v1/whales/events",
    headers=headers
)

data = response.json()

JWT-Token-Authentifizierung

Für langlebige Sessions und Server-zu-Server-Kommunikation können Sie Ihren API-Schlüssel gegen ein JWT-Token eintauschen. JWT-Token sind 24 Stunden gültig und reduzieren die Notwendigkeit, Ihren API-Schlüssel im Anwendungscode zu speichern.

JWT-Token abrufen

POSTen Sie Ihren API-Schlüssel an den JWT-Endpunkt, um ein Token zu erhalten:

cURL

curl -X POST https://api.smartmoneyapi.com/auth/jwt \
  -H "Content-Type: application/json" \
  -d '{
    "api_key": "sk_live_4e3e4d0f1b2c3d4e5f6g7h8i9j0k1l2m"
  }'

JWT-Antwort

JSON

{
  "success": true,
  "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c",
  "expires_in": 86400,
  "token_type": "Bearer"
}

JWT-Token verwenden

Verwenden Sie das JWT-Token im Authorization-Header wie API-Schlüssel:

Python

import requests
import json
from datetime import datetime, timedelta

class JWTAuth:
    def __init__(self, api_key):
        self.api_key = api_key
        self.token = None
        self.token_expires = None

    def get_valid_token(self):
        # Check if current token is still valid
        if self.token and self.token_expires > datetime.now():
            return self.token

        # Get new token
        response = requests.post(
            "https://api.smartmoneyapi.com/auth/jwt",
            json={"api_key": self.api_key}
        )

        data = response.json()
        self.token = data["token"]
        self.token_expires = datetime.now() + timedelta(seconds=data["expires_in"])

        return self.token

    def request(self, method, url, **kwargs):
        token = self.get_valid_token()
        headers = kwargs.get("headers", {})
        headers["Authorization"] = f"Bearer {token}"
        kwargs["headers"] = headers

        return requests.request(method, url, **kwargs)

# Usage
auth = JWTAuth("sk_live_4e3e4d0f1b2c3d4e5f6g7h8i9j0k1l2m")
response = auth.request(
    "GET",
    "https://api.smartmoneyapi.com/v1/whales/events"
)
print(response.json())

OAuth 2.0

OAuth 2.0 ist für Anwendungen gedacht, die auf mehrere Benutzerkonten zugreifen müssen. Benutzer erteilen Ihrer Anwendung die Berechtigung, auf ihre Daten zuzugreifen, ohne ihre API-Schlüssel teilen zu müssen.

OAuth 2.0-Fluss

Die Smart Money API unterstützt den Authorization Code-Fluss für Webanwendungen:

Benutzer klickt auf "Mit Smart Money verbinden"-Button
Browser leitet zur Autorisierungsseite weiter
Benutzer erteilt Ihrer Anwendung die Berechtigung
Browser leitet mit Autorisierungscode zurück
Ihr Backend tauscht den Code gegen ein Access-Token aus
Sie können nun im Namen des Benutzers auf Daten zugreifen

Schritt 1: Autorisierungsanfrage

Leiten Sie den Benutzer zum Autorisierungs-Endpunkt weiter:

URL

https://auth.smartmoneyapi.com/authorize?
client_id=YOUR_CLIENT_ID&
redirect_uri=https://yourapp.com/callback&
response_type=code&
scope=whale_positions+funding_rates+liquidations&
state=random_state_string

Schritt 2: Token-Austausch

Nachdem der Benutzer die Berechtigung erteilt hat, tauschen Sie den Code gegen ein Access-Token aus:

cURL

curl -X POST https://auth.smartmoneyapi.com/token \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "grant_type=authorization_code&code=AUTH_CODE&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET&redirect_uri=https://yourapp.com/callback"

OAuth-Token-Antwort

JSON

{
  "access_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
  "token_type": "Bearer",
  "expires_in": 3600,
  "refresh_token": "rt_1a2b3c4d5e6f7g8h9i0j1k2l3m4n5o6p",
  "scope": "whale_positions funding_rates liquidations"
}

Sicherheits-Best Practices

Schlüssel sicher speichern

Geben Sie API-Schlüssel niemals in die Versionskontrolle ein, hardcodieren Sie sie nicht in Anwendungen oder teilen Sie sie in Dokumentationen. Verwenden Sie Umgebungsvariablen oder sichere Schlüsselverwaltungsdienste wie AWS Secrets Manager, HashiCorp Vault oder ähnliche.

Nur HTTPS verwenden

Alle API-Anfragen müssen HTTPS (TLS 1.2 oder höher) verwenden. HTTP-Anfragen werden abgelehnt. Dies stellt sicher, dass Ihr API-Schlüssel und Ihre Daten während der Übertragung verschlüsselt sind.

Schlüsselberechtigungen einschränken

Erstellen Sie separate API-Schlüssel für verschiedene Anwendungen und Umgebungen. Verwenden Sie Bereiche, um einzuschränken, was jeder Schlüssel zugreifen kann. Verwenden Sie keine Produktionsschlüssel in der Entwicklung.

Schlüsselverwendung überwachen

Überprüfen Sie regelmäßig die API-Nutzung in Ihrer Konsole. Richten Sie Alarme für ungewöhnliche Aktivitäten oder sich nähernde Kontingentgrenzen ein. Löschen Sie Schlüssel, die Sie nicht mehr verwenden.

Schlüsselrotation

Rotieren Sie Ihre API-Schlüssel regelmäßig, um das Risiko eines Kompromitts zu verringern. Wir empfehlen, Schlüssel alle 90 Tage zu rotieren:

Generieren Sie einen neuen API-Schlüssel in Ihrer Konsole
Aktualisieren Sie Ihre Anwendungen, um den neuen Schlüssel zu verwenden
Testen Sie, ob alles korrekt funktioniert
Löschen Sie den alten Schlüssel aus Ihrer Konsole

Bereiche & Berechtigungen

Beim Erstellen von API-Schlüsseln oder bei der Verwendung von OAuth geben Sie an, auf welche Ressourcen Ihr Schlüssel zugreifen kann:

Bereich	Beschreibung	Stufe
whale_positions	Lese-Positionen von Wallet-Wallets	Trader+
funding_rates	Lese-Daten zu Funding Rates	Free+
liquidations	Lese-Liquidationsfeeds	Free+
open_interest	Lese-Daten zu Open Interest	Trader+
confirmation_scores	Lese AI-Bestätigungswerte	Pro+
on_chain	Lese On-Chain-Metriken	Pro+

Authentifizierungs-Code-Beispiele

Vollständige Python-Integration

Python

import requests
from typing import Optional, Dict
from datetime import datetime, timedelta

class SmartMoneyAuth:
    """Handles all authentication methods for Smart Money API"""

    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.smartmoneyapi.com"
        self.jwt_token = None
        self.jwt_expires = None

    def get_jwt_token(self) -> str:
        """Get or refresh JWT token"""
        if self.jwt_token and self.jwt_expires > datetime.now():
            return self.jwt_token

        response = requests.post(
            f"{self.base_url}/auth/jwt",
            json={"api_key": self.api_key}
        )
        data = response.json()
        self.jwt_token = data["token"]
        self.jwt_expires = datetime.now() + timedelta(seconds=data["expires_in"] - 300)
        return self.jwt_token

    def headers_bearer(self) -> Dict:
        """Get headers for Bearer token auth"""
        return {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }

    def headers_jwt(self) -> Dict:
        """Get headers for JWT auth"""
        token = self.get_jwt_token()
        return {
            "Authorization": f"Bearer {token}",
            "Content-Type": "application/json"
        }

    def request(self, method: str, endpoint: str, use_jwt: bool = False, **kwargs) -> Dict:
        """Make authenticated request"""
        headers = self.headers_jwt() if use_jwt else self.headers_bearer()
        response = requests.request(
            method,
            f"{self.base_url}{endpoint}",
            headers=headers,
            **kwargs
        )
        return response.json()

# Usage
auth = SmartMoneyAuth("sk_live_abc123xyz789")

# Bearer token method
whales = auth.request("GET", "/v1/whales/events?symbol=BTCUSDT")

# JWT method (auto-refreshing)
whales_jwt = auth.request("GET", "/v1/whales/events?symbol=BTCUSDT", use_jwt=True)

print(f"Found {whales['data']['total']} whale positions")

Brauchen Sie Hilfe?

Überprüfen Sie unsere API-Dokumentation oder kontaktieren Sie den Support, wenn Sie Hilfe bei der Authentifizierung benötigen.

API-Referenz

Generieren Sie Ihren ersten API-Schlüssel

Beginnen Sie mit der Smart Money API. Erstellen Sie Ihr Konto und generieren Sie Authentifizierungsdaten in wenigen Minuten.

Zur Konsole gehen