---
id: plugins-index
title: "All plugins"
summary: "All 106 plugins Viaducta ships, in 18 categories."
audience: user
keywords: "plugins, catalogue, categories, plugin list"
---
# All plugins

Viaducta ships 106 plugins in 18 categories. Open a category for how its plugins work together, or a plugin for its pins, its configuration and an example. The designer shows the same descriptions.

For what applies to every plugin, read [Pins and routing](/documentation/plugins/guides/pins-and-routing), [Start and keep running](/documentation/plugins/guides/start-and-stop) and [Flow to flow](/documentation/plugins/guides/flow-to-flow).
## AWS

4 plugins: [category page](/documentation/plugins/aws/).

| Plugin | What it does | Pins |
|---|---|---|
| [S3 enumerator](/documentation/plugins/aws/s3-enumerator) | Lists the objects of an Amazon S3 bucket (or of an S3-compatible store such as MinIO), optionally filtered by key prefix, folder level, name pattern, age and an object tag, and emits one file info record per object. Use it with *S3 reader* to process the files of a bucket. | `Input`, `Output`, `Continue` |
| [S3 operation](/documentation/plugins/aws/s3-operation) | Deletes, copies, moves, tags or changes the storage class of an object in Amazon S3 (or an S3-compatible store such as MinIO). The object comes from an incoming object file info (*S3 enumerator*) or from the configuration; the file info of the resulting object is passed on. Use it for housekeeping (archive or delete old objects) or to move objects between buckets. | `Input`, `Output`, `NoData` |
| [S3 reader](/documentation/plugins/aws/s3-reader) | Reads an object from Amazon S3 (or an S3-compatible store such as MinIO) and emits it as a file stream, for example for a CSV or ASN.1 decoder. Every object is a batch: once it is processed and committed downstream, the object can be deleted, moved or tagged; a failed object can be moved to an error location. The object comes from an incoming object file info (*S3 enumerator*) or from the configuration. If the object does not exist, the input is passed to `NoData`. | `Input`, `Output`, `NoData` |
| [S3 writer](/documentation/plugins/aws/s3-writer) | Uploads text or a file stream as an object to Amazon S3 (or an S3-compatible store such as MinIO) and passes the input on. Sets content type, metadata and storage class, can refuse to overwrite and can create the bucket. Large streams are uploaded in parts. | `Input`, `Output` |

## Azure

4 plugins: [category page](/documentation/plugins/azure/).

| Plugin | What it does | Pins |
|---|---|---|
| [Blob enumerator](/documentation/plugins/azure/azure-blob-enumerator) | Lists the blobs of an Azure Storage container, optionally filtered by a name prefix and skipping blobs with a given index tag, and emits one file info record per blob. Use it with *Blob reader* to process the files of a container. | `Input`, `Output`, `Continue` |
| [Blob operation](/documentation/plugins/azure/azure-blob-operation) | Deletes, copies, moves, tags or changes the access tier of a blob in Azure Storage. The blob comes from an incoming blob file info (*Blob enumerator*) or from the configuration; the file info of the resulting blob is passed on. Use it for housekeeping (archive or delete old blobs) or to move blobs between containers. | `Input`, `Output`, `NoData` |
| [Blob reader](/documentation/plugins/azure/azure-blob-reader) | Opens a blob in Azure Storage for reading and emits it as a file stream, for example for a CSV or ASN.1 decoder. Every blob is a batch: once it is processed and committed downstream, the blob can be deleted, moved or tagged; a failed blob can be moved to an error location. The blob comes from an incoming blob file info (*Blob enumerator*) or from the configuration. If the blob does not exist, the input is passed to `NoData`. | `Input`, `Output`, `NoData` |
| [Blob writer](/documentation/plugins/azure/azure-blob-writer) | Uploads text or a file stream to a blob in Azure Storage, or appends records to an append blob, and passes the input on. Sets content type, metadata and access tier, and can create the container. | `Input`, `Output` |

## Cache

3 plugins: [category page](/documentation/plugins/cache/).

| Plugin | What it does | Pins |
|---|---|---|
| [Redis delete](/documentation/plugins/cache/redis-delete) | Deletes one key from a Redis cache and emits what was stored under it. Use it to invalidate cache entries or to take a value out of the cache once. | `Input`, `Deleted`, `NoData` |
| [Redis read](/documentation/plugins/cache/redis-read) | Reads one key from a Redis cache and emits the stored value. Use it for cache lookups, also on keys that C# scripts write with StackExchange.Redis or `IDistributedCache`. | `Input`, `Found`, `NotFound` |
| [Redis write](/documentation/plugins/cache/redis-write) | Writes one key to a Redis cache with an expiry: the whole input as JSON, or a text from an expression. Use it to fill a cache, for idempotency (write only if missing) and to share values with C# scripts that use StackExchange.Redis or `IDistributedCache`. | `Input`, `Written`, `Exists` |

