> ## Documentation Index
> Fetch the complete documentation index at: https://docs.flowripple.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Quickstart
> Get up and running with Flowripple in minutes. Learn how to create a workflow that sends welcome emails when users sign up, from account setup to triggering from code.
## Get started in 5 minutes
This guide walks you through creating your first workflow that sends a welcome email to users when they sign up. You'll learn how to set up events, build workflows, and trigger them from your application. By the end, you'll have a working automation that responds to events in your code.
**Prerequisites:** You'll need a Flowripple account and a basic understanding
of HTTP requests. No prior workflow automation experience required.
Sign up for Flowripple and create your first project in the [dashboard](https://app.flowripple.com/app).
Once you've created a project, you'll be ready to create API keys and start building workflows.
API keys authenticate requests from your application to Flowripple. Create
your first API key: 1. Navigate to your project in the dashboard 2. Go to
**API Keys** in the sidebar navigation 3. Click **"Create New Key"** button
(or use an existing key if you already have one) 4. In the dialog that
appears, enter a descriptive name for your API key (e.g., "Production Key" or
"Development Key") 5. Click **"Create Key"** to generate your API key 6. Copy
the generated API key and store it in a secure place in your project
**Security best practice:** Keep your API key secure. Never commit it to
version control or expose it in client-side code. Store it as an environment
variable or use a secrets management service.
Create separate API keys for different environments (development, staging,
production) to better track usage, manage access, and rotate keys
independently. You can view, reveal, or delete existing keys from the API
Keys page at any time.
Events are the triggers that start your workflows. For this guide, we'll create a user signup event. While events are auto-created when first triggered via SDK (or API), you can pre-configure them with names and expected payloads:
1. Go to the **Events** section in your dashboard
2. Click **"Create Event"**
3. Enter an **Event Name** (e.g., "User Signup")
4. The **Event Identifier** will be auto-generated from the name (e.g., `user.signup`). You can customize it, but it must use only lowercase letters, numbers, dots (.), and dashes (-)
5. (Optional) Define the **Expected Payload** as a JSON structure to map variables and their data types. For a user signup event, you might use:
```json theme={null}
{
"userId": "string",
"email": "string",
"name": "string",
"timestamp": "number"
}
```
The expected payload helps workflows understand the data structure, enabling proper variable mapping, validation, and data routing in your workflow steps.
**Event naming convention:** Use dot notation (e.g., `user.signup`) to organize related events by domain. The identifier is automatically generated from the name, but you can customize it. Events are automatically created when you trigger them for the first time, so you can skip this step and jump straight to building workflows.
The form shows a live **SDK Usage Preview** that updates as you type, showing exactly how you'll trigger this event in your code. This helps you see the final API call before creating the event.
Create a workflow that sends a welcome email to users when they sign up:
1. Go to the **Workflows** section in your dashboard
2. Click **"Create Workflow"**
3. Give it a descriptive name (e.g., "Welcome Email" or "User Onboarding")
4. In the workflow builder, configure the event trigger:
* Click on the **trigger node** (the starting point of the workflow)
* Select **"Event Trigger"** from the trigger options
* In the event dropdown, select the event you just created (e.g., `user.signup`)
* Click **"Save"** to confirm the trigger configuration
5. Add the email step:
* Drag and drop the **"Send Email"** step onto the canvas
* Click on the **Send Email** step to open its configuration
* Configure the email inputs:
* **To Email**: Use an event variable like `{{trigger.email}}` to send to the user who signed up
* **Subject**: Enter a subject line (e.g., "Welcome to our platform!")
* **Body**: Write your email body and use event variables like `{{trigger.name}}` to personalize the message
* Click **"Save"** to confirm the email step configuration
6. The trigger and email step will automatically connect. Click **"Save Workflow"** to save your workflow
7. Toggle the **"Active"** to enable your workflow
This creates a simple single-step workflow. You'll learn about building complex workflows with conditions, loops, and multiple steps in the [workflow documentation](/workflows).
Trigger your workflow from your application. You can use the Flowripple SDK (Node.js only) or make HTTP requests from any programming language.
First, install the Flowripple SDK:
```bash npm theme={null}
npm install @flowripple/sdk
```
```bash pnpm theme={null}
pnpm add @flowripple/sdk
```
```bash yarn theme={null}
yarn add @flowripple/sdk
```
```bash bun theme={null}
bun add @flowripple/sdk
```
Then use it in your code:
```typescript theme={null}
import { FlowrippleClient } from '@flowripple/sdk';
// Initialize the client with your API key
const flowripple = new FlowrippleClient({
apiKey: process.env.FLOWRIPPLE_API_KEY
});
// Trigger the event
await flowripple.trigger('user.signup', {
userId: 'user_123',
email: 'user@example.com',
name: 'John Doe',
timestamp: 1704067200000
});
```
The SDK automatically handles authentication, request formatting, and error handling. Replace `user.signup` with your event identifier and include the data payload your workflow expects.
**Configuration options:**
```typescript theme={null}
const flowripple = new FlowrippleClient({
apiKey: 'frp_your-api-key', // Required: Your API key (starts with frp_)
baseUrl: 'https://api.flowripple.com', // Optional: Custom API URL
silent: false, // Optional: If true, errors return false instead of throwing
version: 'v1' // Optional: API version (defaults to 'v1')
});
```
You can trigger events using HTTP requests from any programming language. Here's an example using cURL:
```bash theme={null}
curl -X POST https://api.flowripple.com/api/v1/trigger \
-H "Content-Type: application/json" \
-H "x-api-key: YOUR_API_KEY" \
-d '{
"identifier": "user.signup",
"data": {
"userId": "user_123",
"email": "user@example.com",
"name": "John Doe",
"timestamp": 1704067200000
}
}'
```
**Expected response:**
```json theme={null}
{
"jobId": "job_abc123",
"status": "queued"
}
```
Replace `YOUR_API_KEY` with your actual API key from step 2. You can use this same HTTP endpoint from Python, Ruby, Go, PHP, or any other language that supports HTTP requests.
If successful, you'll receive a response with a `jobId` indicating your event was queued for processing. The workflow will execute asynchronously—check your dashboard to see the execution status and logs.
## Verify your workflow
After triggering your event, verify that everything worked correctly:
1. Go to the **Executions** section in your dashboard
2. Find the execution for your workflow (it should appear within a few seconds)
3. Check the status—it should show **"Success"** if everything ran correctly
4. Click on the execution to view detailed logs and see:
* Each step that was executed
* The data that was passed between steps
* Any errors or warnings
* Execution timing information
Workflow executions are processed asynchronously, so there may be a brief
delay (usually 1-2 seconds) before you see the execution in your dashboard. If
you don't see it after 10 seconds, check the troubleshooting section below.
**Success indicators:** - Execution status shows "Success" - All workflow
steps completed without errors - Email was sent (if using email integration) -
Execution logs show the expected data flow
## What's next?
Congratulations! You've successfully created and triggered your first workflow. Here's what to explore next:
Learn how to create and manage events, including defining expected payloads, using event variables, and organizing events by domain.
Discover advanced workflow features like conditional logic, loops, multiple
steps, and error handling strategies.
Explore available integrations like email providers, Slack, webhooks, and
more. Learn how to configure and use each integration.
Complete API documentation with all endpoints, parameters, response formats, and authentication methods.
## Troubleshooting
If you run into issues, here are common problems and solutions:
If you receive a 401 Unauthorized error, verify that:
* Your API key is correct and hasn't been revoked
* You're using the `Authorization: Bearer` header format (not `Bearer` alone)
* Your API key belongs to the correct project
* There are no extra spaces or characters in your API key
**Quick check:** Try copying your API key again from the dashboard to ensure it's correct.
If your event isn't being recognized: - Events are auto-created when first
triggered, so this error is rare - Verify your event identifier matches
exactly (case-sensitive) - Check that you're using the correct project (events
are project-specific) - If you pre-created the event, ensure it's in the same
project as your workflow
Use the dashboard to verify your event exists and check its exact identifier
spelling.
If your workflow isn't running after triggering an event: - **Check workflow
status:** Ensure your workflow is **Active** (not paused or draft) - **Verify
trigger configuration:** The workflow must have an event trigger configured -
**Match event identifier:** The event identifier in your code must match the
trigger exactly (case-sensitive) - **Check execution logs:** Look in the
Executions section for any error messages
Workflows must be both saved and activated. Creating a workflow doesn't
automatically activate it.
If your workflow executes but fails:
* **Check step configuration:** Verify all required fields are filled in each step
* **Review execution logs:** Click on the failed execution to see detailed error messages
* **Verify integration settings:** If using integrations (email, Slack, etc.), ensure they're properly configured
* **Check data format:** Ensure the data you're sending matches what the workflow expects
Execution logs show exactly where and why a workflow failed, making debugging much easier.
**Need help?** If you're stuck or have questions, reach out to our support
team at [mail@shivsarthak.com](mailto:mail@shivsarthak.com) or visit the
[dashboard](https://app.flowripple.com/app) for more resources and documentation.