---
title: Modo rápido
url: https://platform.claude.com/docs/es/build-with-claude/fast-mode
description: Obtén hasta 2.5 veces más tokens de salida por segundo con los modelos de Claude compatibles.
featureMetadata:
  betaHeader: fast-mode-2026-02-01
  zdr:
    eligibility: eligible
    note: Excludes [Covered Models](https://platform.claude.com/docs/en/manage-claude/api-and-data-retention#model-specific-data-retention-requirements). Mismo endpoint de la Messages API con inferencia más rápida. ZDR se aplica independientemente de la configuración de velocidad.
  supportedModels:
    - claude-fable-5-2
    - claude-mythos-5-2
    - claude-opus-5-5
    - claude-opus-5
    - claude-opus-4-8
  supportedPlatforms:
    Claude API:
      availability: stable
      note: 'Fecha de eliminación: 30 de noviembre de 2026. Tras la eliminación, las solicitudes a `claude-opus-4-8` con `speed: "fast"` devolverán un error. Para seguir usando el modo rápido, migra a Claude Opus 5.5. Consulta [Migración a Claude Opus 5.5 desde Claude Opus 4.8](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#migrating-from-claude-opus-4-8).'
    Claude Models on Google Cloud (Anthropic managed): stable
    Claude Models on Google Cloud (Google managed): stable
    Microsoft Foundry:
      availability: stable
      note: En Microsoft Foundry, el modo rápido tiene sus propios ID de modelo, que terminan en `-fast`. Envía las solicitudes a una implementación del modelo del modo rápido y omite `speed`.
  details:
    - El modo rápido está en vista previa de investigación en Claude Opus 5 y obsoleto en Claude Opus 4.8, y requiere el encabezado beta `fast-mode-2026-02-01` en ambos modelos.
---

**Compatibilidad con la API**: El uso varía según el producto.

* **Messages API**: Establece `speed: "fast"` en la solicitud.
* **Managed Agents**: Establece `speed` en el objeto de modelo del agente, por ejemplo `{"id": "claude-opus-5-5", "speed": "fast"}`.

El “fast mode” (modo rápido) ofrece hasta 2.5 veces más tokens de salida por segundo a un precio premium. Establece `speed: "fast"` en tu solicitud para activarlo. El modo rápido está disponible en Claude Fable 5.2, Claude Mythos 5.2 y Claude Opus 5.5. El modo rápido está en vista previa de investigación en Claude Opus 5 y obsoleto en Claude Opus 4.8.

## Cómo funciona el modo rápido

El modo rápido ejecuta el mismo modelo con una configuración de inferencia más rápida. No hay ningún cambio en la inteligencia ni en las capacidades.

* Hasta 2.5 veces más tokens de salida por segundo en comparación con la velocidad estándar
* Los beneficios de velocidad se centran en los “output tokens per second” (tokens de salida por segundo), o OTPS, no en el “time to first token” (tiempo hasta el primer token), o TTFT
* Compatible con [streaming](https://platform.claude.com/docs/es/build-with-claude/streaming), donde la ganancia de OTPS es más visible

## Uso básico

El modo rápido solo funciona en los modelos compatibles. Consulta [Disponibilidad](https://platform.claude.com/docs/es/build-with-claude/fast-mode#feature-availability) para obtener más detalles, incluido qué modelos necesitan un encabezado beta.

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 4096,
      "speed": "fast",
      "messages": [{
        "role": "user",
        "content": "Refactor this module to use dependency injection"
      }]
    }'
  ```

  ```bash CLI
  ant messages create <<'YAML'
  model: claude-opus-5-5
  max_tokens: 4096
  speed: fast
  messages:
    - role: user
      content: Refactor this module to use dependency injection
  YAML
  ```

  ```python Python
  client = anthropic.Anthropic()

  response = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=4096,
      speed="fast",
      messages=[
          {"role": "user", "content": "Refactor this module to use dependency injection"}
      ],
  )

  for block in response.content:
      if block.type == "text":
          print(block.text)
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  const response = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 4096,
    speed: "fast",
    messages: [
      {
        role: "user",
        content: "Refactor this module to use dependency injection"
      }
    ]
  });

  const textBlock = response.content.find((block) => block.type === "text");
  console.log(textBlock?.text);
  ```

  ```csharp C#
  AnthropicClient client = new();

  var response = await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 4096,
      Speed = Speed.Fast,
      Messages = [
          new UserMessageParam { Content = "Refactor this module to use dependency injection" }
      ],
  });

  foreach (var block in response.Content)
  {
      if (block.TryPickText(out var textBlock))
      {
          Console.WriteLine(textBlock.Text);
      }
  }
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 4096,
  	Speed:     anthropic.MessageNewParamsSpeedFast,
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Refactor this module to use dependency injection")),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  for _, block := range response.Content {
  	if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
  		fmt.Println(textBlock.Text)
  	}
  }
  ```

  ```java Java
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  Message response = client.messages().create(
      MessageCreateParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(4096L)
          .speed(MessageCreateParams.Speed.FAST)
          .addUserMessage("Refactor this module to use dependency injection")
          .build());

  response.content().stream()
      .flatMap(block -> block.text().stream())
      .forEach(textBlock -> IO.println(textBlock.text()));
  ```

  ```php PHP
  $client = new Client();

  $response = $client->messages->create(
      model: Model::CLAUDE_OPUS_5_5,
      maxTokens: 4096,
      speed: 'fast',
      messages: [
          ['role' => 'user', 'content' => 'Refactor this module to use dependency injection'],
      ],
  );

  foreach ($response->content as $block) {
      if ($block instanceof \Anthropic\Messages\TextBlock) {
          echo $block->text, PHP_EOL;
      }
  }
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  response = client.messages.create(
    model: Anthropic::Model::CLAUDE_OPUS_5_5,
    max_tokens: 4096,
    speed: "fast",
    messages: [{ role: "user", content: "Refactor this module to use dependency injection" }]
  )

  response.content.each do |block|
    puts block.text if block.is_a?(Anthropic::Models::TextBlock)
  end
  ```
</CodeGroup>

En [Claude en Microsoft Foundry](https://platform.claude.com/docs/es/build-with-claude/claude-in-microsoft-foundry), el modo rápido tiene sus propios ID de modelo, y la implementación establece la velocidad. Envía las solicitudes del modo rápido a una implementación del modelo del modo rápido y omite `speed`:

| Modelo            | ID del modelo del modo rápido |
| ----------------- | ----------------------------- |
| Claude Fable 5.2  | `claude-fable-5-2-fast`       |
| Claude Mythos 5.2 | `claude-mythos-5-2-fast`      |
| Claude Opus 5.5   | `claude-opus-5-5-fast`        |

Una solicitud que establece `speed` en una implementación del modelo estándar, como `claude-opus-5-5`, devuelve un error.

## Límites de velocidad

El modo rápido tiene un “rate limit” (límite de velocidad) dedicado que es independiente de los límites de velocidad estándar. Cuando excedes tu límite de velocidad del modo rápido, la API devuelve un error `429` con un encabezado `retry-after` que indica cuándo hay capacidad disponible. En [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/google-managed#rate-limits), Google Cloud administra los límites de velocidad y las cuotas.

Claude Fable 5.2, Claude Mythos 5.2 y Claude Opus 5.5 tienen un límite de velocidad predeterminado para el modo rápido. El límite predeterminado se aplica en los [niveles de uso](https://platform.claude.com/docs/es/api/rate-limits) Start, Build y Scale. No necesitas solicitar acceso al modo rápido para estos modelos. Las organizaciones en el nivel de evaluación pueden usar el modo rápido con estos modelos una vez que pasen al nivel Start, Build o Scale.

La respuesta incluye encabezados que indican el estado de tu límite de velocidad del modo rápido:

| Encabezado                               | Descripción                                                                 |
| ---------------------------------------- | --------------------------------------------------------------------------- |
| `anthropic-fast-input-tokens-limit`      | Máximo de tokens de entrada del modo rápido por minuto                      |
| `anthropic-fast-input-tokens-remaining`  | Tokens de entrada restantes del modo rápido                                 |
| `anthropic-fast-input-tokens-reset`      | Momento en que se restablece el límite de tokens de entrada del modo rápido |
| `anthropic-fast-output-tokens-limit`     | Máximo de tokens de salida del modo rápido por minuto                       |
| `anthropic-fast-output-tokens-remaining` | Tokens de salida restantes del modo rápido                                  |
| `anthropic-fast-output-tokens-reset`     | Momento en que se restablece el límite de tokens de salida del modo rápido  |

Para ver tus límites de velocidad del modo rápido, ve a la página [Límites de frecuencia](https://platform.claude.com/usage/limits) en la Claude Console.

## Comprobar qué velocidad se utilizó

El objeto `usage` de la respuesta incluye un campo `speed` que indica qué velocidad se utilizó, ya sea `"fast"` o `"standard"`. Solicitar `speed: "fast"` en un [modelo que no admite el modo rápido](https://platform.claude.com/docs/es/build-with-claude/fast-mode#feature-availability) devuelve un error, al igual que exceder los límites de velocidad o la capacidad del modo rápido (un `429` o `529`). Cuando una solicitud con `speed: "fast"` tiene éxito, `usage.speed` es `"fast"`. Claude Opus 4.6 es una excepción: en lugar de devolver un error, una solicitud con `speed: "fast"` y el encabezado beta `fast-mode-2026-02-01` tiene éxito, pero se ejecuta a velocidad estándar. En esta situación, `usage.speed` muestra `"standard"`. En Claude Models on Google Cloud (Anthropic managed), una solicitud a Claude Opus 4.6 con `speed: "fast"` devuelve un error `400` incluso con el encabezado.

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 1024,
      "speed": "fast",
      "messages": [{"role": "user", "content": "Hello"}]
    }'
  ```

  ```bash CLI
  ant messages create <<'YAML'
  model: claude-opus-5-5
  max_tokens: 1024
  speed: fast
  messages:
    - role: user
      content: Hello
  YAML
  ```

  ```python Python
  client = anthropic.Anthropic()

  response = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=1024,
      speed="fast",
      messages=[{"role": "user", "content": "Hello"}],
  )

  print(response.usage.speed)  # "fast" or "standard"
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  const response = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 1024,
    speed: "fast",
    messages: [{ role: "user", content: "Hello" }]
  });

  console.log(response.usage.speed); // "fast" or "standard"
  ```

  ```csharp C#
  AnthropicClient client = new();

  var response = await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 1024,
      Speed = Speed.Fast,
      Messages = [new UserMessageParam { Content = "Hello" }],
  });

  Console.WriteLine(response.Usage.Speed);  // "fast" or "standard"
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 1024,
  	Speed:     anthropic.MessageNewParamsSpeedFast,
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Hello")),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(response.Usage.Speed) // "fast" or "standard"
  ```

  ```java Java
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_OPUS_5_5)
      .maxTokens(1024L)
      .speed(MessageCreateParams.Speed.FAST)
      .addUserMessage("Hello")
      .build();

  Message response = client.messages().create(params);
  IO.println(response.usage().speed().orElseThrow());  // "fast" or "standard"
  ```

  ```php PHP
  $client = new Client();

  $response = $client->messages->create(
      model: Model::CLAUDE_OPUS_5_5,
      maxTokens: 1024,
      speed: 'fast',
      messages: [['role' => 'user', 'content' => 'Hello']],
  );

  echo $response->usage->speed;  // "fast" or "standard"
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  response = client.messages.create(
    model: Anthropic::Model::CLAUDE_OPUS_5_5,
    max_tokens: 1024,
    speed: "fast",
    messages: [{ role: "user", content: "Hello" }]
  )

  puts(response.usage.speed)  # "fast" or "standard"
  ```
