Appearance
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, Start and keep running and Flow to flow.
AWS
4 plugins: category page.
| Plugin | What it does | Pins |
|---|---|---|
| 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 | 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 | 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 | 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.
| Plugin | What it does | Pins |
|---|---|---|
| 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 | 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 | 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 | 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.
| Plugin | What it does | Pins |
|---|---|---|
| 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 | 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 | 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.
| Plugin | What it does | Pins |
|---|---|---|
| ASN.1 decoder | 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 | 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 | 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 | 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.
| Plugin | What it does | Pins |
|---|---|---|
| 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 | 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 | 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 | 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 | 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 | 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 | 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.
| Plugin | What it does | Pins |
|---|---|---|
| Kafka publisher | 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 | 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 | 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 | 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 | 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 | 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.
| Plugin | What it does | Pins |
|---|---|---|
| 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 | 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 | 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 | 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 | 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 | 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 | 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 | Writes an incoming ViaFileStream, or a stream of TextRecords, 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.
| Plugin | What it does | Pins |
|---|---|---|
| Alarm | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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.
| Plugin | What it does | Pins |
|---|---|---|
| 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 | 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 | 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 | 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.
| Plugin | What it does | Pins |
|---|---|---|
| AI 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 | 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.
| Plugin | What it does | Pins |
|---|---|---|
| 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 | 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 | 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 | 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 | 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.
| Plugin | What it does | Pins |
|---|---|---|
| Ping | 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 | 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 | 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 | 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 | 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.
| Plugin | What it does | Pins |
|---|---|---|
| Pipe 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 | 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.
| Plugin | What it does | Pins |
|---|---|---|
| Duplicate check | 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 | 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 | 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 | 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.
| Plugin | What it does | Pins |
|---|---|---|
| C# 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 | 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 | 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 | 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.
| Plugin | What it does | Pins |
|---|---|---|
| Flow test case | 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.
| Plugin | What it does | Pins |
|---|---|---|
| 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 | 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 | 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 | 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 | 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.
| Plugin | What it does | Pins |
|---|---|---|
| Http authentication | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 |