## Codecs

4 plugins: [category page](/documentation/plugins/codecs/).

| Plugin | What it does | Pins |
|---|---|---|
| [ASN.1 decoder](/documentation/plugins/codecs/asn1-decoder-plugin) | Decodes a binary ASN.1 stream (for example telecom CDR files) into typed records. Flow types are generated from an ASN.1 module definition; every top-level record found in the stream is emitted on `Output`. | `Input`, `Output`, `Header`, `Continue` |
| [ASN.1 encoder](/documentation/plugins/codecs/asn1-encoder-plugin) | Encodes typed records into an ASN.1 BER file (for example telecom CDR files). Flow types are generated from an ASN.1 module definition, the same way the ASN.1 decoder does it; every record received on `Input` is encoded and appended to the current file, which is emitted on `Output`. | `Input`, `Output` |
| [CSV decoder](/documentation/plugins/codecs/csv-decoder-plugin) | Splits CSV text into records: every line becomes one record of a flow type generated from the configured header names, all properties being strings. Input is a text record or a file stream. | `Input`, `Output`, `Continue` |
| [CSV encoder](/documentation/plugins/codecs/csv-encoder-plugin) | Encodes records into CSV: one line per record, one column per configured property. The records of a batch (e.g. one Sql query execution, one file read) go into one CSV file, emitted as an in-memory file stream when the batch completes, ready for a file or blob writer. | `Input`, `Output` |

## Database

7 plugins: [category page](/documentation/plugins/database/).

| Plugin | What it does | Pins |
|---|---|---|
| [Bulk insert](/documentation/plugins/database/database-bulk-insert) | Buffers incoming records and writes them to a database table with the database's bulk load mechanism (minimally logged, much faster than row-by-row inserts). Use it for high-volume ingestion, for example after a file decoder or a mapper that produces many records. | `Input`, `Continue` |
| [Routine call](/documentation/plugins/database/database-routine-call) | Calls a stored procedure or function on a database and emits its result: the return value, output parameters, or the rows of a table-valued / pipelined result. Input and output types are generated from the routine signature. Works inside a *Sql transaction* scope. | `Input`, `Output`, `Continue` |
| [Schema reader](/documentation/plugins/database/database-schema) | Reads the schema of database objects - tables, views, procedures and functions - and emits it as descriptors: columns with types, keys and foreign keys for tables and views, parameters for routines. Its main use is the branch of an **AI tool**, so the model can look up tables before it writes SQL; it also serves to document a database or drive generic flows. | `Input`, `Output` |
| [Sql query](/documentation/plugins/database/database-query) | Runs a parameterized SQL statement against a database link and emits the result rows as typed records (or as one dynamic result set). Parameter values are taken from the input record, the message metadata or the flow configuration. Works inside a *Sql transaction* scope. Use it for custom selects, joins and DML statements. | `Input`, `Output`, `NoData`, `Continue` |
| [Sql transaction](/documentation/plugins/database/database-transaction) | Runs everything connected to its `Output` pin inside one database transaction. If all downstream components finish without error the transaction is committed and `Continue` is called; if any of them throws, the transaction is rolled back and the error is raised to the caller. | `Input`, `Output`, `Continue` |
| [Table reader](/documentation/plugins/database/database-reader) | Selects the rows of one database table (or view) and emits them as typed records, one record per row. The row type is generated from the table definition. A `DbShapeRequest` input adds projection, filtering, sorting and paging. Use it to read reference data or to serve table data to an API. | `Input`, `Output`, `NoData`, `Continue` |
| [Table writer](/documentation/plugins/database/database-writer) | Inserts, updates, upserts or deletes one row in a database table for every input record. The record type is generated from the table definition. After an insert, database-generated values (identity, primary key, computed columns) are written back into the record. Works inside a *Sql transaction* scope. | `Input`, `Continue` |

## Event

6 plugins: [category page](/documentation/plugins/event/).

