Skip to main contentInputs and Outputs
Every Blueprint needs a way to receive information and send results back. Think of inputs and outputs as your Blueprint’s conversation with the outside world — inputs are what people tell your Blueprint, and outputs are what your Blueprint tells them back.
Overview
When would you use inputs and outputs? Use inputs when your Blueprint needs information to work with — like a customer’s name, an order amount, or a list of products. Use outputs to send back results — like a personalized greeting, a calculated total, or a status message.
Inputs and outputs are configured in the Data Contract section on the left side of Leapter. This is where you define what information your Blueprint expects to receive and what it will send back.
When would you use this? Use input parameters when you need someone to provide specific information to your Blueprint — like asking for a username, email address, or any single piece of data your Blueprint needs to work.
Input parameters are the questions your Blueprint asks. Each input has a name, description, and data type to help users understand what information to provide.
Structure
Each input parameter consists of several configurable parts:
-
Parameter Name - The identifier used in your Blueprint
- Must be a valid name (letters, numbers, underscores)
- Used to reference this input in your Blueprint elements
- Example:
username, orderAmount, customerEmail
-
Description - Human-readable explanation of what this input is for
- Helps users understand what information to provide
- Should be clear and specific
- Example: “Optional name of the user to be greeted. Can be present, null, or absent.”
-
Data Type - What kind of information this input expects
- string: Text like names, messages, or descriptions
- number: Numeric values like prices, quantities, or ages
- boolean: True/false values like yes/no questions
- date: Date and time information
- enum: A predefined list of allowed values
-
Options - Additional settings that control how the input works
- Required: Whether this input must be provided (checked) or is optional (unchecked)
- Multiple: Whether this input can accept multiple values (becomes a list)
Use Cases
Input parameters are essential for:
- User personalization: Collecting names, preferences, or settings
- Business data: Order amounts, product IDs, customer information
- Configuration: Settings that change how your Blueprint behaves
- Validation: Information needed to verify or process requests
- Dynamic behavior: Data that determines what actions to take
Example
In the example above, the input parameter:
- Name:
username
- Type:
string (text)
- Description: Clear explanation of what it’s for and that it’s optional
- Required: Not checked (making it optional)
- Usage: The Blueprint uses this to personalize a greeting message
In short: Input parameters are your Blueprint’s way of asking for information. Define what you need — users provide it when they run your Blueprint.
When would you use this? Use list inputs when you need multiple items of the same type — like a list of customer names, multiple email addresses, or a collection of products to process.
List inputs let your Blueprint work with multiple pieces of similar information at once, instead of just one item.
When you check the Multiple option for an input parameter:
- Configuration: The input expects a list/array of values instead of a single value
- User Interface: Users can add multiple items to the list
- Blueprint Access: Your Blueprint receives all items as a collection
- Processing: You can use Loop elements to work with each item
When someone runs your Blueprint:
- They can add multiple values to the list (Amy, Melodie, Max in this example)
- The “Add another value” option lets them include as many items as needed
- Your Blueprint receives all these values as a collection called
usernames
List inputs are perfect for:
- Batch processing: Handle multiple customers, orders, or items at once
- Bulk operations: Send emails to multiple recipients
- Data collections: Process lists of products, transactions, or records
- User selections: Let users pick multiple options from categories
- Import scenarios: Handle data from spreadsheets or databases
In short: List inputs let your Blueprint handle multiple items at once. Perfect for batch processing and working with collections of similar data.
Output Parameters
When would you use this? Use output parameters to send back results from your Blueprint — like a calculated total, a personalized message, a status update, or any information that the person or system running your Blueprint needs to know.
Output parameters are your Blueprint’s way of reporting back what it accomplished or discovered.
Structure
Each output parameter consists of:
-
Parameter Name - The identifier for this result
- Used to reference this output value
- Should clearly indicate what the result represents
- Example:
greeting, totalCost, processingStatus
-
Description - Explanation of what this output contains
- Helps users understand what they’re getting back
- Should describe the purpose and format of the result
- Example: “The resulting greeting message”
-
Data Type - What kind of information this output provides
- string: Text results like messages, descriptions, or formatted data
- number: Calculated values like totals, counts, or measurements
- boolean: Status results like success/failure or yes/no answers
- date: Time-based results like completion timestamps
- enum: Results from a predefined set of possible values
-
Options
- Required: Whether this output will always be provided
- Multiple: Whether this output can contain multiple values (list)
- Default Value: Optional fallback value if the output isn’t set
Use Cases
Output parameters are essential for:
- Results reporting: Send back calculated values, totals, or summaries
- Status updates: Inform about success, failure, or progress
- Data transformation: Return processed or formatted information
- Decision outcomes: Report which path or choice was made
- Generated content: Return created messages, documents, or data
Example
In the example above, the output parameter:
- Name:
greeting
- Type:
string (text)
- Description: “The resulting greeting message”
- Purpose: Returns the personalized greeting created by the Blueprint
- Required: Checked (this output will always be provided)
How Outputs Are Set
Outputs are typically set by:
- Assignment elements: Calculating and storing result values
- Return elements: Explicitly setting output values when completing
- Final processing: The last values assigned to output parameter names
In short: Output parameters are your Blueprint’s way of sharing results. Define what you’ll send back — users receive it when your Blueprint completes.
Data Contract Best Practices
- Clear naming: Use descriptive names that indicate the purpose
- Helpful descriptions: Explain what information is needed and why
- Appropriate types: Choose the right data type for each input
- Required vs optional: Only mark inputs as required if absolutely necessary
- Default values: Provide sensible defaults for optional inputs when helpful
Output Design
- Meaningful results: Return information that’s actually useful to the caller
- Consistent naming: Use names that clearly indicate what the output contains
- Appropriate types: Match the output type to the kind of data you’re returning
- Complete information: Include all the important results, not just success/failure
List Parameters
- When to use lists: Choose lists when you need to handle multiple similar items
- Clear item descriptions: Explain what each item in the list should contain
- Processing consideration: Remember you’ll need Loop elements to work with list inputs
Documentation
- Descriptive text: Write descriptions as if explaining to someone who’s never seen your Blueprint
- Examples: Include example values in descriptions when helpful
- Edge cases: Mention special cases or limitations in descriptions
Data Flow
Understanding how data moves through your Blueprint:
- Input Collection: Users provide input values when running your Blueprint
- Processing: Your Blueprint elements use input values in calculations and decisions
- Result Generation: Assignment and Return elements create output values
- Output Delivery: Final output values are returned to the caller
In short: Inputs and outputs are your Blueprint’s interface with the world. Inputs ask for what you need — outputs share what you’ve accomplished.