ShareAI
AI Prosumer
DE
Sprache
OpenAI

gpt-4o

API-Schlüssel abrufen
openai/gpt-4o

GPT-4o (\"o\" für \"omni\") ist OpenAIs neuestes KI-Modell, das sowohl Text- als auch Bildeingaben mit Textausgaben unterstützt. Es bietet die gleiche Intelligenzstufe wie GPT-4 Turbo, ist jedoch doppelt so schnell und 50% kosteneffizienter. GPT-4o bietet zudem verbesserte Leistungen bei der Verarbeitung nicht-englischer Sprachen und erweiterte visuelle Fähigkeiten. Für Benchmarking-Zwecke wurde es kurzzeitig \'im-also-a-good-gpt2-chatbot\" genannt."

Eingabe → Ausgabe
Text, Bild Text
Zugriff
Nicht verfügbar
Kontextfenster
128.000 Tokens
Maximale Leistung
16.384 Tokens
Lizenz: proprietär

Vom Modell zur Anwendung

Schnellstart

API-Referenz

  1. Holen Sie sich Ihren API-Schlüssel

    Erstellen Sie einen Schlüssel in der ShareAI-Konsole und speichern Sie ihn dann als Umgebungsvariable auf Ihrem Server.

    API-Schlüssel erstellen
    Umgebungsvariable
    export SHAREAI_API_KEY="your-api-key"

  2. Wählen Sie Ihren Endpunkt

    Senden Sie eine POST-Anfrage mit Ihrem API-Schlüssel im Authorization-Header.

    POSThttps://api.shareai.now/api/v1/chat/completions

    Der Endpunkt dieses Tags wurde nicht bestätigt. Überprüfen Sie die API-Referenz und Ihre Konsole, bevor Sie eine Anfrage senden.

  3. Stellen Sie Ihre erste Anfrage

    Die Beispiele verwenden dein ausgewähltes Tag und zeigen dessen Anforderungsformat. Führe sie auf deinem Server aus, um deinen API-Schlüssel privat zu halten. Die Verfügbarkeit des Modells und der Kontozugriff werden überprüft, wenn du eine Anfrage sendest.

    cURL
    curl --fail-with-body --request POST 'https://api.shareai.now/api/v1/chat/completions' \
  --header "Authorization: Bearer ${SHAREAI_API_KEY}" \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "model": "openai/gpt-4o",
  "messages": [
    {
      "role": "user",
      "content": "Hello!"
    }
  ],
  "stream": false
}'
    Python
    import json
import os
import urllib.request

payload = {
    "model": "openai/gpt-4o",
    "messages": [
        {
            "role": "user",
            "content": "Hello!",
        },
    ],
    "stream": False,
}
request = urllib.request.Request("https://api.shareai.now/api/v1/chat/completions",
    data=json.dumps(payload).encode(),
    headers={
        "Authorization": f"Bearer {os.environ['SHAREAI_API_KEY']}",
        "Content-Type": "application/json",
    },
    method="POST",
)
with urllib.request.urlopen(request, timeout=180) as response:
    print(json.dumps(json.load(response), indent=2))
    Go
    package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
    "time"
)

func main() {
    if err := run(); err != nil {
        fmt.Fprintln(os.Stderr, err)
        os.Exit(1)
    }
}

func run() error {
    key := os.Getenv("SHAREAI_API_KEY")
    if key == "" { return fmt.Errorf("set SHAREAI_API_KEY") }
    body := []byte(`{
  "model": "openai/gpt-4o",
  "messages": [
    {
      "role": "user",
      "content": "Hello!"
    }
  ],
  "stream": false
}`)
    request, err := http.NewRequest(http.MethodPost, "https://api.shareai.now/api/v1/chat/completions", bytes.NewReader(body))
    if err != nil { return err }
    request.Header.Set("Authorization", "Bearer " + key)
    request.Header.Set("Content-Type", "application/json")
    client := &http.Client{Timeout: 180 * time.Second}
    response, err := client.Do(request)
    if err != nil { return err }
    defer response.Body.Close()
    if response.StatusCode < 200 || response.StatusCode >= 300 {
        detail, _ := io.ReadAll(io.LimitReader(response.Body, 1<<20))
        return fmt.Errorf("ShareAI HTTP %d: %s", response.StatusCode, detail)
    }
    var result any
    if err := json.NewDecoder(response.Body).Decode(&result); err != nil { return err }
    encoder := json.NewEncoder(os.Stdout)
    encoder.SetIndent("", "  ")
    return encoder.Encode(result)
}

    Speichere als main.go und führe go run main.go aus. Dieses Beispiel verwendet die Go-Standardbibliothek.

    Rust-Abhängigkeiten einrichten

    Füge in deinem Cargo-Projekt diese Abhängigkeiten hinzu. Speichere das Beispiel als src/main.rs und führe dann cargo run aus.

    Cargo-Befehle
    cargo add [email protected] --no-default-features --features blocking,json,rustls-tls
