ShareAI
AI Prosumer
ES
Idioma
OpenAI

gpt-4o

Obtener clave API
openai/gpt-4o

GPT-4o (\"o\" de \"omni\") es el último modelo de IA de OpenAI, compatible con entradas de texto e imagen y salidas de texto. Mantiene el nivel de inteligencia de GPT-4 Turbo mientras es el doble de rápido y un 50% más rentable. GPT-4o también ofrece un mejor rendimiento en el procesamiento de idiomas no ingleses y capacidades visuales mejoradas. Para la comparación con otros modelos, fue brevemente llamado \'im-also-a-good-gpt2-chatbot\"."

Entrada → Salida
Texto, Imagen Texto
Acceso
No disponible
Ventana de contexto
128.000 tokens
Máximo rendimiento
16.384 tokens
Licencia: propietario

Del modelo a la aplicación

Inicio rápido

Referencia de API

  1. Obtén tu clave API

    Crea una clave en la Consola de ShareAI, luego guárdala como una variable de entorno en tu servidor.

    Crear clave API
    Variable de entorno
    export SHAREAI_API_KEY="your-api-key"

  2. Elige tu endpoint

    Envía una solicitud POST con tu clave API en el encabezado de Autorización.

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

    El endpoint de esta etiqueta no ha sido confirmado. Consulta la referencia de la API y tu Consola antes de enviar una solicitud.

  3. Realiza tu primera solicitud

    Los ejemplos utilizan tu etiqueta seleccionada y muestran su formato de solicitud. Ejecútalos en tu servidor para mantener tu clave API privada. La disponibilidad del modelo y el acceso a la cuenta se verifican cuando envías una solicitud.

    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)
}

    Guarda como main.go y ejecuta go run main.go. Este ejemplo utiliza la biblioteca estándar de Go.

    Configura las dependencias de Rust

    En tu proyecto Cargo, añade estas dependencias. Guarda el ejemplo como src/main.rs, luego ejecuta cargo run.

    Comandos de Cargo
    cargo add [email protected] --no-default-features --features blocking,json,rustls-tls
cargo add serde_json@1
    Óxido
    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));

Intercambio de Tokens

Sin acceso al Intercambio de Tokens para esta etiqueta

Usa la red con el saldo de tus tokens. La configuración de consumo de tu cuenta determina cómo se facturan las solicitudes.

Un poco más de detalle

Preguntas frecuentes

¿Qué es gpt-4o?

GPT-4o (\"o\" de \"omni\") es el último modelo de IA de OpenAI, compatible con entradas de texto e imagen y salidas de texto. Mantiene el nivel de inteligencia de GPT-4 Turbo mientras es el doble de rápido y un 50% más rentable. GPT-4o también ofrece un mejor rendimiento en el procesamiento de idiomas no ingleses y capacidades visuales mejoradas. Para la comparación con otros modelos, fue brevemente llamado \'im-also-a-good-gpt2-chatbot\"."

¿Cuánto cuesta gpt-4o?

Esta etiqueta no está actualmente listada para el Intercambio de Tokens. Elige otra etiqueta de la Red.

¿Qué entradas y salidas admite gpt-4o?

Entradas: Texto, Imagen. Salidas: Texto. Estas capacidades se aplican a la etiqueta del modelo seleccionado. Consulta la documentación del endpoint para los formatos de solicitud compatibles.

¿Cuál es la longitud de contexto de gpt-4o?

Esta etiqueta tiene una ventana de contexto de 128.000 tokens. El tamaño del contexto y los umbrales de precios son independientes. Los límites de solicitud pueden ser menores para una implementación en particular. Salida máxima: 16.384 tokens.

¿gpt-4o admite llamadas a herramientas y salidas estructuradas?

Llamadas a herramientas: Compatible. Salidas estructuradas: Compatible.

¿Cómo uso gpt-4o con ShareAI?

Crea una clave API en la Consola de ShareAI, elige una etiqueta de modelo y envía una solicitud autenticada al endpoint en Inicio Rápido. Tu clave debe tener acceso al modelo elegido. Mantén tu clave en tu servidor.