`litellm.UnsupportedParamsError` — LiteLLM refused a parameter your provider does not list

litellm.UnsupportedParamsError: <provider> does not support parameters: ['<param>'], for model=<model>. To drop these, set `litellm.drop_params=True` or for proxy: …

(The start of the error as litellm.completion raises it, assembled by us from the message template and the class’s prefix quoted below, with our placeholders in angle brackets. The class is in litellm/exceptions.py, so from litellm.exceptions import UnsupportedParamsError is an import path; utils.py imports it from there, line 481.)

The “does not support parameters” form is raised inside get_optional_params, which completion() calls to build the call’s optional parameters for the provider, when a parameter you set to a non-default value is not in the provider’s supported list for that model, nor in your allowed_openai_params — unless the parameter is user, stream_options, stream or max_retries, or is n set to 1 — and neither litellm.drop_params nor the drop_params argument is True. Every claim about the library below is read off the Python source of BerriAI/litellm at tag v1.104.2, fetched on 10 October 2026, with the line of each quote given; where we draw a conclusion from those lines rather than quote them, we say so.

What it is: class UnsupportedParamsError(BadRequestError):, LiteLLM’s own BadRequestError, which subclasses openai.BadRequestError. Its message is your text prefixed with litellm.UnsupportedParamsError: , and its status_code is set to 400 whatever the raise passes (the raise sites pass 500).

When it is raised: the message with “does not support parameters:” and the allowed_openai_params hint comes from one site, utils.py line 4519, in get_optional_params. The class is raised at seven other places in utils.py and two in assistants/utils.py; their messages are listed below.

The three ways past it the source shows: litellm.drop_params = True, a drop_params=True argument, or naming the parameter in allowed_openai_params. The first two discard the parameter without raising; the third keeps it and passes the check.

The class

In litellm/exceptions.py, lines 945–951:

