Input

Adds an input media file to an FFmpeg session. Input files can be local paths or URLs, and multiple inputs can be added to the same session for complex operations like merging or overlaying.

Common Properties

• Name - The custom name of the node.
• Color - The custom color of the node.
• Delay Before (sec) - Waits in seconds before executing the node.
• Delay After (sec) - Waits in seconds after executing node.
• Continue On Error - Automation will continue regardless of any error. The default value is false.

info

If the ContinueOnError property is true, no error is caught when the project is executed, even if a Catch node is used.

Inputs

• ffmpeg_id - FFmpeg session ID from the Create node. This links the input to a specific processing session.
• Input File URL - Path or URL to the input media file. Can be:
  • Local file path (e.g., /path/to/video.mp4)
  • HTTP/HTTPS URL (e.g., https://example.com/video.mp4)
  • Network path or other supported FFmpeg input formats

Options

• Input File Options - Array of FFmpeg input options. These are applied specifically to this input file before processing. Examples:

  • ["ss=00:00:10"] - Start reading from 10 seconds into the file
  • ["t=30"] - Only read 30 seconds of the input
  • ["r=30"] - Set input frame rate to 30 fps
  • ["f=mp4"] - Force input format to MP4

• Custom Input File Options - Individual input options added as separate fields. Each option should follow the format:

  • key=value for options with values (e.g., ss=00:00:10)
  • key only for flags

Output

• stream_id - Stream identifier for this input file. This ID is used by Filter and Output nodes to reference this specific input stream in the processing pipeline.

How It Works

The Input node adds a media file to the FFmpeg session and returns a stream identifier. When executed, the node:

1. Validates that both the FFmpeg session ID and input file path are provided
2. Parses any input options specified
3. Creates an FFmpeg input stream with the specified file and options
4. Registers the stream with the session
5. Returns a unique stream ID that can be used by downstream nodes

Input Options Reference

Common FFmpeg input options you can use:

Option	Description	Example
ss	Start time offset	ss=00:01:30 (start at 1min 30sec)
t	Duration to read	t=60 (read 60 seconds)
to	End time	to=00:02:00 (stop at 2 minutes)
r	Frame rate	r=25 (25 fps)
s	Frame size	s=1920x1080 (1080p)
f	Force format	f=mp4
codec	Specify codec	codec:v=h264
stream_loop	Loop input	stream_loop=3 (loop 3 times)

Example Usage

Basic Video Input

Add a single video file for processing:

// Create node outputs: ffmpeg_id
// Input node settings:
{
  "Input File URL": "/path/to/video.mp4"
}
// Output: stream_id

Input with Start Time

Skip the first 10 seconds of a video:

// Input File Options:
["ss=00:00:10"]

Input Specific Duration

Read only 30 seconds from the input:

// Input File Options:
["ss=00:00:05", "t=30"]
// Starts at 5 seconds, reads 30 seconds

Input from URL

Process a video from the internet:

// Input File URL:
"https://example.com/sample-video.mp4"

Multiple Inputs for Concatenation

Add two videos to merge them:

// First Input node:
{
  "Input File URL": "/path/to/video1.mp4"
}
// stream_id_1

// Second Input node (same ffmpeg_id):
{
  "Input File URL": "/path/to/video2.mp4"
}
// stream_id_2

// Later in Filter node, concatenate both streams

Video and Audio Inputs

Combine a video file with a separate audio file:

// Video Input:
{
  "Input File URL": "/path/to/video.mp4"
}
// video_stream_id

// Audio Input (same ffmpeg_id):
{
  "Input File URL": "/path/to/audio.mp3"
}
// audio_stream_id

// In Output node, map both streams

Practical RPA Scenarios

Scenario 1: Process Screen Recording

Add a screen recording captured earlier in the workflow:

Create → Input (screen_recording.mp4) → Filter (scale to 720p) → Output → Run

Scenario 2: Extract Segment from Video

Process only a specific time range:

// Input node with options:
{
  "Input File URL": "/recordings/meeting.mp4",
  "Input File Options": ["ss=00:15:00", "t=600"]
}
// Extracts 10 minutes starting at 15-minute mark

Scenario 3: Merge Multiple Clips

Combine several video clips:

Create →
  Input (clip1.mp4) → stream1
  Input (clip2.mp4) → stream2
  Input (clip3.mp4) → stream3
→ Filter (concat, streams=[stream1,stream2,stream3]) → Output → Run

Error Handling

The node will return errors in the following cases:

• "Input file is required" - Input File URL is empty
• "FFmpegID is required" - ffmpeg_id is not provided or invalid
• Invalid option format - Options are not properly formatted

Usage Notes

• The input file path can be absolute or relative to the working directory
• URLs must be accessible and supported by FFmpeg (HTTP, HTTPS, FTP, etc.)
• Each Input node creates a new stream, even if pointing to the same file
• Input options are applied before any filters or output settings
• Use ss option on input for seeking (faster than output seeking)
• File validation happens at Run time, not when the Input node executes

Performance Tips

1. Seek on Input: Use ss in Input options instead of Output options for faster seeking
2. Limit Duration Early: Apply t option on input to avoid processing unnecessary content
3. Use Appropriate Format: Force format with f option if auto-detection is slow
4. Stream Loop Efficiently: Use stream_loop for repeated content instead of multiple inputs

Common Errors and Solutions

Error: "File does not exist"

Cause: The specified file path is incorrect or the file is not accessible. Solution: Verify the file path is correct and the file exists. Use absolute paths when possible.

Error: "Invalid stream id"

Cause: Trying to use the stream_id before it's been created. Solution: Ensure the Input node executes before any Filter or Output nodes that reference its stream_id.

Error: "Unsupported format"

Cause: FFmpeg cannot detect or doesn't support the input file format. Solution: Verify the file is a valid media file. Try forcing the format with the f option.

Best Practices

1. Validate Files First: Use File System nodes to check if files exist before processing
2. Use Variables: Store file paths in variables for flexibility and reusability
3. Optimize Inputs: Apply input options (ss, t) to reduce processing time
4. Name Streams Clearly: When working with multiple inputs, use descriptive variable names for stream IDs
5. Handle URLs Carefully: Implement timeout and error handling for network-based inputs

Related Nodes

• Create - Initializes the FFmpeg session required by this node
• Output - Defines where to save processed streams
• Filter - Applies transformations to input streams
• Run - Executes the complete FFmpeg command
• Probe - Inspect input file properties before processing