| Plugin | What it does | Pins |
|---|---|---|
| [Kafka publisher](/documentation/plugins/event/kafka-producer) | Publishes every incoming record as a message to a Kafka topic. Accepts either a ready-made `EventData` (key, headers, timestamp, binary payload) or a `TextRecord` whose text becomes the payload. | `Input`, `Continue` |
| [Kafka subscriber](/documentation/plugins/event/kafka-consumer) | Subscribes to one Kafka topic and emits every received message as an `EventData` record. Use it as the starting point of a flow that reacts to Kafka events. | `Start`, `Continue` |
| [MQTT publisher](/documentation/plugins/event/mqtt-publisher) | Publishes every incoming `EventData` record as a message to an MQTT topic. Use it to send events or telemetry to an MQTT broker. | `Input` |
| [MQTT subscriber](/documentation/plugins/event/mqtt-subscriber) | Subscribes to an MQTT topic (or topic filter) and emits every received message as an `EventData` record. Use it as the starting point of a flow that reacts to MQTT messages. | `Start`, `Continue` |
| [NATS publisher](/documentation/plugins/event/nats-publisher) | Publishes every incoming `EventData` record to a NATS subject (core NATS, at-most-once) using the CloudEvents NATS binding in binary content mode: attributes travel as `ce-*` headers, the payload is the raw message body. | `Input`, `Continue` |
| [NATS subscriber](/documentation/plugins/event/nats-subscriber) | Subscribes to a NATS subject (core NATS, at-most-once) and emits every received message as an `EventData` record, strictly in arrival order. CloudEvents attributes are read from `ce-*` headers (NATS binding, binary content mode). Use it as the starting point of a flow that reacts to NATS messages. | `Start`, `Output` |

## File

8 plugins: [category page](/documentation/plugins/file/).

| Plugin | What it does | Pins |
|---|---|---|
| [Collect files](/documentation/plugins/file/collect-files) | Downloads files from a remote server over FTP, FTPS or SFTP into a local folder of the environment data folder and emits a `ViaFileInfo` for each downloaded file. Optionally deletes or renames the remote file afterwards and remembers collected file names to skip duplicates. | `Start`, `Output`, `Continue` |
| [Distribute files](/documentation/plugins/file/distribute-files) | Uploads files from a local folder of the environment data folder to a remote server over FTP, FTPS or SFTP. Either scans the whole local file group (e.g. on a Timer) or uploads the single file it receives as `ViaFileInfo`. Optionally deletes or moves the local file afterwards. The counterpart of **Collect files**. | `Input`, `Continue` |
| [File operation](/documentation/plugins/file/file-operation) | Housekeeping component that keeps the data and archive folders tidy. Each call scans a file group and moves, copies, compresses, decompresses or deletes every matching file. It is not part of the data path: it emits no file data, only `Continue` when it's done. Typically connected to a Timer. | `Input`, `Continue` |
| [Read file](/documentation/plugins/file/read-file) | Opens local files and passes them on as `ViaFileStream` (file info plus an open read stream). It either scans a folder of the environment data folder for files matching a mask (`Start` pin), or opens a single file given as `ViaFileInfo` (`Input` pin, e.g. from Collect files). | `Start`, `Input`, `Output`, `NoFiles` |
| [Remote shell](/documentation/plugins/file/telnet-ssh) | Runs a script on a remote system over SSH or Telnet for every incoming record (bash or another POSIX shell, or PowerShell on Windows and Linux servers over SSH) and returns the output as a `TextRecord`. Values from the input record can be injected into the script with placeholders. | `Input`, `Output` |
| [Stream compress](/documentation/plugins/file/stream-compress) | Packs incoming `ViaFileStream` records into an archive (ZIP, GZip, TAR, TAR.GZ or TAR.LZ) and emits the archive as a new `ViaFileStream`. The files of one batch (e.g. the entries of a decompressed archive, the files of one Collect files run) go into one archive; a file without a batch becomes its own archive. | `Input`, `Output` |
| [Stream decompress](/documentation/plugins/file/stream-decompress) | Unpacks an archive delivered as `ViaFileStream` (ZIP, GZip, TAR, TAR.GZ, RAR, 7-Zip) and emits every contained file as its own `ViaFileStream`. The entries of one archive can form a batch. | `Input`, `Output` |
| [Write file](/documentation/plugins/file/write-file) | Writes an incoming `ViaFileStream`, or a stream of `TextRecord`s, to a file in a local folder of the environment data folder. Typically the last step after Read file, Stream compress/decompress, an encoder or any component producing a file stream. | `Input` |

## Flow

25 plugins: [category page](/documentation/plugins/flow/).