cargo add serde_json@1
    Rost
    fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("SHAREAI_API_KEY")?;
    let payload: serde_json::Value = serde_json::from_str(r#"{
  "model": "openai/gpt-4o",
  "messages": [
    {
      "role": "user",
      "content": "Hello!"
    }
  ],
  "stream": false
}"#)?;
    let client = reqwest::blocking::Client::builder()
        .timeout(std::time::Duration::from_secs(180))
        .build()?;
    let response = client.post(r#"https://api.shareai.now/api/v1/chat/completions"#)
        .bearer_auth(api_key)
        .json(&payload)
        .send()?
        .error_for_status()?;
    let result: serde_json::Value = response.json()?;
    println!("{}", serde_json::to_string_pretty(&result)?);
    Ok(())
}
    TypeScript
    const payload = {
  "model": "openai/gpt-4o",
  "messages": [
    {
      "role": "user",
      "content": "Hello!"
    }
  ],
  "stream": false
};
const response = await fetch("https://api.shareai.now/api/v1/chat/completions", {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.SHAREAI_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify(payload),
});
if (!response.ok) throw new Error(await response.text());
console.log(JSON.stringify(await response.json(), null, 2));

Token-Austausch

Kein Token Exchange-Zugriff für dieses Tag

Nutzen Sie das Netzwerk mit Ihrem Token-Guthaben. Die Verbrauchseinstellungen Ihres Kontos bestimmen, wie Anfragen abgerechnet werden.

Ein paar weitere Details

Häufig gestellte Fragen

Was ist gpt-4o?

GPT-4o (\"o\" für \"omni\") ist OpenAIs neuestes KI-Modell, das sowohl Text- als auch Bildeingaben mit Textausgaben unterstützt. Es bietet die gleiche Intelligenzstufe wie GPT-4 Turbo, ist jedoch doppelt so schnell und 50% kosteneffizienter. GPT-4o bietet zudem verbesserte Leistungen bei der Verarbeitung nicht-englischer Sprachen und erweiterte visuelle Fähigkeiten. Für Benchmarking-Zwecke wurde es kurzzeitig \'im-also-a-good-gpt2-chatbot\" genannt."

Wie viel kostet gpt-4o?

Dieses Tag ist derzeit nicht für den Token-Austausch gelistet. Wähle ein anderes Tag aus dem Netzwerk.

Welche Eingaben und Ausgaben unterstützt gpt-4o?

Eingaben: Text, Bild. Ausgaben: Text. Diese Funktionen gelten für das ausgewählte Modell-Tag. Überprüfen Sie die Endpunkt-Dokumentation für unterstützte Anforderungsformate.

Wie lang ist der Kontext von gpt-4o?

Dieses Tag hat ein Kontextfenster von 128.000 Tokens. Kontextgröße und Preisschwellen sind getrennt. Anfragelimits können für eine bestimmte Bereitstellung niedriger sein. Maximale Ausgabe: 16.384 Tokens.

Unterstützt gpt-4o Tool-Aufrufe und strukturierte Ausgaben?

Tool-Aufrufe: Unterstützt. Strukturierte Ausgaben: Unterstützt.

Wie verwende ich gpt-4o mit ShareAI?

Erstellen Sie einen API-Schlüssel in der ShareAI-Konsole, wählen Sie einen Modell-Tag aus und senden Sie eine authentifizierte Anfrage an den Endpunkt im Quick Start. Ihr Schlüssel muss Zugriff auf das gewählte Modell haben. Bewahren Sie Ihren Schlüssel auf Ihrem Server auf.