# CreateEmbeddingsProvider


## Fields

| Field                                                                                                                                                                                                                                                                                | Type                                                                                                                                                                                                                                                                                 | Required                                                                                                                                                                                                                                                                             | Description                                                                                                                                                                                                                                                                          | Example                                                                                                                                                                                                                                                                              |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `allow_fallbacks`                                                                                                                                                                                                                                                                    | *OptionalNullable[bool]*                                                                                                                                                                                                                                                             | :heavy_minus_sign:                                                                                                                                                                                                                                                                   | Whether to allow backup providers to serve requests<br/>- true: (default) when the primary provider (or your custom providers in "order") is unavailable, use the next best provider.<br/>- false: use only the primary/custom provider, and return the upstream error if it's unavailable.<br/> |                                                                                                                                                                                                                                                                                      |
| `require_parameters`                                                                                                                                                                                                                                                                 | *OptionalNullable[bool]*                                                                                                                                                                                                                                                             | :heavy_minus_sign:                                                                                                                                                                                                                                                                   | Whether to filter providers to only those that support the parameters you've provided. If this setting is omitted or set to false, then providers will receive only the parameters they support, and ignore the rest.                                                                |                                                                                                                                                                                                                                                                                      |
| `data_collection`                                                                                                                                                                                                                                                                    | [OptionalNullable[components.DataCollection]](../components/datacollection.md)                                                                                                                                                                                                       | :heavy_minus_sign:                                                                                                                                                                                                                                                                   | Data collection setting. If no available model provider meets the requirement, your request will return an error.<br/>- allow: (default) allow providers which store user data non-transiently and may train on it<br/><br/>- deny: use only providers which do not collect user data. | allow                                                                                                                                                                                                                                                                                |
| `zdr`                                                                                                                                                                                                                                                                                | *OptionalNullable[bool]*                                                                                                                                                                                                                                                             | :heavy_minus_sign:                                                                                                                                                                                                                                                                   | Whether to restrict routing to only ZDR (Zero Data Retention) endpoints. When true, only endpoints that do not retain prompts will be used.                                                                                                                                          | true                                                                                                                                                                                                                                                                                 |
| `enforce_distillable_text`                                                                                                                                                                                                                                                           | *OptionalNullable[bool]*                                                                                                                                                                                                                                                             | :heavy_minus_sign:                                                                                                                                                                                                                                                                   | Whether to restrict routing to only models that allow text distillation. When true, only models where the author has allowed distillation will be used.                                                                                                                              | true                                                                                                                                                                                                                                                                                 |
| `order`                                                                                                                                                                                                                                                                              | List[[operations.Order](../operations/order.md)]                                                                                                                                                                                                                                     | :heavy_minus_sign:                                                                                                                                                                                                                                                                   | An ordered list of provider slugs. The router will attempt to use the first provider in the subset of this list that supports your requested model, and fall back to the next if it is unavailable. If no providers are available, the request will fail with an error message.      |                                                                                                                                                                                                                                                                                      |
| `only`                                                                                                                                                                                                                                                                               | List[[operations.Only](../operations/only.md)]                                                                                                                                                                                                                                       | :heavy_minus_sign:                                                                                                                                                                                                                                                                   | List of provider slugs to allow. If provided, this list is merged with your account-wide allowed provider settings for this request.                                                                                                                                                 |                                                                                                                                                                                                                                                                                      |
| `ignore`                                                                                                                                                                                                                                                                             | List[[operations.Ignore](../operations/ignore.md)]                                                                                                                                                                                                                                   | :heavy_minus_sign:                                                                                                                                                                                                                                                                   | List of provider slugs to ignore. If provided, this list is merged with your account-wide ignored provider settings for this request.                                                                                                                                                |                                                                                                                                                                                                                                                                                      |
| `quantizations`                                                                                                                                                                                                                                                                      | List[[components.Quantization](../components/quantization.md)]                                                                                                                                                                                                                       | :heavy_minus_sign:                                                                                                                                                                                                                                                                   | A list of quantization levels to filter the provider by.                                                                                                                                                                                                                             |                                                                                                                                                                                                                                                                                      |
| `sort`                                                                                                                                                                                                                                                                               | [OptionalNullable[components.ProviderSort]](../components/providersort.md)                                                                                                                                                                                                           | :heavy_minus_sign:                                                                                                                                                                                                                                                                   | The sorting strategy to use for this request, if "order" is not specified. When set, no load balancing is performed.                                                                                                                                                                 | price                                                                                                                                                                                                                                                                                |
| `max_price`                                                                                                                                                                                                                                                                          | [Optional[operations.MaxPrice]](../operations/maxprice.md)                                                                                                                                                                                                                           | :heavy_minus_sign:                                                                                                                                                                                                                                                                   | The object specifying the maximum price you want to pay for this request. USD price per million tokens, for prompt and completion.                                                                                                                                                   |                                                                                                                                                                                                                                                                                      |
| `min_throughput`                                                                                                                                                                                                                                                                     | *OptionalNullable[float]*                                                                                                                                                                                                                                                            | :heavy_minus_sign:                                                                                                                                                                                                                                                                   | The minimum throughput (in tokens per second) required for this request. Only providers serving the model with at least this throughput will be used.                                                                                                                                | 100                                                                                                                                                                                                                                                                                  |
| `max_latency`                                                                                                                                                                                                                                                                        | *OptionalNullable[float]*                                                                                                                                                                                                                                                            | :heavy_minus_sign:                                                                                                                                                                                                                                                                   | The maximum latency (in seconds) allowed for this request. Only providers serving the model with better than this latency will be used.                                                                                                                                              | 5                                                                                                                                                                                                                                                                                    |