</CodeGroup>

```json Output
{
  "id": "msg_01XFDUDYJgAACzvnptvVoYEL",
  "type": "message",
  "role": "assistant",
  // ...
  "usage": {
    "input_tokens": 8,
    "output_tokens": 12,
    "speed": "fast"
  }
}
```

Para hacer un seguimiento del uso y los costos del modo rápido en toda tu organización, consulta la [API de análisis de uso y costos](https://platform.claude.com/docs/es/manage-claude/usage-cost-analytics-api).

## Reintentos y alternativas

### Reintentos automáticos

El SDK reintenta automáticamente los errores `429` del modo rápido hasta dos veces de forma predeterminada (configurable con `max_retries` (typescript, php: `maxRetries`; java: `.maxRetries()`; csharp: `MaxRetries`; go: `option.WithMaxRetries()`)), esperando el tiempo indicado en el encabezado `retry-after` antes de cada reintento. Como el modo rápido utiliza una reposición continua de tokens, el retraso de `retry-after` suele ser corto y las solicitudes tienen éxito una vez que hay capacidad disponible.

### Recurrir a la velocidad estándar

Si prefieres recurrir a la velocidad estándar en lugar de esperar a que haya capacidad en el modo rápido, captura el error de límite de velocidad y vuelve a intentarlo sin `speed: "fast"`. En Claude en Microsoft Foundry, la implementación establece la velocidad, así que, en su lugar, vuelve a intentarlo en una implementación del modelo estándar. Establece `max_retries` (typescript, php: `maxRetries`; java: `.maxRetries()`; csharp: `MaxRetries`; go: `option.WithMaxRetries()`) en `0` en la solicitud rápida inicial para omitir los reintentos automáticos y fallar de inmediato ante errores de límite de velocidad.

<Note>
  Pasar de la velocidad rápida a la estándar provoca un fallo de [caché de prompts](https://platform.claude.com/docs/es/build-with-claude/prompt-caching). Las solicitudes a diferentes velocidades no comparten prefijos almacenados en caché.
</Note>

Como establecer `max_retries` (typescript, php: `maxRetries`; java: `.maxRetries()`; csharp: `MaxRetries`; go: `option.WithMaxRetries()`) en `0` también desactiva los reintentos para otros errores transitorios (sobrecarga, errores internos del servidor), los siguientes ejemplos vuelven a enviar la solicitud después de esos errores.

<CodeGroup exclude="shell:cURL, shell:CLI">
  ```python Python
  client = anthropic.Anthropic()


  def create_message_with_fast_fallback(max_retries=0, max_attempts=3, **params):
      try:
          return client.with_options(max_retries=max_retries).messages.create(**params)
      except anthropic.RateLimitError:
          if params.get("speed") == "fast":
              del params["speed"]
              return create_message_with_fast_fallback(max_retries=max_retries, **params)
          raise
      except (
          anthropic.APIStatusError,
          anthropic.APIConnectionError,
      ) as error:
          if isinstance(error, anthropic.APIStatusError) and error.status_code < 500:
              raise
          if max_attempts > 1:
              return create_message_with_fast_fallback(
                  max_retries=max_retries, max_attempts=max_attempts - 1, **params
              )
          raise


  message = create_message_with_fast_fallback(
      model="claude-opus-5-5",
      max_tokens=1024,
      messages=[{"role": "user", "content": "Hello"}],
      speed="fast",
      max_retries=0,
  )
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  async function createMessageWithFastFallback(
    params: Anthropic.MessageCreateParamsNonStreaming,
    requestOptions?: Anthropic.RequestOptions,
    maxAttempts: number = 3
  ): Promise<Anthropic.Message> {
    try {
      return await client.messages.create(params, requestOptions);
    } catch (e) {
      if (e instanceof Anthropic.RateLimitError && params.speed === "fast") {
        const { speed, ...rest } = params;
        return createMessageWithFastFallback(rest);
      }
      if (
        e instanceof Anthropic.InternalServerError ||
        e instanceof Anthropic.APIConnectionError
      ) {
        if (maxAttempts > 1) {
          return createMessageWithFastFallback(params, undefined, maxAttempts - 1);
        }
      }
      throw e;
    }
  }

  const message = await createMessageWithFastFallback(
    {
      model: "claude-opus-5-5",
      max_tokens: 1024,
      messages: [{ role: "user", content: "Hello" }],
      speed: "fast"
    },
    { maxRetries: 0 }
  );
  ```

  ```csharp C#
  AnthropicClient client = new();

  async Task<Message> CreateMessageWithFastFallback(
      MessageCreateParams parameters,
      int? maxRetries = null,
      int maxAttempts = 3)
  {
      try
      {
          var requestClient = maxRetries is int retries
              ? client.WithOptions(options => options with { MaxRetries = retries })
              : client;
          return await requestClient.Messages.Create(parameters);
      }
      catch (AnthropicRateLimitException)
      {
          if (parameters.Speed is not null)
          {
              return await CreateMessageWithFastFallback(
                  parameters with { Speed = null });
          }
          throw;
      }
      catch (Anthropic5xxException)
      {
          if (maxAttempts > 1)
          {
              return await CreateMessageWithFastFallback(
                  parameters, maxAttempts: maxAttempts - 1);
          }
          throw;
      }
  }

  var message = await CreateMessageWithFastFallback(
      new MessageCreateParams
      {
          Model = Model.ClaudeOpus5_5,
          MaxTokens = 1024,
          Messages = [new UserMessageParam { Content = "Hello" }],
          Speed = Speed.Fast,
      },
      maxRetries: 0);
  ```

  ```go Go
  func createMessageWithFastFallback(
  	ctx context.Context,
  	client *anthropic.Client,
  	params anthropic.MessageNewParams,
  	maxAttempts int,
  	opts ...option.RequestOption,
  ) (*anthropic.Message, error) {
  	message, err := client.Messages.New(ctx, params, opts...)
  	if err != nil {
  		var apierr *anthropic.Error
  		if errors.As(err, &apierr) && apierr.StatusCode == 429 && params.Speed != "" {
  			params.Speed = ""
  			return createMessageWithFastFallback(ctx, client, params, maxAttempts)
  		}
  		if (errors.As(err, &apierr) && apierr.StatusCode >= 500) || !errors.As(err, &apierr) {
  			if maxAttempts > 1 {
  				return createMessageWithFastFallback(ctx, client, params, maxAttempts-1)
  			}
  		}
  		return nil, err
  	}
  	return message, nil
  }

  func main() {
  	client := anthropic.NewClient()
  	message, err := createMessageWithFastFallback(
  		context.TODO(),
  		&client,
  		anthropic.MessageNewParams{
  			Model:     anthropic.ModelClaudeOpus5_5,
  			MaxTokens: 1024,
  			Messages: []anthropic.MessageParam{
  				anthropic.NewUserMessage(anthropic.NewTextBlock("Hello")),
  			},
  			Speed: anthropic.MessageNewParamsSpeedFast,
  		},
  		3,
  		option.WithMaxRetries(0),
  	)
  	if err != nil {
  		panic(err)
  	}
  	fmt.Println(message)
  }
  ```

  ```java Java
  import com.anthropic.errors.InternalServerException;
  import com.anthropic.errors.RateLimitException;
  // ...
  // Desactiva el reintento automático del SDK para que lo gestione la lógica de respaldo siguiente
  AnthropicClient client =
      AnthropicOkHttpClient.builder()
          .fromEnv()
          .maxRetries(0)
          .build();

  Message createMessageWithFastFallback(
          MessageCreateParams params, int maxAttempts) {
      try {
          return client.messages().create(params);
      } catch (RateLimitException e) {
          if (params.speed().isPresent()) {
              MessageCreateParams retryParams = params.toBuilder()
                  .speed(Optional.empty())
                  .build();
              return createMessageWithFastFallback(retryParams, maxAttempts);
          }
          throw e;
      } catch (InternalServerException e) {
          if (maxAttempts > 1) {
              return createMessageWithFastFallback(params, maxAttempts - 1);
          }
          throw e;
      }
  }

  void main() {
      Message message = createMessageWithFastFallback(
          MessageCreateParams.builder()
              .model(Model.CLAUDE_OPUS_5_5)
              .maxTokens(1024L)
              .addUserMessage("Hello")
              .speed(MessageCreateParams.Speed.FAST)
              .build(),
          3);
      message.content().stream()
          .flatMap(block -> block.text().stream())
          .forEach(textBlock -> IO.println(textBlock.text()));
  }
  ```

  ```php PHP
  use Anthropic\Core\Exceptions\APIConnectionException;
  use Anthropic\Core\Exceptions\InternalServerException;
  use Anthropic\Core\Exceptions\RateLimitException;
  use Anthropic\Messages\Model;
  use Anthropic\RequestOptions;

  $client = new Client();

  function createMessageWithFastFallback(
      Client $client,
      array $params,
      ?RequestOptions $requestOptions = null,
      int $maxAttempts = 3,
  ) {
      try {
          return $client->messages->create(
              ...$params,
              requestOptions: $requestOptions,
          );
      } catch (RateLimitException $e) {
          if (isset($params['speed'])) {
              unset($params['speed']);
              return createMessageWithFastFallback($client, $params);
          }
          throw $e;
      } catch (InternalServerException | APIConnectionException $e) {
          if ($maxAttempts > 1) {
              return createMessageWithFastFallback(
                  $client, $params, maxAttempts: $maxAttempts - 1
              );
          }
          throw $e;
      }
  }

  $message = createMessageWithFastFallback(
      $client,
      [
          'model' => Model::CLAUDE_OPUS_5_5,
          'maxTokens' => 1024,
          'messages' => [['role' => 'user', 'content' => 'Hello']],
          'speed' => 'fast',
      ],
      RequestOptions::with(maxRetries: 0),
  );
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  def create_message_with_fast_fallback(client, request_options: {}, max_attempts: 3, **params)
    client.messages.create(**params, request_options: request_options)
  rescue Anthropic::Errors::RateLimitError
    raise unless params[:speed] == "fast"
    params.delete(:speed)
    create_message_with_fast_fallback(client, **params)
  rescue Anthropic::Errors::InternalServerError, Anthropic::Errors::APIConnectionError
    raise unless max_attempts > 1
    create_message_with_fast_fallback(client, max_attempts: max_attempts - 1, **params)
  end

  message = create_message_with_fast_fallback(
    client,
    model: Anthropic::Model::CLAUDE_OPUS_5_5,
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello" }],
    speed: "fast",
    request_options: { max_retries: 0 }
  )
  ```
</CodeGroup>

## Consideraciones

* **Batch API:** El modo rápido no está disponible con la [Batch API](https://platform.claude.com/docs/es/build-with-claude/batch-processing).
* **Priority Tier:** El modo rápido no está disponible con un compromiso de [Priority Tier](https://platform.claude.com/docs/es/api/service-tiers).

## Precios

El modo rápido tiene un precio basado en un multiplicador sobre las tarifas estándar en toda la “context window” (ventana de contexto), incluidas las solicitudes de más de 200k tokens de entrada. En Claude Models on Google Cloud (Google managed), Google Cloud establece los precios del modo rápido. Consulta [Precios de plataformas en la nube](https://platform.claude.com/docs/es/about-claude/pricing#cloud-platform-pricing).

| Modelo                          | Entrada        | Salida         |
| ------------------------------- | -------------- | -------------- |
| Claude Fable 5.2                | $16 USD / MTok | $80 USD / MTok |
| Claude Mythos 5.2               | $16 USD / MTok | $80 USD / MTok |
| Claude Opus 5.5                 | $8 USD / MTok  | $40 USD / MTok |
| Claude Opus 5 / Claude Opus 4.8 | $10 USD / MTok | $50 USD / MTok |

El precio del modo rápido se acumula con otros modificadores de precio:

* Los [multiplicadores del almacenamiento en caché de prompts](https://platform.claude.com/docs/es/about-claude/pricing#prompt-caching) se aplican sobre el precio del modo rápido.
* Los multiplicadores de [residencia de datos](https://platform.claude.com/docs/es/manage-claude/data-residency) se aplican sobre el precio del modo rápido.

Para obtener todos los detalles de precios, consulta la página de [Precios](https://platform.claude.com/docs/es/about-claude/pricing#fast-mode-pricing).

## Disponibilidad

Modo rápido está disponible o en versión preliminar de investigación o en desuso en algunos modelos y es elegible para retención de datos cero y preparación para HIPAA.

### Compatibilidad con la API

El modo rápido solo está disponible en los siguientes modelos. Si estabas usando el modo rápido en un modelo anterior, [migra a un modelo que admita el modo rápido](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide).

Para acceder al modo rápido en Claude Opus 5, contacta a tu gerente de cuenta o [únete a la lista de espera](https://claude.com/fast-mode).

#### [Messages API](https://platform.claude.com/docs/es/build-with-claude/working-with-messages)

* Disponibilidad: Disponible
* Uso: Establece `speed: "fast"` en la solicitud.

| Estado                              | Plataformas en la nube                                                                                                                                                                                                                                                                                                       | Modelos                                                                                                                                                                |
| ----------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Disponible                          | Claude API, [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed), [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/google-managed) | [Claude Fable 5.2](https://platform.claude.com/docs/es/models/fable-5-2/overview), [Claude Mythos 5.2](https://platform.claude.com/docs/es/models/mythos-5-2/overview) |
| Disponible<sup>1</sup>              | [Microsoft Foundry (hosted on Anthropic)](https://platform.claude.com/docs/es/build-with-claude/claude-in-microsoft-foundry)                                                                                                                                                                                                 | [Claude Fable 5.2](https://platform.claude.com/docs/es/models/fable-5-2/overview), [Claude Mythos 5.2](https://platform.claude.com/docs/es/models/mythos-5-2/overview) |
| Disponible                          | Claude API, [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed)                                                                                                                                                       | [Claude Opus 5.5](https://platform.claude.com/docs/es/models/opus-5-5/overview)                                                                                        |
| Disponible<sup>1</sup>              | [Microsoft Foundry (hosted on Azure)](https://platform.claude.com/docs/es/build-with-claude/claude-in-microsoft-foundry)                                                                                                                                                                                                     | [Claude Opus 5.5](https://platform.claude.com/docs/es/models/opus-5-5/overview)                                                                                        |
| Versión preliminar de investigación | Claude API                                                                                                                                                                                                                                                                                                                   | [Claude Opus 5](https://platform.claude.com/docs/es/models/opus-5/overview)                                                                                            |
| En desuso<sup>2</sup>               | Claude API                                                                                                                                                                                                                                                                                                                   | [Claude Opus 4.8](https://platform.claude.com/docs/es/models/opus-4-8/overview)                                                                                        |

1. En Microsoft Foundry, el modo rápido tiene sus propios ID de modelo, que terminan en `-fast`. Envía las solicitudes a una implementación del modelo del modo rápido y omite `speed`.
2. Fecha de eliminación: 30 de noviembre de 2026. Tras la eliminación, las solicitudes a `claude-opus-4-8` con `speed: "fast"` devolverán un error. Para seguir usando el modo rápido, migra a Claude Opus 5.5. Consulta [Migración a Claude Opus 5.5 desde Claude Opus 4.8](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#migrating-from-claude-opus-4-8).

#### [Managed Agents](https://platform.claude.com/docs/es/managed-agents/overview)

* Disponibilidad: Disponible
* Uso: Establece `speed` en el objeto de modelo del agente, por ejemplo `{"id": "claude-opus-5-5", "speed": "fast"}`.

| Estado                              | Plataformas en la nube                                                                                                                                                 | Modelos                                                                         |
| ----------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- |
| Disponible                          | Claude API, [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed) | [Claude Opus 5.5](https://platform.claude.com/docs/es/models/opus-5-5/overview) |
| Versión preliminar de investigación | Claude API                                                                                                                                                             | [Claude Opus 5](https://platform.claude.com/docs/es/models/opus-5/overview)     |
| En desuso<sup>1</sup>               | Claude API                                                                                                                                                             | [Claude Opus 4.8](https://platform.claude.com/docs/es/models/opus-4-8/overview) |

1. Fecha de eliminación: 30 de noviembre de 2026. Tras la eliminación, las solicitudes a `claude-opus-4-8` con `speed: "fast"` devolverán un error. Para seguir usando el modo rápido, migra a Claude Opus 5.5. Consulta [Migración a Claude Opus 5.5 desde Claude Opus 4.8](https://platform.claude.com/docs/es/models/opus-5-5/migration-guide#migrating-from-claude-opus-4-8).

### Encabezados beta requeridos

[Descripción general de los encabezados beta](https://platform.claude.com/docs/es/api/beta-headers)

Los encabezados beta te permiten acceder a funciones experimentales y nuevas capacidades de los modelos antes de que formen parte de la API estándar.

| Encabezado             | Modelos                                                                                                                                                      |
| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `fast-mode-2026-02-01` | [Claude Opus 5](https://platform.claude.com/docs/es/models/opus-5/overview), [Claude Opus 4.8](https://platform.claude.com/docs/es/models/opus-4-8/overview) |

### Manejo de datos

[Descripción general del manejo de datos](https://platform.claude.com/docs/es/manage-claude/api-and-data-retention#feature-eligibility)

| Elemento | Retención de datos cero                                                                                                                                     | HIPAA    |
| -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- | -------- |
| Estado   | Elegible (excluye [Modelos cubiertos](https://platform.claude.com/docs/es/manage-claude/api-and-data-retention#model-specific-data-retention-requirements)) | Elegible |
| Detalles | Mismo endpoint de la Messages API con inferencia más rápida. ZDR se aplica independientemente de la configuración de velocidad.                             | —        |

Endpoints aplicables:

* `/v1/messages` con `speed: "fast"`

## Próximos pasos

<CardGroup cols={2}>
  <Card title="Salidas estructuradas" icon="code-brackets" href="https://platform.claude.com/docs/es/build-with-claude/structured-outputs">
    Obtén resultados JSON validados de flujos de trabajo de agentes.
  </Card>

  <Card title="Precios" icon="calculator" href="https://platform.claude.com/docs/es/about-claude/pricing#fast-mode-pricing">
    Conoce la estructura de precios de Anthropic para modelos y funciones.
  </Card>

  <Card title="Esfuerzo" icon="gauge" href="https://platform.claude.com/docs/es/build-with-claude/effort">
    Controla cuántos tokens usa Claude al responder con el parámetro effort, equilibrando la exhaustividad de la respuesta y la eficiencia de tokens.
  </Card>

  <Card title="Streaming de mensajes" icon="arrow-right" href="https://platform.claude.com/docs/es/build-with-claude/streaming">
    Transmite las respuestas de la Messages API de forma incremental con eventos enviados por el servidor, incluidos deltas de texto, uso de herramientas y pensamiento extendido.
  </Card>
</CardGroup>
