---
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 Claude compatibles.
---

El "fast mode" (modo rápido) ofrece hasta 2.5 veces más tokens de salida por segundo con Claude Opus 5.5, Claude Opus 5, y Claude Opus 4.8, a precios premium. Establece `speed: "fast"` en tu solicitud para activarlo.

<Note>
  El modo rápido para Claude Opus 5.5 no necesita el encabezado beta `fast-mode-2026-02-01` ni una solicitud de acceso. Las solicitudes que aún envían el encabezado siguen funcionando. El modo rápido para Claude Opus 5 y Claude Opus 4.8 está en vista previa de investigación: contacta a tu gerente de cuenta o [únete a la lista de espera](https://claude.com/fast-mode) para solicitar acceso, y envía el [encabezado beta](https://platform.claude.com/docs/es/api/beta-headers) en tus solicitudes.
</Note>

<Note>
  Para saber cómo se aplica la "zero data retention" (retención cero de datos), o ZDR, a esta función, consulta [API y retención de datos](https://platform.claude.com/docs/es/manage-claude/api-and-data-retention).
</Note>

## Modelos y plataformas compatibles

El modo rápido es compatible con los siguientes modelos y plataformas:

| Modelo compatible                 | Plataformas compatibles                                                                                                                                                                                                                                                  |
| --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Claude Opus 5.5 (claude-opus-5-5) | Claude API, incluido [Claude Managed Agents](https://platform.claude.com/docs/es/managed-agents/overview)<br />[Claude en Microsoft Foundry](https://platform.claude.com/docs/es/build-with-claude/claude-in-microsoft-foundry), para implementaciones alojadas en Azure |
| Claude Opus 5 (claude-opus-5)     | Claude API, incluido [Claude Managed Agents](https://platform.claude.com/docs/es/managed-agents/overview)                                                                                                                                                                |
| Claude Opus 4.8 (claude-opus-4-8) | Claude API, incluido [Claude Managed Agents](https://platform.claude.com/docs/es/managed-agents/overview)                                                                                                                                                                |

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

El modo rápido no está disponible para las implementaciones de Claude en Microsoft Foundry [alojadas en Anthropic](https://platform.claude.com/docs/es/build-with-claude/claude-in-microsoft-foundry#hosting-options).

## 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), u OTPS, no en el "time to first token" (tiempo hasta el primer token), o TTFT
* Los mismos pesos y comportamiento del modelo (no es un modelo diferente)
* Compatible con [streaming](https://platform.claude.com/docs/es/build-with-claude/streaming), donde la ganancia en OTPS es más visible

## Uso básico

Los modelos en vista previa de investigación también necesitan el [encabezado beta](https://platform.claude.com/docs/es/api/beta-headers) `fast-mode-2026-02-01`.

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -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 is Anthropic.TextBlock => 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() { Role = Role.User, 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: '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: "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.type == :text
  end
  ```
</CodeGroup>

## 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. La siguiente tabla muestra los precios del modo rápido para los modelos compatibles:

| Modelo                          | Entrada        | Salida         |
| ------------------------------- | -------------- | -------------- |
| Claude Opus 5.5                 | $8 USD / MTok  | $40 USD / MTok |
| Claude Opus 5 / Claude Opus 4.8 | $10 USD / MTok | $50 USD / MTok |

Los precios del modo rápido se acumulan con otros modificadores de precio:

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

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

## 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 de Opus. Cuando se excede tu límite de velocidad del modo rápido, la API devuelve un error `429` con un encabezado `retry-after` que indica cuándo habrá capacidad disponible.

Claude Opus 5.5 tiene un límite de velocidad predeterminado del modo rápido en los [niveles de uso](https://platform.claude.com/docs/es/api/rate-limits) Start, Build y Scale, por lo que no necesitas solicitar acceso para usar el modo rápido con él. Las organizaciones en el nivel Evaluation pueden usar el modo rápido con Claude Opus 5.5 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 del modo rápido restantes                                 |
| `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 del modo rápido restantes                                  |
| `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 velocidad](https://platform.claude.com/usage/limits) en la Claude Console.

## Verificar qué velocidad se usó

El objeto `usage` de la respuesta incluye un campo `speed` que indica qué velocidad se usó, 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#supported-models-and-platforms) 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. Este comportamiento se refleja correctamente en `usage.speed`, que muestra `"standard"` en esta situación.

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -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 \
    --transform usage.speed \
    --raw-output <<'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() { Role = Role.User, 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: '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: "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 uso y costos](https://platform.claude.com/docs/es/manage-claude/usage-cost-api).

## Reintentos y alternativa de respaldo

### Reintentos automáticos

Cuando se exceden los límites de velocidad del modo rápido, la API devuelve un error `429` con un encabezado `retry-after`. El SDK reintenta automáticamente estas solicitudes hasta 2 veces de forma predeterminada (configurable con `max_retries` (typescript, java, php: `maxRetries`; csharp: `MaxRetries`; go: `option.WithMaxRetries`)), esperando el retraso especificado por el servidor antes de cada reintento. Como el modo rápido usa reposición continua de tokens, el retraso de `retry-after` suele ser corto y las solicitudes tienen éxito en cuanto 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 reintenta sin `speed: "fast"`. Establece `max_retries` (typescript, java, php: `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>
  Recurrir de la velocidad rápida a la estándar provocará un fallo de la [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, java, php: `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 emitir la solicitud original con los reintentos predeterminados para esos casos.

<CodeGroup exclude="shell:cURL">
  ```bash CLI
  # `ant` reintenta 429/5xx automáticamente y no tiene anulación de max_retries
  # por solicitud, así que ante un 429 en modo rápido el respaldo se ejecuta tras agotar
  # los reintentos integrados. --transform-error expone error.type para ramificar.
  create_message_with_fast_fallback() {
    local speed="$1" max_attempts="${2:-3}" body out
    body=${3:-$(cat)}
    out=$(
      ant messages create \
        ${speed:+--speed "$speed"} \
        --transform-error error.type --format-error yaml <<<"$body" 2>/dev/null
    ) && { printf '%s\n' "$out"; return; }
    case "$out" in
      rate_limit_error)
        if [[ -n "$speed" ]]; then
          create_message_with_fast_fallback "" "$max_attempts" "$body"
          return
        fi ;;
      overloaded_error | api_error | "")
        if (( max_attempts > 1 )); then
          create_message_with_fast_fallback "$speed" $((max_attempts - 1)) "$body"
          return
        fi ;;
    esac
    printf '%s\n' "${out:-connection_error}" >&2
    return 1
  }

  MESSAGE=$(
    create_message_with_fast_fallback fast <<'YAML'
  model: claude-opus-5-5
  max_tokens: 1024
  messages:
    - role: user
      content: Hello
  YAML
  )
  ```

  ```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() { Role = Role.User, 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 los reintentos automáticos del SDK para que la lógica de respaldo de abajo los gestione
  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\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' => '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: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello" }],
    speed: "fast",
    request_options: { max_retries: 0 }
  )
  ```
</CodeGroup>

## Consideraciones

* **Almacenamiento en caché de prompts:** Cambiar entre la velocidad rápida y la estándar invalida la caché de prompts. Las solicitudes a diferentes velocidades no comparten prefijos almacenados en caché.
* **TTFT:** Los beneficios del modo rápido se centran en los tokens de salida por segundo (OTPS), no en el tiempo hasta el primer token (TTFT).
* **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).
* **Claude Platform on AWS:** Actualmente, el modo rápido no está disponible en [Claude Platform on AWS](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws).

## 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 funcionalidades.
  </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 entre 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, incluyendo texto, uso de herramientas y deltas de pensamiento extendido.
  </Card>
</CardGroup>