| Plugin | What it does | Pins |
|---|---|---|
| [Alarm](/documentation/plugins/flow/alarm-plugin) | Pass-through component that raises a flow alarm (an alarm definition from the repository) when a condition is met: on every request, on a downstream exception, on a slow request, or when the request rate in a time window is too low or too high. Place it in front of the part of the flow you want to monitor. | `Input`, `Output`, `OnRaise` |
| [Build array](/documentation/plugins/flow/build-array) | Collects single records arriving on `Input` into one collection record and sends it to `Output` when the batch they belong to completes (e.g. one file read, one Sql query execution), or, for records without a batch, when the buffer is full or after an idle timeout. Use it to batch records for bulk inserts, bulk API calls or to rebuild a list after a ForEach. | `Input`, `Output` |
| [Data mapper](/documentation/plugins/flow/data-mapper) | Copies property values from the input record into a new record of another type, field by field, as defined in the mapping editor. Use it to turn one structure into another, for example a database row into an API request or a JSON document into a flow type. | `Input`, `Output` |
| [Data sampler](/documentation/plugins/flow/data-sampler) | Generates test data: for every message on `Input` it creates a new record of the output connection's type and fills its properties with (optionally seeded) random values. Use it to exercise a flow without a real data source, for example Timer → Data sampler → the flow under test. | `Input`, `Output` |
| [Decision router](/documentation/plugins/flow/decision-plugin) | Routes each record to one of several branches. A C# script returns a route name for the record; the record is sent to the outgoing connections whose route id equals that name. Use it for if/else and switch-like branching. | `Input`, `Output` |
| [Error](/documentation/plugins/flow/throw-exception) | Throws a configurable error when a record reaches it. Use it to end a request with a failure (validation failed, not found, ...) that upstream error handling (Try catch, Retry, HTTP listener error response) reacts to. | `Input` |
| [For each](/documentation/plugins/flow/for-each) | Splits a list property of the input record into single items and sends each item to `Output`, sequentially or in parallel. Use it to process the elements of a list one by one (call an API per item, map items, write them to a database). | `Input`, `Output` |
| [Fork](/documentation/plugins/flow/fork-plugin) | Runs the connected branch on its own background task for every input record and returns at once, so the caller does not wait for the downstream processing. Use it to decouple a slow branch from a fast producer (for example answer an HTTP request and process the data in the background) or to process records in parallel with a limit. | `Input`, `Output` |
| [Gather](/documentation/plugins/flow/gather) | Second half of the scatter-gather pattern: waits for the results of all branches started by a **Scatter** component and emits them as one combined object. The output type is generated from the components connected to its input. | `Input`, `Output` |
| [Lock](/documentation/plugins/flow/lock-plugin) | Lets only one record at a time pass through to the components behind it. Use it when concurrent requests (for example several HTTP calls, Fork tasks or a parallel For each) must not run a section of the flow at the same time, such as updating a shared file or a counter. | `Input`, `Output` |
| [Log](/documentation/plugins/flow/log-plugin) | Writes an entry to the flow log for each record that passes, with a fixed message, the chosen severity and the record and its metadata attached, then forwards the record unchanged. Use it to trace what goes through a branch or to log errors from error pins. | `Input`, `Output` |
| [Pin to metadata](/documentation/plugins/flow/pin-plugin) | Stores the record passing through in a named property of the flow metadata and forwards it unchanged. Later components and scripts of the same request can read the value from the metadata without a direct connection, for example to combine the original request with a later response. | `Input`, `Output` |
| [Plugin port](/documentation/plugins/flow/entry-point) | The entry point of a flow that is published as a plugin ("flow as plugin"). Other flows then use the published flow like any other component: what they send to its `Input` pin comes out of `Request` here, and what this flow sends to `Response` (or to a Plugin port response component) comes out of the component's `Output` pin in the calling flow. | `Request`, `Response`, `Initialize` |
| [Plugin port response](/documentation/plugins/flow/entry-point-response) | Sends the response of a flow that is published as a plugin back to the calling flow, exactly like connecting to the `Response` pin of the Plugin port. Use it to answer from several places of the flow without drawing long connections back to the Plugin port. | `Response`, `Continue` |
| [Range](/documentation/plugins/flow/range-plugin) | Loop component: calls `Output` once for every integer from `Start` (inclusive) to `End` (exclusive) with the same input record, then calls `Continue` once. The current index is available in the metadata property `RangeInfo`. | `Input`, `Output`, `Continue` |
| [Retry](/documentation/plugins/flow/retry-plugin) | Calls the components behind `Output`; when they fail with an exception, the record is put into a retry list and re-sent later, up to `MaxRetries` times. If it still fails, the record goes to the `MaxRetries` pin. | `Input`, `Output`, `MaxRetries` |
| [Scatter](/documentation/plugins/flow/scatter) | First half of the scatter-gather pattern: sends the same input message to every component connected to `Output`, in parallel, and tags each copy so that a **Gather** component can later combine the branch results into one message. | `Input`, `Output` |
| [Semaphore](/documentation/plugins/flow/semaphore) | Throttles parallelism: at most `Slots` records at a time may run through the components behind `Output`; further records wait until a slot is free. Use it in front of resources that must not be called by too many threads at once (APIs with rate limits, databases). | `Input`, `Output` |
| [Start flow](/documentation/plugins/flow/start-flow) | Starts another flow of the repository, in the same way as pressing Start for it, and then calls `Continue` either right after the flow has started or after it has stopped. No data is passed to the started flow and nothing is returned from it. | `Input`, `Continue` |
| [Stop execution](/documentation/plugins/flow/stop-request) | Stops the processing of the current request: after a record reaches this component, no further component is called for any record that shares the same metadata instance. The flow itself keeps running. | `Input` |
| [Sync call](/documentation/plugins/flow/sync-call) | Sequencer inside one flow: sends the record to `Output`, waits until that branch has completed, then sends the same record to `Continue`. Use it to run "first this, then that" with the same data. It does not call other flows. | `Input`, `Output`, `Continue` |
| [Timer](/documentation/plugins/flow/scheduler) | Scheduler that periodically calls the components connected to `Continue`, at a fixed interval aligned to a time of day. Use it as the start of polling, batch and heartbeat flows. It keeps the flow running. | `Start`, `Continue` |
| [Try catch](/documentation/plugins/flow/try-catch) | Error handler: runs the components behind `Try`; if they fail with an error, the record is sent to `Catch` with the error details in the metadata property `Error`. | `Input`, `Try`, `Catch` |
| [Unknown plugin](/documentation/plugins/flow/unknown-plugin) | Hidden placeholder. The designer shows it in place of a component whose plugin is no longer installed, so that the flow can still be opened and edited. It cannot be added from the toolbox. | `Input`, `Output` |
| [Wait](/documentation/plugins/flow/wait-plugin) | Delays each record by a fixed number of milliseconds, then passes it on unchanged. Use it for simple pauses between steps or crude rate limiting. | `Input`, `Output` |

