diff --git a/src/bundle/Resources/public/ts/components/dropdown/dropdown_multi_input.ts b/src/bundle/Resources/public/ts/components/dropdown/dropdown_multi_input.ts
new file mode 100644
index 00000000..c3e9ed51
--- /dev/null
+++ b/src/bundle/Resources/public/ts/components/dropdown/dropdown_multi_input.ts
@@ -0,0 +1,143 @@
+import { BaseDropdown, BaseDropdownItem } from '../../partials';
+import { createNodesFromTemplate } from '../../utils/dom';
+
+export enum DropdownMultiInputAction {
+    Check = 'check',
+    Uncheck = 'uncheck',
+}
+
+export class DropdownMultiInput extends BaseDropdown {
+    private _sourceInputNode: HTMLSelectElement;
+    private _value: string[];
+
+    constructor(container: HTMLDivElement) {
+        super(container);
+
+        const _sourceInputNode = this._sourceNode.querySelector<HTMLSelectElement>('select');
+
+        if (!_sourceInputNode) {
+            throw new Error('DropdownMultiInput: Required elements are missing in the container.');
+        }
+
+        this._sourceInputNode = _sourceInputNode;
+        this._value = this.getSelectedValuesFromSource();
+
+        this.onItemClick = this.onItemClick.bind(this);
+    }
+
+    protected getSelectedValuesFromSource(): string[] {
+        const selectedValues = Array.from(this._sourceInputNode.selectedOptions).map((option) => option.value);
+
+        return selectedValues;
+    }
+
+    protected isSelected(id: string): boolean {
+        return this._value.includes(id);
+    }
+
+    protected setSource() {
+        this._sourceInputNode.innerHTML = '';
+
+        this._itemsMap.forEach((item) => {
+            const option = document.createElement('option');
+
+            option.value = item.id;
+            option.textContent = item.label;
+
+            if (this._value.includes(item.id)) {
+                option.selected = true;
+            }
+
+            this._sourceInputNode.appendChild(option);
+        });
+
+        this.setValues(this.getSelectedValuesFromSource());
+    }
+
+    protected setSourceValue(id: string, actionPerformed: DropdownMultiInputAction) {
+        const optionNode = this._sourceInputNode.querySelector<HTMLOptionElement>(`option[value="${id}"]`);
+
+        if (!optionNode) {
+            return;
+        }
+
+        optionNode.selected = actionPerformed === DropdownMultiInputAction.Check;
+    }
+
+    protected setSelectedItem(id: string, actionPerformed: DropdownMultiInputAction) {
+        const listItemNode = this._itemsContainerNode.querySelector<HTMLLIElement>(`.ids-dropdown__item[data-id="${id}"]`);
+        const checkboxNode = listItemNode?.querySelector<HTMLInputElement>('.ids-input--checkbox');
+
+        if (!checkboxNode) {
+            return;
+        }
+
+        checkboxNode.checked = actionPerformed === DropdownMultiInputAction.Check;
+    }
+
+    protected setSelectionInfo(values: string[]) {
+        const items = values.map((value) => this.getItemById(value)).filter((item): item is BaseDropdownItem => item !== undefined);
+
+        if (items.length) {
+            // TODO: implement OverflowList when merged
+            this._selectionInfoItemsNode.textContent = items.map(({ label }) => label).join(', ');
+            this._selectionInfoItemsNode.removeAttribute('hidden');
+            this._placeholderNode.setAttribute('hidden', '');
+        } else {
+            this._selectionInfoItemsNode.textContent = '';
+            this._selectionInfoItemsNode.setAttribute('hidden', '');
+            this._placeholderNode.removeAttribute('hidden');
+        }
+    }
+
+    public getItemContent(item: BaseDropdownItem, listItem: HTMLLIElement): NodeListOf<ChildNode> | string {
+        const placeholders = {
+            '{{ id }}': item.id,
+            '{{ label }}': item.label,
+        };
+
+        const itemContent = createNodesFromTemplate(listItem.innerHTML, placeholders);
+
+        return itemContent instanceof NodeList ? itemContent : item.label;
+    }
+
+    public setItems(items: BaseDropdownItem[]) {
+        super.setItems(items);
+
+        const tempValue = this._value;
+
+        this._value = [];
+
+        this.setValues(tempValue);
+    }
+
+    public setValues(values: string[]) {
+        values.forEach((value) => {
+            this.setValue(value);
+        });
+    }
+
+    public setValue(value: string) {
+        const isSelected = this.isSelected(value);
+        const nextValue = isSelected ? this._value.filter((iteratedValue) => iteratedValue !== value) : [...this._value, value];
+        const actionPerformed = isSelected ? DropdownMultiInputAction.Uncheck : DropdownMultiInputAction.Check;
+
+        this.setSourceValue(value, actionPerformed);
+        this.setSelectedItem(value, actionPerformed);
+        this.setSelectionInfo(nextValue);
+
+        this._value = nextValue;
+    }
+
+    public onItemClick = (event: MouseEvent) => {
+        if (event.currentTarget instanceof HTMLLIElement) {
+            const { id } = event.currentTarget.dataset;
+
+            if (!id) {
+                return;
+            }
+
+            this.setValue(id);
+        }
+    };
+}
diff --git a/src/bundle/Resources/public/ts/components/dropdown/index.ts b/src/bundle/Resources/public/ts/components/dropdown/index.ts
index c94f8831..24f61dde 100644
--- a/src/bundle/Resources/public/ts/components/dropdown/index.ts
+++ b/src/bundle/Resources/public/ts/components/dropdown/index.ts
@@ -1 +1,2 @@
+export * from './dropdown_multi_input';
 export * from './dropdown_single_input';