class UnsupportedParamsError(BadRequestError): def __init__( self, message, llm_provider: str | None = None, model: str | None = None, status_code: int = 400,

and the first lines of the constructor body, 957–960:

self.status_code = 400 self.message = f"litellm.UnsupportedParamsError: {message}" self.model = model self.llm_provider = llm_provider

So status_code is always 400, whatever is passed as status_code (our reading of line 957). The constructor sets these fields, plus litellm_debug_info, max_retries and num_retries, and ends at line 967 without calling super().__init__; the response it builds is a local variable. The parent, class BadRequestError(openai.BadRequestError): (line 219), defines the string form, lines 253–258:

def __str__(self): _message = self.message if self.num_retries: _message += f" LiteLLM Retried: {self.num_retries} times" if self.max_retries: _message += f", LiteLLM Max Retries: {self.max_retries}"

so str(e) is e.message, plus retry counts only if they were passed (our reading). Because the parent’s constructor is not run, we would not rely on attributes that only openai’s constructor sets, such as e.response or e.body (our inference; we did not read the openai package).

Where it is raised: `get_optional_params`

In litellm/utils.py, get_optional_params (line 4421) defines a nested _check_valid_arg (line 4495). Lines 4506–4522:

for k in non_default_params: if k not in supported_params: if k in PROVIDER_UNVALIDATED_PARAMS: continue if k == "n" and n == 1: # langchain sends n=1 as a default value continue # skip this param unsupported_params[k] = non_default_params[k] if unsupported_params: if litellm.drop_params is True or (drop_params is not None and drop_params is True): for k in unsupported_params: non_default_params.pop(k, None) else: raise UnsupportedParamsError( status_code=500, message=f"{custom_llm_provider} does not support parameters: {list(unsupported_params.keys())}, for model={model}. To drop these, set `litellm.drop_params=True` or for proxy:\n\n`litellm_settings:\n drop_params: true`\n. \n If you want to use these params dynamically send allowed_openai_params={list(unsupported_params.keys())} in your request.", )

The list it checks against, lines 4527–4535:

supported_params = get_supported_openai_params( model=model, custom_llm_provider=custom_llm_provider, base_model=base_model ) if supported_params is None: supported_params = get_supported_openai_params(model=model, custom_llm_provider="openai") supported_params = supported_params or [] allowed_openai_params = allowed_openai_params or [] supported_params.extend(allowed_openai_params)

and line 5094:

PROVIDER_UNVALIDATED_PARAMS: Final = frozenset({"user", "stream_options", "stream", "max_retries"})

Reading these together (our reading):

Checked: non_default_params, the parameters of your call whose value differs from LiteLLM’s default for it; the table is passed as default_param_values=DEFAULT_CHAT_COMPLETION_PARAM_VALUES, (line 4288). Names in additional_drop_params are filtered out before the check, line 4240.
Against: what get_supported_openai_params returns for the model and provider; if it returns None, OpenAI’s list is used; then anything in allowed_openai_params is added.
Skipped: the four names in PROVIDER_UNVALIDATED_PARAMS, and n when it is 1, with the comment # langchain sends n=1 as a default value.
Not raised: when litellm.drop_params is True, or the call’s drop_params is True; the offending keys are popped from non_default_params instead, and nothing else happens in that branch.
Raised with: only status_code=500 and message; no model and no llm_provider are passed, so at this site both attributes are None and the provider and model appear only inside the message text.

The drop_params argument is normalised first, line 4467: drop_params = normalize_drop_params(drop_params) # rebind-ok: config and DB deployments pass "true" as a string; the global litellm.drop_params is compared with is True as it is, so a string there would not count (our reading; we did not read where litellm.drop_params is defined).

Where `completion()` passes the arguments

In litellm/main.py, completion calls it at line 5606: optional_params = get_optional_params(**optional_param_args, **non_default_params). allowed_openai_params comes from the call’s keyword arguments, lines 5554–5558:

allowed_openai_params: Final[list[str] | None] = ( [*(kwargs.get("allowed_openai_params") or []), "reasoning_effort"] if bridges_to_responses_api else kwargs.get("allowed_openai_params") )

and is placed in optional_param_args at line 5603. That dict, lines 5559–5605, has no drop_params key; we did not trace whether a per-call drop_params reaches get_optional_params through **non_default_params, which depends on a list of LiteLLM’s own parameter names defined in files we did not fetch. So the per-call drop_params below is the parameter of get_optional_params (line 4453); that completion(…, drop_params=True) sets it is our inference, not something we traced.

The other raise sites

We searched both fetched files for UnsupportedParamsError(. In utils.py it is raised at lines 3528, 3661, 3757, 3814, 4037, 4052, 4413 and 4519; in litellm/assistants/utils.py at lines 49 and 110. main.py does not name it. We did not fetch LiteLLM’s other files, so this list covers these files only. Each message, from the raise’s message= line, two lines below it:

get_optional_params_transcription, line 3528: Setting user/encoding format is not supported by {custom_llm_provider}. To drop it from the call, set `litellm.drop_params = True`.
get_optional_params_image_gen, line 3661: Setting `{k}` is not supported by {custom_llm_provider}, {model}. To drop it from the call, set `litellm.drop_params = True`.
get_optional_params_embeddings, line 3757: {custom_llm_provider} does not support parameters: {unsupported_params}, for model={model}. … — the same opening as the chat message, but it prints the dict of values, not a list of names, and has no allowed_openai_params sentence.
get_optional_params_embeddings, line 3814 (OpenAI, a model name without text-embedding-3, dimensions set and not in allowed_openai_params): Setting dimensions is not supported for OpenAI `text-embedding-3` and later models.
get_optional_params_embeddings, lines 4037 and 4052: Setting {non_default_params} is not supported by {custom_llm_provider}.
pre_process_optional_params, line 4413, which get_optional_params calls at line 4489: Function calling is not supported by {custom_llm_provider}.
assistants/utils.py get_optional_params_add_message, line 49: k={k}, not supported by {custom_llm_provider}. Supported params={supported_params}.
assistants/utils.py get_optional_params_image_gen, line 110: Setting user/encoding format is not supported by {custom_llm_provider}.

All except line 4413 skip the raise when drop_params applies, and the two in assistants/utils.py test only litellm.drop_params. The function-calling site is reached when if "functions" in non_default_params or "function_call" in non_default_params or "tools" in non_default_params: (line 4371) and the provider is not in the list that follows; its branch never reads drop_params, and the alternative it offers is elif litellm.add_function_to_prompt: # if user opts to add it to prompt instead (line 4408) (our reading of lines 4371–4416).

What it looks like in the field

In n8n-io/n8n#40671, Agent with AWS Bedrock - lite llm via the open ai creds (open when we fetched it), the reporter, on n8nVersion: 2.43.2, gets litellm.UnsupportedParamsError: bedrock does not support parameters: ['prompt_cache_key'], for model=eu.anthropic.claude-sonnet-5. … followed by Received Model Group=claude-sonnet-5 Available Model Group Fallbacks=None, and says This was prior to 2.43.X possible. The trailing model-group text is not in the utils.py template, so it was added after the raise (our inference: by the LiteLLM proxy their request went through). prompt_cache_key is one of get_optional_params’s own parameters (line 4463).

In brianlan/LearnLoop#689, Upgrade litellm to restore reasoning_effort passthrough for OpenAI-compatible aliases; separate local param-validation errors from remote 400s; harden VLM health probe (closed as completed), the reporter quotes openai does not support parameters: ['reasoning_effort'], on litellm 1.91.2, and writes that UnsupportedParamsError is raised and **zero HTTP requests** are sent, and that their app showed it as an HTTP 400 — “a local validation failure disguised as a remote rejection”. They report the reasoning_effort case gone in 1.101.0 and 1.104.2 (their tests; we did not run them).

What the caller sees and can read

e.message and str(e) — the text, starting litellm.UnsupportedParamsError: ; at line 4519 it names the provider, the parameters and the model.
e.status_code — 400, set by the constructor, though the raise passes 500.
e.model, e.llm_provider — set from the constructor arguments; none of the ten raise sites listed above passes them, so they are None (our reading).
Catching it — except UnsupportedParamsError, imported from litellm.exceptions; it is also a LiteLLM BadRequestError and an openai.BadRequestError, so a handler for those catches it too (our reading of lines 219 and 945).

What to do

Read the list in the message. At line 4519, the names in brackets are the non-default parameters the provider’s list lacks; removing them from the call, or leaving them at their default, avoids the raise (our reading).
litellm.drop_params = True — process-wide; every listed parameter is popped without an error, and the other sites that test it do not raise either; line 4413 does not test it. The trade-off: the provider never sees those parameters, and nothing in the lines quoted warns you (our reading).
drop_params=True on one call — the same silent drop, scoped to the call (our reading of lines 4515–4517; how completion() forwards it we did not trace, see above).
allowed_openai_params=["<param>"] — the parameter is added to the supported list, so it passes the check and stays in the call; whether the provider then accepts it is up to the provider (our inference).
On the proxy, the message itself suggests litellm_settings: with drop_params: true; we did not read the proxy’s code.
“Function calling is not supported by” is line 4413, which drop_params does not affect; the source’s alternative is litellm.add_function_to_prompt (our reading).

import litellm from litellm.exceptions import UnsupportedParamsError def ask(model: str, question: str) -> str | None: # Our sketch: decide per parameter instead of dropping everything. messages = [{"role": "user", "content": question}] try: response = litellm.completion(model=model, messages=messages, seed=7) except UnsupportedParamsError as e: print(e.status_code) print(e.message) return None return response.choices[0].message.content

(Our sketch, not library code, and not run against your version. To keep seed for a provider you know accepts it, add allowed_openai_params=["seed"] to the call, read from kwargs as quoted above; to discard it instead, remove it. That the error reaches completion’s caller unchanged is our inference, not something we ran.)

What is behind this site

There is a written guide: the step-and-turn arithmetic as a formula you can run against a brief before you launch it, why raising a cap does not finish the job, and batch.py, one standard-library file that collapses a per-item loop into a single pass — fewer turns, which means fewer final calls made from an unfinished transcript when a run hits its cap. It is $19, on a storefront that delivers the files automatically and carries a 30-day money-back guarantee (checked 7 October 2026). One working way to pay today is 19 USDC on Base, and delivery is manual: you email the transaction hash and the files come back as a reply. This page is free, ungated, and sells nothing on its own.

The short version: litellm.UnsupportedParamsError with “does not support parameters:” means LiteLLM’s get_optional_params found a parameter you set to a non-default value that the provider’s supported list for the model lacks and that you did not name in allowed_openai_params; user, stream_options, stream, max_retries and n=1 are never flagged there. With litellm.drop_params or drop_params set to True the parameter is dropped silently instead. e.status_code is 400; the provider and model are in e.message, not in e.llm_provider or e.model.

Nearby

ModelHTTPError — Pydantic AI’s error, a different library; the error on this page is raised by LiteLLM’s own parameter check, with a status_code of 400 set by LiteLLM itself (our reading).

This page counts anonymous readership with one counter, the file at /measure.js, and each of the events below is sent at most once per load. Once the page is ready it sends one view event. With it go the page path, the domain of the page you came from — only the domain, and nothing at all if you came from this site — how long the page has been open, counting only the time it was actually in front of you and not the time it sat in a background tab, whether you have scrolled, and any campaign or outreach code in the link you followed. A second event, which we call a human candidate, is sent only once the page has also received a real input event from you — a mouse movement, a touch, a scroll or a key press — and has been visible in the foreground for ten seconds in all; a program that fetches the page, or opens it and sits there, cannot produce one. A third, “engaged”, is stricter still: it is sent only after the human-candidate event, once the page has been in front of you for ninety seconds in all and you have scrolled far enough to reach a marker we put where the explaining part of this page ends; a reader who stops short of that marker never produces one. The second and third events carry the same fields as the first. If you switch away from the tab or close it, an event that has just become due may be sent as you leave. If this page has a button or a copy control that says it records a click, pressing it sends the name of that event and nothing else. Following a link to buy the guide sends one further event, also at most once per load, carrying that event’s name and a single word for which of the two checkouts you were sent to — the Gumroad listing or the payment page on this site — and nothing else: not the address you followed, not which page you were reading, not how long you had been there. Everything is sent to this site only, with no cookie attached. No cookie is read or written, nothing is put in your browser’s local or session storage, and no identifier is made from your device. Earlier versions of this page kept the campaign codes of your first visit in local storage under the name llab_attr; this page neither reads nor deletes that entry, so if it is there it stays until you clear this site’s data. An outreach code is minted per recipient, which would let us tell one reader from another; it is sent with each event and, unlike on earlier versions of this page, it is no longer removed from the address bar after it is read — if you copy the address, the code goes with it. Earlier versions also asked this domain for Vercel’s analytics script at /_vercel/insights/script.js, which on 26 September 2026 returned HTTP 404 on every host we publish; this page no longer asks for it. Your browser and the network attach things the page does not send: the identification string your browser gives, your IP address and the time of the request. The host that serves this page keeps its own request logs; those are its record and not ours.

litellm.UnsupportedParamsError — LiteLLM refused a parameter your provider does not list