## Google Cloud

4 plugins: [category page](/documentation/plugins/google-cloud/).

| Plugin | What it does | Pins |
|---|---|---|
| [GCS enumerator](/documentation/plugins/google-cloud/gcs-enumerator) | Lists the objects of a Google Cloud Storage bucket, optionally filtered by name prefix, folder level, name pattern, age and a custom metadata entry, and emits one file info record per object. Use it with *GCS reader* to process the files of a bucket. | `Input`, `Output`, `Continue` |
| [GCS operation](/documentation/plugins/google-cloud/gcs-operation) | Deletes, copies, moves, tags or changes the storage class of an object in Google Cloud Storage. The object comes from an incoming object file info (*GCS enumerator*) or from the configuration; the file info of the resulting object is passed on. Use it for housekeeping (archive or delete old objects) or to move objects between buckets. | `Input`, `Output`, `NoData` |
| [GCS reader](/documentation/plugins/google-cloud/gcs-reader) | Reads an object from Google Cloud Storage and emits it as a file stream, for example for a CSV or ASN.1 decoder. Every object is a batch: once it is processed and committed downstream, the object can be deleted, moved or tagged; a failed object can be moved to an error location. The object comes from an incoming object file info (*GCS enumerator*) or from the configuration. If the object does not exist, the input is passed to `NoData`. | `Input`, `Output`, `NoData` |
| [GCS writer](/documentation/plugins/google-cloud/gcs-writer) | Uploads text or a file stream as an object to Google Cloud Storage and passes the input on. Sets content type, custom metadata and storage class, can refuse to overwrite and can create the bucket. Streams are uploaded in chunks as they are read. | `Input`, `Output` |

## LLM

2 plugins: [category page](/documentation/plugins/llm/).