diff --git a/src/bundle/Resources/public/ts/init_components.ts b/src/bundle/Resources/public/ts/init_components.ts
index 1371fb55..778544eb 100644
--- a/src/bundle/Resources/public/ts/init_components.ts
+++ b/src/bundle/Resources/public/ts/init_components.ts
@@ -1,8 +1,8 @@
 import { CheckboxInput, CheckboxesListField } from './components/checkbox';
+import { DropdownMultiInput, DropdownSingleInput } from './components/dropdown';
 import { InputTextField, InputTextInput } from './components/input_text';
 import { Accordion } from './components/accordion';
 import { AltRadioInput } from './components/alt_radio/alt_radio_input';
-import { DropdownSingleInput } from './components/dropdown/dropdown_single_input';
 import { OverflowList } from './components/overflow_list';
 
 const accordionContainers = document.querySelectorAll<HTMLDivElement>('.ids-accordion:not([data-ids-custom-init])');
@@ -37,9 +37,17 @@ checkboxesFieldContainers.forEach((checkboxesFieldContainer: HTMLDivElement) =>
     checkboxesFieldInstance.init();
 });
 
-const dropdownContainers = document.querySelectorAll<HTMLDivElement>('.ids-dropdown:not([data-ids-custom-init])');
+const dropdownMultiContainers = document.querySelectorAll<HTMLDivElement>('.ids-dropdown--multi:not([data-ids-custom-init])');
 
