AI Prosumer
ES
deepseek/deepseek-v4-flash

DeepSeek-V4-Flash es un modelo de DeepSeek que acepta texto y produce texto. Esta entrada de catálogo identifica deepseek/deepseek-v4-flash. Su ventana de contexto revisada es de 1,048,576 tokens; los límites de implementación pueden ser menores.

Entrada → Salida
Texto Texto
Entrada / Salida · por 1M de tokens
€0.171303 / €0.459815
Ventana de contexto
1.048.576 tokens
Máximo rendimiento
384.000 tokens
Licencia: código_abierto

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": "deepseek/deepseek-v4-flash",
      "messages": [
        {
          "role": "user",
          "content": "Hello!"
        }
      ],
      "stream": false
    }'
    Python
    import json
    import os
    import urllib.request
    
    payload = {
        "model": "deepseek/deepseek-v4-flash",
        "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": "deepseek/deepseek-v4-flash",
      "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": "deepseek/deepseek-v4-flash",
      "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": "deepseek/deepseek-v4-flash",
      "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));

Precios

EUR · por 1M de tokens

ShareAI EUR

Entrada
Todas las longitudes€0.171303/M fichas
Salida
Todas las longitudes€0.459815/M fichas
Lectura de caché
Todas las longitudes€0.025245/M fichas
Escritura de caché
Todas las longitudes€0.171303/M fichas

Cache write sigue la tarifa de entrada. Los tokens en caché se cuentan una sola vez.

Un poco más de detalle

Preguntas frecuentes

¿Qué es DeepSeek-V4-Flash?

DeepSeek-V4-Flash es un modelo de DeepSeek que acepta texto y produce texto. Esta entrada de catálogo identifica deepseek/deepseek-v4-flash. Su ventana de contexto revisada es de 1,048,576 tokens; los límites de implementación pueden ser menores.

¿Cuánto cuesta DeepSeek-V4-Flash?

Las tarifas publicadas de ShareAI comienzan en €0.171303 por entrada y €0.459815 por salida por millón de tokens. Las tarifas dependen de la etiqueta seleccionada, el plan de precios y el rango de tokens. Consulta Precios arriba para las tarifas de caché y todos los niveles publicados.

¿Qué entradas y salidas admite DeepSeek-V4-Flash?

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

¿Cuál es la longitud de contexto de DeepSeek-V4-Flash?

Esta etiqueta tiene una ventana de contexto de 1.048.576 tokens. El tamaño del contexto y los umbrales de precios son independientes. Los límites de solicitudes pueden ser menores para una implementación específica. Salida máxima: 384.000 tokens.

¿DeepSeek-V4-Flash admite llamadas a herramientas y salidas estructuradas?

Llamadas a herramientas: Compatible. Salidas estructuradas: Compatible.

¿Cómo uso DeepSeek-V4-Flash 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.