| Plugin | What it does | Pins |
|---|---|---|
| [AI tool](/documentation/plugins/llm/llm-tool) | Exposes a branch of the flow as a tool (function) that an **LLM chat client** can call. The model decides when to call it, the arguments are sent to the components on `Output`, and whatever comes back on `Input` is returned to the model as the tool result. | `Register`, `Output`, `Input` |
| [LLM chat client](/documentation/plugins/llm/llm-chat-client) | Sends the input text to a large language model on an OpenAI-compatible endpoint (vLLM, Ollama, llama.cpp, OpenAI, Gemini's OpenAI endpoint, ...) and emits the model's answer. Tools defined with **AI tool** components can be attached, so the model can call flow logic while answering. | `Register`, `Input`, `Output` |

## Messaging

5 plugins: [category page](/documentation/plugins/messaging/).

| Plugin | What it does | Pins |
|---|---|---|
| [Mail client](/documentation/plugins/messaging/smtp-mail-client) | Sends an e-mail over SMTP for every record it receives. The mail is either fully described by an incoming `SmtpMessage`, or built from the configuration (recipient, subject, body) with the body optionally taken from a `TextRecord`. Use it for notifications, reports and replies to collected mail. | `Input`, `Continue` |
| [Mail collector](/documentation/plugins/messaging/smtp-mail-collector) | Downloads e-mail from a mailbox over IMAP or POP3 and emits every message as a `SmtpMessage`. Trigger it periodically (for example from a timer) to process incoming mail, optionally deleting it from the server after processing. | `Start`, `Output`, `Continue` |
| [Sms receiver](/documentation/plugins/messaging/sms-receiver) | Connects to an SMSC or SMS gateway over SMPP and emits every incoming SMS (and delivery report) as a message. It is a listener: the flow keeps running while it is connected. | `Start`, `Output`, `DeliveryAck` |
| [Sms transmitter](/documentation/plugins/messaging/sms-transmitter) | Sends SMS messages to an SMSC or SMS gateway over SMPP. Long texts are split into concatenated parts automatically; several receivers can be given in one message. | `Input`, `Output`, `Continue` |
| [Ussd server](/documentation/plugins/messaging/ussd-server) | Implements a USSD application over SMPP: receives USSD requests from the SMSC/USSD gateway, emits them to the flow, and sends back the response messages the flow produces. Use it to build USSD menus (e.g. `*123#`). | `Start`, `Request`, `Response` |

## Network

5 plugins: [category page](/documentation/plugins/network/).

| Plugin | What it does | Pins |
|---|---|---|
| [Ping](/documentation/plugins/network/ping-plugin) | Sends one ICMP echo request (ping) to a host for every record it receives and emits the result. Use it for simple availability checks of servers and network devices. | `Input`, `Output`, `Continue` |
| [Tcp client](/documentation/plugins/network/tcp-client-plugin) | Opens a persistent TCP connection to a remote server, writes the bytes of every input record to it and, optionally, emits everything the server sends back. Use it to talk to devices or services with a raw TCP protocol. | `Input`, `Output`, `Continue` |
| [TCP server](/documentation/plugins/network/tcp-server-plugin) | Listens for TCP connections on an address and port, emits all received data as `TcpDatagram` records and sends data back to a specific client through the `Response` pin. Use it to accept connections from devices or services that speak a raw TCP protocol. The component keeps the flow running. | `Start`, `Request`, `Response`, `Tcp events` |
| [UDP client](/documentation/plugins/network/udp-client-plugin) | Sends the bytes of every input record as one UDP datagram to a configured address and port, and optionally emits the datagrams the remote side sends back. Use it for UDP-based devices, telemetry or simple request/reply protocols. | `Input`, `Output`, `Continue` |
| [UDP server](/documentation/plugins/network/udp-server-plugin) | Listens on a UDP port and emits every received datagram as a `UdpDatagram` record. Use it to receive telemetry, syslog-style messages or device notifications sent over UDP. The component keeps the flow running. | `Start`, `Output` |

## Pipes

2 plugins: [category page](/documentation/plugins/pipes/).

| Plugin | What it does | Pins |
|---|---|---|
| [Pipe client](/documentation/plugins/pipes/port-client) | Calls a **Pipe listener** in another flow: every input record is sent to the selected listener over a local TCP pipe, and the listener's response (for two-way listeners) is emitted on `Output`. Use it to split logic into reusable flows (sub-flow / service style calls) on the same machine. | `Input`, `Output`, `Timeout` |
| [Pipe listener](/documentation/plugins/pipes/port-listener) | Entry point of a flow that is called from other flows. It opens a local TCP pipe, registers it under its `Name`, emits every incoming request on `Request` and, for two-way listeners, sends whatever reaches `Response` back to the calling **Pipe client**. The component keeps the flow running. | `Request`, `Response`, `Start` |

## Queues

4 plugins: [category page](/documentation/plugins/queues/).

| Plugin | What it does | Pins |
|---|---|---|
| [Duplicate check](/documentation/plugins/queues/de-duplicate-filter) | Passes a record to `Output` only the first time its key (the value of `FilterProperty`) is seen, optionally within a time window; repeats go to `Already exists`. Use it in front of anything that must not process the same item twice. | `Input`, `Output`, `Already exists` |
| [Priority queue](/documentation/plugins/queues/priority-queue) | Queue that emits records ordered by an integer priority property instead of arrival order. Input records are stored and the call returns at once; a background worker emits them one by one on `Output`. Optionally persistable and duplicate-filtering, like the Reqular queue. | `Input`, `Clear`, `Output`, `Already exists` |
| [Queue writer](/documentation/plugins/queues/queue-writer) | Producer for a queue of the same flow: adds each incoming record to a queue owned by a queue component (Reqular queue or Priority queue), then passes the record on. Use it to hand work from one part of a flow to the queue's consumer, or to feed one queue from several places. | `Input`, `Output` |
| [Reqular queue](/documentation/plugins/queues/queue-plugin) | FIFO or LIFO queue: input records are stored and the call returns at once; a background worker emits them one by one on `Output`. Use it to decouple a fast producer from slow processing, to serialize processing, or (persistable) to keep work across flow restarts. Optionally rejects duplicates. | `Input`, `Clear`, `Output`, `Already exists` |

## Scripting

4 plugins: [category page](/documentation/plugins/scripting/).

| Plugin | What it does | Pins |
|---|---|---|
| [C# script](/documentation/plugins/scripting/csharp-script) | Runs your own C# code for every message that reaches the component. Use it to transform data between plugins, implement logic no plugin covers, or call .NET libraries (NuGet packages referenced in the flow configuration are available). | `Input`, `Output` |
| [C# shared script](/documentation/plugins/scripting/csharp-shared-script) | A code library for the flow: write C# classes, helpers or extension methods once and use them from every C# script (and other compiled code) in the same flow. The component has no pins and never processes messages. | - |
| [JavaScript script](/documentation/plugins/scripting/java-script-script) | Runs your own JavaScript (Google V8 engine) for every message that reaches the component. Use it for transformations and small integrations when you prefer JavaScript over C#; `async`/`await`, `fetch`, `setTimeout` / `setInterval` and `console` are available. | `Input`, `Output` |
| [Python script](/documentation/plugins/scripting/python-script) | Runs your own Python code (CPython embedded through pythonnet) for every message that reaches the component. Use it for transformations or when you need Python packages installed on the host. | `Input`, `Output` |

## Test

1 plugin: [category page](/documentation/plugins/test/).

| Plugin | What it does | Pins |
|---|---|---|
| [Flow test case](/documentation/plugins/test/flow-test) | Defines one test case in a **Test** flow. When the test flow runs, every Flow test case component is started in turn; it triggers the components connected to it, waits until they have finished, and the test passes or fails depending on whether an exception was thrown. | `Starter pin`, `Test to start` |

## Text

5 plugins: [category page](/documentation/plugins/text/).

| Plugin | What it does | Pins |
|---|---|---|
| [Handlebars](/documentation/plugins/text/handlebars) | Renders a Handlebars (Mustache-style) template with the input data and emits the result as a text record. Use it to build e-mail bodies, messages, XML or JSON payloads from flow data. | `Input`, `Output` |
| [Json deserializer](/documentation/plugins/text/json-de-serializer) | Parses JSON text into objects of a flow type. The target type is not configured: it is the type of the connection on the `Output` pin. A JSON array produces one message per element; the elements can form a batch. | `Input`, `Output` |
| [Json serializer](/documentation/plugins/text/json-serializer) | Converts the input object to JSON text. The records of a batch (e.g. one Sql query execution, one JSON array from Json deserializer, one file read) are serialized together into one JSON array when the batch completes; records without a batch become one JSON object each. | `Input`, `Output` |
| [RSS/Atom parser](/documentation/plugins/text/rss-atom) | Parses an RSS 2.0 or Atom feed (XML text) and emits one record per feed item. Typically placed after an Http client that downloads the feed. | `Input`, `Output`, `Property`, `Id`, `Title`, `ArticleLink`, `Summary`, `Categories`, `PublishDate`, `Authors`, `EnclosureUrl` |
| [Text asset](/documentation/plugins/text/text) | Stores a piece of text (template, query, message, configuration snippet) in the flow so that scripts and services can read it by name. It has no pins and is not part of the data path. | - |

## Web

13 plugins: [category page](/documentation/plugins/web/).

| Plugin | What it does | Pins |
|---|---|---|
| [Http authentication](/documentation/plugins/web/http-authentification) | Reads the credentials of a request received by an **Http listener** and passes them on, so the next components can check them. It does not verify anything itself: connect `Output` to the component that checks the credentials (a database lookup, a file, a Script, a **JWT validator**) and raises an error to reject the request. Connect `Input` to the listener's `Authentificate` pin; when this component or one after it raises an error, the listener answers `401` and the request never reaches the listener's `Output` pin. | `Input`, `Output` |
| [Http client](/documentation/plugins/web/http-client) | Sends an HTTP request to a remote server and emits the response as a `WebHttpResponse`. Use it to call REST APIs, download files or post forms. The request is built from the configuration, optionally overridden by a `WebHttpRequest` on the input. | `Input`, `Output` |
| [Http listener](/documentation/plugins/web/http-listener) | Embedded web server: listens on a port and path, emits every incoming request as a `WebHttpRequest` and sends the response it receives back on its `Input` pin (or from an **Http response** component). Use it to expose a flow as an HTTP endpoint. | `Start`, `Output`, `Input`, `Authentificate` |
| [Http response](/documentation/plugins/web/http-listener-response) | Sends the HTTP response for a request received by an **Http listener**. Place it at the end of the request branch; it finds the waiting request through the flow metadata, so it must run in the same branch that started at the listener. | `Input`, `Continue` |
| [JWT issuer](/documentation/plugins/web/jwt-issuer) | Creates a signed JSON Web Token for a user, and optionally a refresh token. Use it in a login endpoint after the user's credentials have been checked; the **JWT validator** with the matching key accepts the token later. | `Input`, `Output` |
| [JWT validator](/documentation/plugins/web/jwt-validator) | Validates a JSON Web Token: from **Http authentication** (type `2` JWT, or Bearer), or a token sent as a `TextRecord`. It checks the signature with a shared secret, a public key or the keys of an OpenID Connect provider (Entra ID, Auth0, Keycloak, ...), then the lifetime, issuer, audience and required claims, and puts the claims into the flow metadata. An invalid token raises an error that the Http listener answers with `401` (`403` for a missing required claim). | `Input`, `Output` |
| [Rest handler](/documentation/plugins/web/rest-api-listener) | Handles one REST operation (method + route) behind an **Http listener**: it accepts only matching requests, extracts route, query and body parameters into a typed record and emits it. Connect several Rest handlers to the same listener `Output` pin, one per operation; each request goes to the handler(s) whose route matches. It also serves an OpenAPI (`swagger.json`) document for all Rest handlers of the flow. | `Input`, `Output`, `Validate` |
| [SOAP handler](/documentation/plugins/web/soap-handler) | Answers one SOAP operation behind an **Http listener**: it reads the request envelope (SOAP 1.1 or 1.2, document/literal wrapped) into a typed record, emits it, and sends what the flow returns to its `Response` pin back as the SOAP response, or a SOAP fault. Connect one SOAP handler per operation to the same listener `Output` pin; together they are one SOAP service, and they serve its WSDL at `?wsdl`. | `Input`, `Output`, `Validate`, `Response` |
| [Web socket client](/documentation/plugins/web/web-socket-client) | Connects to a remote WebSocket server, sends every input record as a message and emits every message received from the server. One connection per component, kept open while the flow runs. | `Input`, `Output`, `Start`, `OnConnect` |
| [Web socket listener](/documentation/plugins/web/web-socket-listener) | Embedded WebSocket server: accepts WebSocket connections on a port and path, emits every received message and sends messages back to a connected client. Use it for push or chat style endpoints; reply with the listener's `Input` pin or a **Web socket response** component. | `Start`, `Output`, `Input`, `Authenticate` |
| [Web socket response](/documentation/plugins/web/web-socket-response) | Sends a message back to the client connection that delivered the current message to a **Web socket listener**. The connection is taken from the `WebSocketListener` metadata, so place it in the branch that starts at the listener `Output` pin. | `Input`, `Continue` |
| [Webhook receiver](/documentation/plugins/web/webhook-receiver) | Receives webhooks (HTTP callbacks other systems send when something happens). Place it right after an **Http listener** (on its `Output` pin). The listener owns the URL, port and TLS; this component does the webhook specific work: answers URL checks, checks the signature, drops repeated deliveries and answers the sender quickly. | `Input`, `Output`, `Rejected` |
| [Webhook sender](/documentation/plugins/web/webhook-sender) | Turns any record into a signed webhook request. Connect its `Output` to an **Http client**, which does the actual sending (auth, TLS, client certificates, timeouts). The signature formats are the same ones the **Webhook receiver** checks, so a Viaducta flow can send to another one. | `Input`, `Output` |