-dropdownContainers.forEach((dropdownContainer: HTMLDivElement) => {
+dropdownMultiContainers.forEach((dropdownContainer: HTMLDivElement) => {
+    const dropdownInstance = new DropdownMultiInput(dropdownContainer);
+
+    dropdownInstance.init();
+});
+
+const dropdownSingleContainers = document.querySelectorAll<HTMLDivElement>('.ids-dropdown--single:not([data-ids-custom-init])');
+
+dropdownSingleContainers.forEach((dropdownContainer: HTMLDivElement) => {
     const dropdownInstance = new DropdownSingleInput(dropdownContainer);
 
     dropdownInstance.init();
diff --git a/src/bundle/Resources/public/ts/partials/base_dropdown/base_dropdown.ts b/src/bundle/Resources/public/ts/partials/base_dropdown/base_dropdown.ts
index 1d9ee6fc..4e263db0 100644
--- a/src/bundle/Resources/public/ts/partials/base_dropdown/base_dropdown.ts
+++ b/src/bundle/Resources/public/ts/partials/base_dropdown/base_dropdown.ts
@@ -112,7 +112,17 @@ export abstract class BaseDropdown extends Base {
 
             listItem.dataset.id = item.id;
             listItem.dataset.label = item.label;
-            listItem.textContent = this.getItemContent(item);
+
+            const itemContent = this.getItemContent(item, listItem);
+
+            if (itemContent instanceof NodeList) {
+                listItem.innerHTML = '';
+                Array.from(itemContent).forEach((childNode) => {
+                    listItem.appendChild(childNode);
+                });
+            } else {
+                listItem.textContent = itemContent;
+            }
 
             this._itemsNode.appendChild(listItem);
         });
@@ -132,15 +142,12 @@ export abstract class BaseDropdown extends Base {
         }
     }
 
-    protected abstract setSourceValue(id: string): void;
-
-    protected abstract setSelectedItem(id: string): void;
-
     protected abstract setSource(): void;
 
     /******* Items management ********/
 
-    public getItemContent(item: BaseDropdownItem) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    public getItemContent(item: BaseDropdownItem, _listItem: HTMLLIElement): NodeListOf<ChildNode> | string {
         return item.label;
     }
 
diff --git a/src/bundle/Resources/public/ts/utils/dom.ts b/src/bundle/Resources/public/ts/utils/dom.ts
new file mode 100644
index 00000000..82161d72
--- /dev/null
+++ b/src/bundle/Resources/public/ts/utils/dom.ts
@@ -0,0 +1,16 @@
+export const createNodesFromTemplate = (template: string, placeholders: Record<string, string>): NodeListOf<ChildNode> | null => {
+    const container = document.createElement('div');
+    let result = template;
+
+    Object.entries(placeholders).forEach(([placeholder, value]) => {
+        result = result.replaceAll(placeholder, value);
+    });
+
+    container.innerHTML = result;
+
+    if (container instanceof HTMLElement && container.childNodes.length > 0) {
+        return container.childNodes;
+    }
+
+    return null;
+};
diff --git a/src/bundle/Resources/views/themes/standard/design_system/components/dropdown_multi/input.html.twig b/src/bundle/Resources/views/themes/standard/design_system/components/dropdown_multi/input.html.twig
new file mode 100644
index 00000000..748f0c23
--- /dev/null
+++ b/src/bundle/Resources/views/themes/standard/design_system/components/dropdown_multi/input.html.twig
@@ -0,0 +1,25 @@
+{% extends '@IbexaDesignSystemTwig/themes/standard/design_system/partials/base_dropdown.html.twig' %}
+
+{% set class = html_classes('ids-dropdown--multi', attributes.render('class') ?? '') %}
+
+{% block source %}
+    <select multiple name="{{ name }}"{% if disabled %} disabled{% endif %}>
+        {% for item in items %}
+            <option value="{{ item.id }}"{% if item.id in value %} selected{% endif %}>{{ item.label }}</option>
+        {% endfor %}
+    </select>
+{% endblock source %}
+
+{% block item_content %}
+    <twig:ibexa:checkbox:input
+        name="{{ name }}-checkbox"
+        :checked="item.id in value"
+        :value="item.id"
+        data-ids-custom-init="true"
+    />
+    {{ item.label }}
+{% endblock item_content %}
+
+{% block selected_items %}
+    {{ selected_items|map(item => item.label)|join(', ') }}
+{% endblock selected_items %}
diff --git a/src/bundle/Resources/views/themes/standard/design_system/partials/base_dropdown.html.twig b/src/bundle/Resources/views/themes/standard/design_system/partials/base_dropdown.html.twig
index f7866625..0c1de990 100644
--- a/src/bundle/Resources/views/themes/standard/design_system/partials/base_dropdown.html.twig
+++ b/src/bundle/Resources/views/themes/standard/design_system/partials/base_dropdown.html.twig
@@ -68,7 +68,9 @@
     </div>
     {% block templates %}
         {% set item_content %}
-            {{ block('item_content') is defined ? block('item_content') : '' }}
+            {% with { item: item_template_props } %}
+                {{ block('item_content') is defined ? block('item_content') : '' }}
+            {% endwith %}
         {% endset %}
 
         <template class="ids-dropdown__template" data-id="item">
diff --git a/src/lib/Twig/Components/AbstractDropdown.php b/src/lib/Twig/Components/AbstractDropdown.php
index 407ccd1e..22c4b7a9 100644
--- a/src/lib/Twig/Components/AbstractDropdown.php
+++ b/src/lib/Twig/Components/AbstractDropdown.php
@@ -35,6 +35,9 @@ abstract class AbstractDropdown
     /** @var array<TDropdownItem> */
     public array $items = [];
 
+    /** @var array<string> */
+    public array $itemTemplateProps = ['id', 'label'];
+
     public string $placeholder;
 
     #[ExposeInTemplate('max_visible_items')]
@@ -94,6 +97,20 @@ public function getIsSearchVisible(): bool
         return count($this->items) > $this->maxVisibleItems;
     }
 
+    /**
+     * @return array<string, string>
+     */
+    #[ExposeInTemplate('item_template_props')]
+    public function getItemTemplateProps(): array
+    {
+        $itemPropsPatterns = array_map(
+            static fn (string $name): string => '{{ ' . $name . ' }}',
+            $this->itemTemplateProps
+        );
+
+        return array_combine($this->itemTemplateProps, $itemPropsPatterns);
+    }
+
     abstract protected function configurePropsResolver(OptionsResolver $resolver): void;
 
     /**
diff --git a/src/lib/Twig/Components/DropdownMulti/Input.php b/src/lib/Twig/Components/DropdownMulti/Input.php
new file mode 100644
index 00000000..214ee19c
--- /dev/null
+++ b/src/lib/Twig/Components/DropdownMulti/Input.php
@@ -0,0 +1,53 @@
+<?php
+
+/**
+ * @copyright Copyright (C) Ibexa AS. All rights reserved.
+ * @license For full copyright and license information view LICENSE file distributed with this source code.
+ */
+declare(strict_types=1);
+
+namespace Ibexa\DesignSystemTwig\Twig\Components\DropdownMulti;
+
+use Ibexa\DesignSystemTwig\Twig\Components\AbstractDropdown;
+use Symfony\Component\OptionsResolver\OptionsResolver;
+use Symfony\UX\TwigComponent\Attribute\AsTwigComponent;
+use Symfony\UX\TwigComponent\Attribute\ExposeInTemplate;
+
+#[AsTwigComponent('ibexa:dropdown_multi:input')]
+final class Input extends AbstractDropdown
+{
+    /** @var array<string> */
+    public array $value = [];
+
+    /**
+     * @return array<int, array{id: string, label: string}|null>
+     */
+    #[ExposeInTemplate('selected_items')]
+    public function getSelectedItems(): array
+    {
+        $items = $this->items;
+
+        return array_map(
+            static function (string $id) use ($items): ?array {
+                return array_find($items, static function (array $item) use ($id): bool {
+                    return $item['id'] === $id;
+                });
+            },
+            $this->value
+        );
+    }
+
+    #[ExposeInTemplate('is_empty')]
+    public function isEmpty(): bool
+    {
+        return count($this->value) === 0;
+    }
+
+    protected function configurePropsResolver(OptionsResolver $resolver): void
+    {
+        $resolver
+            ->define('value')
+            ->allowedTypes('array')
+            ->default([]);
+    }
+}
diff --git a/tests/integration/Twig/Components/DropdownMulti/InputTest.php b/tests/integration/Twig/Components/DropdownMulti/InputTest.php
new file mode 100644
index 00000000..917bf87f
--- /dev/null
+++ b/tests/integration/Twig/Components/DropdownMulti/InputTest.php
@@ -0,0 +1,251 @@
+<?php
+
+/**
+ * @copyright Copyright (C) Ibexa AS. All rights reserved.
+ * @license For full copyright and license information view LICENSE file distributed with this source code.
+ */
+declare(strict_types=1);
+
+namespace Ibexa\Tests\Integration\DesignSystemTwig\Twig\Components\DropdownMulti;
+
+use Ibexa\DesignSystemTwig\Twig\Components\DropdownMulti\Input;
+use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;
+use Symfony\Component\DomCrawler\Crawler;
+use Symfony\Component\OptionsResolver\Exception\InvalidOptionsException;
+use Symfony\UX\TwigComponent\Test\InteractsWithTwigComponents;
+
+final class InputTest extends KernelTestCase
+{
+    use InteractsWithTwigComponents;
+
+    public function testMount(): void
+    {
+        $component = $this->mountTwigComponent(
+            Input::class,
+            $this->baseProps(['value' => ['opt-a']])
+        );
+
+        self::assertInstanceOf(
+            Input::class,
+            $component,
+            'Component should mount as DropdownMulti\\Input.'
+        );
+        self::assertSame(
+            ['opt-a'],
+            $component->value,
+            '"value" prop should be set on the component.'
+        );
+
+        $selectedItems = $component->getSelectedItems();
+        self::assertCount(
+            1,
+            $selectedItems,
+            'getSelectedItems() should return one entry for selected ID.'
+        );
+        self::assertNotNull(
+            $selectedItems[0],
+            'Selected items array should contain the original item data.'
+        );
+        self::assertSame(
+            'opt-a',
+            $selectedItems[0]['id'],
+            'Selected item should retain original ID.'
+        );
+        self::assertSame(
+            'Pick A',
+            $selectedItems[0]['label'],
+            'Selected item should expose its label.'
+        );
+        self::assertFalse(
+            $component->isEmpty(),
+            'Component should not be empty when value contains ids.'
+        );
+    }
+
+    public function testRenderProducesMultiSelectAndCheckboxItems(): void
+    {
+        $crawler = $this->renderTwigComponent(Input::class, $this->baseProps([
+            'value' => ['opt-b'],
+        ]))->crawler();
+
+        $wrapper = $this->getDropdownWrapper($crawler);
+        $wrapperClass = $this->getClassAttr($wrapper);
+
+        self::assertStringContainsString(
+            'ids-dropdown--multi',
+            $wrapperClass,
+            'Wrapper should include multi modifier class.'
+        );
+
+        $select = $this->getSelectElement($wrapper);
+        self::assertSame(
+            'group',
+            $select->attr('name'),
+            'Select name should match provided name.'
+        );
+        self::assertSame(
+            'multiple',
+            $select->attr('multiple'),
+            'Select should render with "multiple" attribute.'
+        );
+
+        $options = $select->filter('option');
+        self::assertSame(
+            2,
+            $options->count(),
+            'Select should render one option per item.'
+        );
+        self::assertSame(
+            'opt-a',
+            $options->eq(0)->attr('value'),
+            'First option should expose the first item id.'
+        );
+        self::assertNull(
+            $options->eq(0)->attr('selected'),
+            'First option should not be selected.'
+        );
+        self::assertSame(
+            'opt-b',
+            $options->eq(1)->attr('value'),
+            'Second option should expose the second item id.'
+        );
+        self::assertNotNull(
+            $options->eq(1)->attr('selected'),
+            'Second option should be marked as selected.'
+        );
+
+        $checkboxes = $wrapper->filter('.ids-dropdown__items input[type="checkbox"]');
+        self::assertSame(
+            2,
+            $checkboxes->count(),
+            'Dropdown list should include a checkbox per item.'
+        );
+        self::assertSame(
+            'group-checkbox',
+            $checkboxes->eq(0)->attr('name'),
+            'Checkbox name should derive from component name.'
+        );
+        self::assertNotNull(
+            $checkboxes->eq(1)->attr('checked'),
+            'Checkbox representing the selected option should be checked.'
+        );
+        self::assertSame(
+            'true',
+            $checkboxes->eq(0)->attr('data-ids-custom-init'),
+            'Checkbox should opt-in for custom JS init.'
+        );
+    }
+
+    public function testSelectionInfoDisplaysSelectedLabels(): void
+    {
+        $crawler = $this->renderTwigComponent(Input::class, $this->baseProps([
+            'value' => ['opt-a', 'opt-b'],
+        ]))->crawler();
+
+        $selectionInfo = $crawler
+            ->filter('.ids-dropdown__selection-info-items')
+            ->first();
+        self::assertGreaterThan(
+            0,
+            $selectionInfo->count(),
+            'Selection info container should render.'
+        );
+        $selectionText = preg_replace('/\s+/', ' ', $selectionInfo->text(''));
+        self::assertIsString($selectionText, 'Selection text normalisation should yield a string.');
+        $selectionText = trim($selectionText);
+        self::assertSame(
+            'Pick A, Pick B',
+            $selectionText,
+            'Selection info should list chosen labels.'
+        );
+        self::assertNull(
+            $selectionInfo->attr('hidden'),
+            'Selection info should be visible when there are selections.'
+        );
+
+        $placeholder = $crawler->filter('.ids-dropdown__placeholder')->first();
+        self::assertGreaterThan(
+            0,
+            $placeholder->count(),
+            'Placeholder container should render.'
+        );
+        self::assertNotNull(
+            $placeholder->attr('hidden'),
+            'Placeholder should be hidden when selections are present.'
+        );
+    }
+
+    public function testEmptyValueShowsPlaceholder(): void
+    {
+        $crawler = $this->renderTwigComponent(Input::class, $this->baseProps([
+            'value' => [],
+        ]))->crawler();
+
+        $placeholder = $crawler->filter('.ids-dropdown__placeholder')->first();
+        self::assertGreaterThan(
+            0,
+            $placeholder->count(),
+            'Placeholder container should render.'
+        );
+        self::assertNull(
+            $placeholder->attr('hidden'),
+            'Placeholder should be visible when there are no selections.'
+        );
+
+        $selectionInfo = $crawler
+            ->filter('.ids-dropdown__selection-info-items')
+            ->first();
+        self::assertNotNull(
+            $selectionInfo->attr('hidden'),
+            'Selection info should be hidden when there are no selections.'
+        );
+    }
+
+    public function testInvalidValueTypeCausesResolverErrorOnMount(): void
+    {
+        $this->expectException(InvalidOptionsException::class);
+
+        $this->mountTwigComponent(
+            Input::class,
+            $this->baseProps(['value' => 'opt-a'])
+        );
+    }
+
+    /**
+     * @param array<string, mixed> $overrides
+     *
+     * @return array<string, mixed>
+     */
+    private function baseProps(array $overrides = []): array
+    {
+        return array_replace([
+            'name' => 'group',
+            'items' => [
+                ['id' => 'opt-a', 'label' => 'Pick A'],
+                ['id' => 'opt-b', 'label' => 'Pick B'],
+            ],
+            'value' => [],
+        ], $overrides);
+    }
+
+    private function getDropdownWrapper(Crawler $crawler): Crawler
+    {
+        $node = $crawler->filter('.ids-dropdown')->first();
+        self::assertGreaterThan(0, $node->count(), 'Dropdown wrapper should be present.');
+
+        return $node;
+    }
+
+    private function getSelectElement(Crawler $scope): Crawler
+    {
+        $node = $scope->filter('.ids-dropdown__source select')->first();
+        self::assertGreaterThan(0, $node->count(), 'Native select element should be present.');
+
+        return $node;
+    }
+
+    private function getClassAttr(Crawler $node): string
+    {
+        return (string) $node->attr('class');
+    }
+}