How do I create a dropdown list in Pine Script using input.string?

To create a dropdown list in TradingView settings, pass an array of string literals to the `options` parameter of `input.string()`. For example: `string ma_type = input.string("EMA", "MA Type", options=["EMA", "SMA", "RMA", "WMA"])`. TradingView automatically renders this as a select dropdown menu in the indicator or strategy settings dialog.

Why does Pine Script throw an error about the default value not being in options?

The `defval` argument must match one of the elements in your `options` list exactly, including case sensitivity. If your options are `["Buy", "Sell"]` but `defval` is set to `"Hold"` or `"buy"`, the Pine Script compiler throws an error stating that the default value must be one of the allowed options. Always verify that `defval` appears in `options`.

Can I use variables or dynamic arrays in the input.string options parameter?

No. The `options` parameter requires a compile-time constant array of string literals (e.g. `["Option 1", "Option 2"]`). You cannot pass dynamic `series string` variables, calculated arrays, or external data into `options`.

How do I handle dropdown selections in my Pine Script logic?

The cleanest way to handle dropdown choices in Pine Script v5 and v6 is with a `switch` statement or `switch` expression. For example: ```pinescript float ma = switch ma_type "SMA" => ta.sma(close, length) "EMA" => ta.ema(close, length) "RMA" => ta.rma(close, length) "WMA" => ta.wma(close, length) => ta.ema(close, length) // Default fallback ``` This maps each user dropdown selection to its corresponding calculation.

Can I group multiple dropdown inputs on the same line in the settings dialog?

Yes. Use the `inline` parameter with a shared identifier string across multiple inputs. You can also organize them under titled collapsible sections using the `group` parameter. For example, setting `inline="ma1"` on both a dropdown input and a length integer input places them side-by-side in TradingView.

Pine Script v6 / v5UI Inputs & SettingsDropdown Menus

Pine Script input.string Options: How to Create Dropdown Menus

In TradingView Pine Script, adding dropdown selection menus to an indicator or strategy is done via input.string() with the options=[...] parameter. By passing a fixed list of allowed string choices, TradingView automatically replaces the free-form text field with a clean select dropdown.

Direct Syntax Pattern

string selected = input.string(defval="EMA", title="MA Type", options=["EMA", "SMA", "RMA", "WMA"])

Generate Pine Script with Custom Inputs View Code Examples

Complete Pine Script v6 Dropdown Example

This indicator demonstrates how to create a Moving Average selector dropdown and use a switch expression to route the chosen calculation.

Pine Script v6 — Moving Average Type Dropdown

//@version=6
indicator("Moving Average Selector [Pineify]", overlay=true)

// 1. Dropdown input using input.string with options
string ma_type = input.string(
     defval="EMA",
     title="Moving Average Type",
     options=["EMA", "SMA", "RMA", "WMA"],
     tooltip="Select calculation method for the moving average"
 )
int ma_len = input.int(20, "Length", minval=1)

// 2. Switch expression to calculate the selected MA
float ma_value = switch ma_type
    "EMA" => ta.ema(close, ma_len)
    "SMA" => ta.sma(close, ma_len)
    "RMA" => ta.rma(close, ma_len)
    "WMA" => ta.wma(close, ma_len)
    => ta.ema(close, ma_len)

// 3. Plot the result
plot(ma_value, title="Selected MA", color=color.blue, linewidth=2)

1. Define Options

Provide a string array of choice names in options=[...].

2. Match Default

Ensure defval matches one option exactly.

3. Switch Logic

Use switch to execute the corresponding calculation.

API Reference

input.string() Parameters Breakdown

Understanding every argument supported by input.string() in Pine Script v6:

Parameter	Type	Required	Description
defval	const string	Yes	Default selected value. Must strictly match one of the string items in the options array.
title	const string	No	Label displayed next to the dropdown menu in the settings dialog.
options	const string[]	Yes (for dropdown)	List of string literals that populate the dropdown menu (e.g. ["EMA", "SMA", "RMA"]).
tooltip	const string	No	Informational text displayed when hovering over the question mark icon in settings.
inline	const string	No	Joins multiple inputs onto the same horizontal line sharing the same inline identifier.
group	const string	No	Organizes inputs under a collapsible titled section inside the script settings dialog.
confirm	const bool	No	When true, prompts the user to verify input values before applying the indicator to the chart.
display	display.*	No	Controls whether input values appear in the status line and data window (e.g. display.all, display.none).

Advanced Layout & Strategy

Multi-Mode Strategy with Grouped Inputs

Combine group and inline parameters with dropdown choices to build polished, customizable strategy interfaces.

Pine Script v6 — Multi-Mode Strategy with Settings Groups

//@version=6
strategy("Mode Switcher Strategy [Pineify]", overlay=true, initial_capital=10000)

// Dropdown input organized with group and inline parameters
string mode = input.string(
     defval="Trend Following",
     title="Strategy Mode",
     options=["Trend Following", "Mean Reversion", "Breakout"],
     group="Execution Settings",
     tooltip="Choose trading model to execute"
 )
int rsi_len = input.int(14, "RSI Length", group="Indicator Settings", inline="rsi")
int rsi_ob  = input.int(70, "Overbought", group="Indicator Settings", inline="rsi")
int rsi_os  = input.int(30, "Oversold", group="Indicator Settings", inline="rsi")

rsi_val = ta.rsi(close, rsi_len)
fast_ema = ta.ema(close, 20)
slow_ema = ta.ema(close, 50)
highest_high = ta.highest(high, 20)[1]

bool long_condition = false
bool close_condition = false

switch mode
    "Trend Following" =>
        long_condition := ta.crossover(fast_ema, slow_ema)
        close_condition := ta.crossunder(fast_ema, slow_ema)
    "Mean Reversion" =>
        long_condition := ta.crossover(rsi_val, rsi_os)
        close_condition := ta.crossunder(rsi_val, rsi_ob)
    "Breakout" =>
        long_condition := close > highest_high
        close_condition := close < ta.lowest(low, 10)[1]

if long_condition and strategy.position_size == 0
    strategy.entry("Long", strategy.long)

if close_condition and strategy.position_size > 0
    strategy.close("Long")

Troubleshooting & Best Practices

Common Pitfalls with input.string Options

Avoid these common compiler errors and interface pitfalls when building dropdowns:

Default Value Mismatch

If defval is not present inside the options array (or has different letter casing), Pine Script halts compilation with an error.

❌ options=["Long", "Short"], defval="Both"
✅ options=["Long", "Short", "Both"], defval="Both"

Dynamic Variables in Options

The options list must be compile-time string constants. You cannot pass calculated variables, arrays, or series strings into it.

❌ options=[syminfo.ticker, "Default"]
✅ options=["AAPL", "TSLA", "NVDA"]

Always Provide a Fallback

When matching dropdown selections in a switch block, always provide a default fallback branch (=> defaultValue) to guard against unexpected states.

Informative Tooltips

Adding the tooltip parameter provides immediate guidance to users directly in the TradingView settings dialog without cluttering title labels.

Frequently Asked Questions

Essential questions about input dropdowns in Pine Script v6.

Build Complete Pine Script Strategies in Seconds

Need to create complex Pine Script indicators with custom dropdown selectors, multi-timeframe filters, and automated webhook alerts? Let Pineify AI Coding Agent generate clean, error-free Pine Script v6 code for TradingView.

Open Pine Script AI Coding Agent