# About Blitzllama Blitzllama is a modern AI-powered user research platform that helps teams make better product decisions by streamlining feedback collection and analysis. It provides the tools and automation needed to deeply understand user experiences, improve product features, and drive growth. Blitzllama offers two core products: **Pulse** for feedback collection and **Eureka** for feedback analysis. ## **Why Blitzllama?** Traditional user research is often inefficient, leading to poor product decisions, missed opportunities, and customer dissatisfaction. Blitzllama eliminates these challenges by: * Automating feedback collection and analysis. * Providing real-time insights at scale. * Reducing the time and cost of user research. With Blitzllama, PMs and UX teams can uncover what drives user behavior, optimize product journeys, and improve customer satisfaction. ## **Pulse | Feedback Collection** **Pulse** helps you gather targeted, real-time feedback through in-app, link, and email surveys. It’s designed to be flexible, scalable, and easy to use. #### **Key Features:** 1. **Popular Question Types and Channels**: Collect feedback using ratings (stars, emojis, NPS), single/multi-select, open-ended text, and more, and launch as in-app surveys or shareable links. 2. **Advanced Targeting**: Use event-based triggers, funnel targeting, and cohort filters to survey the right users at the right time. 3. **AI-Powered Survey Creation**: Quickly generate high-quality surveys with Blitzllama's AI, reducing the effort and time needed to launch surveys. 4. **AI-Driven Insights**: Automatically analyze survey responses to extract key findings, saving time on manual interpretation. 5. **Multilingual Support**: Create surveys in 50+ languages and automatically translate responses into English for easy analysis. 6. **Seamless Integration**: Sync data with tools like Mixpanel, Segment, Slack, and more. Import/export cohorts and responses effortlessly. {% hint style="success" %} *Markaz used Pulse to gather real-time pricing feedback from sellers, leading to a 10-20% increase in reseller orders and a 35% reduction in complaints.* {% endhint %} ## **Eureka | Feedback Analysis** **Eureka** centralizes and analyzes all your feedback data, transforming it into actionable insights. It helps teams make sense of user feedback without the manual effort. #### **Key Features:** 1. **Centralized Repository**: Aggregate feedback from surveys, support chats, app store reviews, and interviews into one platform. 2. **AI Categorization**: Automatically categorize feedback by topics, sentiment, intent, and emotion for deeper analysis. 3. **Automated Insights**: Eureka generates detailed reports and uncovers hidden trends, saving hours of manual analysis. 4. **Advanced Search and Filters**: Quickly find insights by searching specific topics, cohorts, or feedback types with AI-powered search. 5. **Real-Time Alerts**: Get Slack and email notifications for new insights, ensuring you're always informed. {% hint style="success" %} HROne used Eureka to save over 20 hours per month by automating the categorization and analysis of support conversations and sales calls. This enabled them to make faster, data-driven product decisions, earning them the #3 spot on [G2's 2024 Highest Satisfaction Products](https://www.g2.com/best-software-companies/highest-satisfaction). {% endhint %} ## **Blitzllama Benefits** * **35% Average Response Rates** for Blitzllama surveys. * **Saves 35 Hours Per Week** with AI-driven analysis. * **40% Cost Savings** on feedback tools and employee effort. * **Quick Setup**: 1 hour for Pulse, 10 minutes for Eureka. # Creating Surveys Surveys are essential to gather actionable user insights, validate hypotheses, and measure satisfaction. Blitzllama makes it simple to create, customize, and distribute surveys to the right users at the right time. This guide will take you through two broad steps: **Framing the Right Questions** and **Configuring the Distribution**. ## Framing the Right Questions ### 1. **Choose a Template or Start from Scratch** Navigate to the **Research Tab** on Blitzllama's dashboard and click the **"Launch Research"** CTA in the top-right corner. Then, choose one of the following options: * **"Create new survey"**: Start from scratch and design your survey based on your specific needs. * **"Choose from templates"**: Select from 60+ survey templates used by top companies to save time and leverage best practices. *Tip: Start with the Testing Template or the Measure Product Market Fit template.*
### **2. Question Types** Blitzllama offers a variety of question types to cater to different survey objectives: | Rating - Number (1-5 scale) | | | ------------------------------------------------ | ------------------------------------------------------------------- | | Rating - Emoji (1-5 scale) | | | Rating - Stars (1-5 scale) | | | Rating - NPS (0-10 scale) | | | Choices - Single Select (choose one option) | | | Choices - Multi Select (choose multiple options) | | | Open Ended Text | | | Prompt | | | Thank You Card | | ### **3.** Use AI to Frame or Refine Questions Blitzllama's AI-survey creator is preloaded with your company's context and helps frame high-quality, relevant questions. Here's how to use it:
1. Add your survey’s **objectives** and **hypotheses** to personalize questions. 2. Choose: * **"Evaluative"** for objective questions (ratings, choices). * **"Generative"** for open-ended questions. 3. Set the **maximum number of questions**. 4. Click **"Generate"** to create the survey. You can edit the AI-generated questions if needed. ### **4.** Customizing Questions and Logic * Add **conditional logic** to display questions based on specific criteria. * Include **images** above question text for richer context. * Customize all text elements (subtext, legends, CTAs) and enable **option shuffling** to avoid response bias.
### **5.** Adding Multiple Languages * Personalize survey language into 50+ languages based on users' app language preferences. * Multilingual responses are automatically translated into English while preserving the original text. * AI-analysis is performed on all multilingual responses. ### **6.** Personalize Questions with User Attributes and Event Properties Use personalization to boost response rates: * Boost response rates by personalizing questions: * Use **user attributes**: E.g., *"Hey Jack, do you have a minute?"* * Use **event properties**: E.g., *"How would you rate your 'iPhone 15' purchase experience?'* Implement personalization using **liquid tags**. For more information, refer to the [personalization documentation](https://documentation.blitzllama.com/best-practices/personalization) for details. ## Configuring the Distribution ### **1. Choose Platform** Blitzllama supports all major mobile and web platforms. If you haven't integrated Blitzllama yet, refer to the integration documentation. You can also launch surveys as **link surveys** and distribute via **Email** or **WhatsApp**. *Tip: Link surveys are ideal for quick feedback from segmented user groups outside your app.* ### **2. Cohort Targeting** Precisely control which users see surveys: * By default, surveys are shown to **all users**. * To refine targeting, you can: * **Add user attribute conditions**. * **Upload a CSV** of user IDs. * Use cohorts from tools like **Mixpanel, Segment, or Amplitude**. **Example**: *Target users who completed a new feature onboarding to understand their first impressions.*
### **3. Trigger Surveys** Use triggers to display surveys at the optimal moment in the user experience: * Select from your configured triggers in the dropdown. * Prioritize surveys if multiple are set on a single trigger. ***Best Practice**: Trigger surveys immediately after a key action, like completing a purchase, for higher response rates.*
### **4.** Survey Frequency * Wait period: Set the minimum days between surveys to avoid overwhelming users. This applies across all Blitzllama surveys, ensuring users are not overwhelmed with frequent surveys. * Repeat frequency: Control how often a user sees the same survey: * Number of times viewed. * Response to the first question. * Completion of the survey.
#### **5. Sample Size and End Conditions** * **Sample Size**: Default is 500, but you can set no limits too (i.e. collect infinitely). * **End Date**: Set a specific end date if needed. * **Daily Limits**: Restrict the number of responses per day. ## **Customizing the UI/UX** Before launching, head to the **Settings Tab** to customize the survey’s look and feel: * All colors are customizable. You can create custom themes.
* Web surveys have additional options: positions, custom CSS, and fonts.
* For link surveys, you can customize the survey URL.
#### **Best Practices for PMs** 1. **Keep Surveys Short**: Aim for under 10 questions to maximize completion. 2. **Mix Question Types**: Combine ratings and open-ended questions for rich insights. 3. **Survey Timing**: Trigger surveys contextually (e.g., post-action). 4. **Analyze & Act**: Use feedback to iterate and improve features. **You’re Ready to Launch!** * **Save the draft**, **edit after launch**, or **pause** anytime. * Ready to gain actionable insights? **Head to Blitzllama's dashboard and launch your first Blitzllama survey!** # Creating Quizzes Quizzes can be launched in mobile apps, websites, or as a link. They behave similarly to surveys, requiring no additional integration effort if you're already launching surveys.\

View of how your users see the quiz.

## Creating Questions Navigate to the Research tab, click "Create New CTA" at the top right, and choose "Create Quiz."
Quizzes offer two question types: 1. Prompts: Use these to introduce the quiz or create breaks between questions. 2. Single select: These are the core quiz questions. More information below. ### 1. Questions 1. All text fields are editable (question, subtext, choices, and CTA text).
2. Attach images to any question. ### 2. Scoring 1. Assign each choice as right or wrong. 2. Assign a score to each choice (any integer, positive or negative). 3. Attach explanations for each question, optionally displayed on the Results page.
### 3. Results 1. All text fields on the Results page are editable and can be hidden or shown. 2. Display the score in any text field using ##score##. Example: "Woohoo, you scored ##score##" 3. Create multiple Results pages based on score buckets.
## Distribution 1. **Choose Platform** \ Quizzes can be launched in mobile apps, websites, or as links (distributable via email or WhatsApp). 2. **Cohort** * Control which users see quizzes using the cohorts feature. * Default: Show to all users. Add conditions on user attributes to filter further. * For a pre-defined set of users: * Upload a CSV list of user IDs * Use cohorts from existing tools like Mixpanel, Segment, Amplitude, etc. 3. **Trigger** * Use triggers to display quizzes at specific moments in the product experience. * All your triggers appear in the dropdown. * Prioritize surveys or quizzes when multiple are running on a trigger. 4. **Survey Frequency** * Wait period: Minimum days before displaying the survey/quiz to the same user again (applies across all Blitzllama surveys/quizzes). * Repeat frequency: Configure how often a user sees the same quiz. Options include: (i) Number of times viewed (ii) Response to the first question (iii) Completion of the entire quiz 5. **Sample Size and End Conditions** * Sample size selection provides confidence metrics (90% confidence is default). * Set an end date for the survey. * Set daily limits on maximum number of responses. You're now ready to launch the quiz! You can save drafts, edit after launching, or pause anytime. ## Customizing the UI/UX Go to the Settings tab to customize the look and feel of the Quiz (applies to all surveys too). Customize all colors and create custom themes.
# Targeting Essentials ## User Targeting (who should see the survey) ### **Cohort Filters** You can show the survey only to users who belong to or do not belong to a specific cohort. The cohort dropdown will list all the cohorts in your projects.
{% hint style="info" %} **Note:** To create or update cohorts, follow these steps: 1. Go to the dashboard’s homepage and navigate to the **Users & Cohorts** tab. 2. Click the **Create User Cohort** button to create a new cohort. You can create cohorts in the following ways: * **Uploading a list of user IDs:** * Select **Create User Cohort** > **Upload CSV**. * **Syncing cohorts from other tools like Amplitude, Mixpanel, or Segment:** * Refer to the [documentation here](https://documentation.blitzllama.com/connections-sources/mixpanel) for integration details. * **Segmenting users by their attributes:** * Select **Create User Cohort** > **Create using conditions**. {% endhint %} You can use "in" or "not in" to decide whether to show or not show the survey to specific user cohorts.
### Attribute Filters Further refine your targeting using user attributes passed to Blitzllama. User attributes are persistent properties that define a user.
**Default Attributes:** Blitzllama provides a set of default user attributes like user ID and user creation date. **Custom Attributes:** You can define custom attributes by: 1. **Defining them in your SDK:** * Refer to the [Web](https://documentation.blitzllama.com/sdk/web) or [Android](https://documentation.blitzllama.com/sdk/android) documentation for guidance. 2. **Uploading a CSV file with user IDs and attributes:** * Navigate to **Users & Cohorts** > **Create User Cohort** > **Upload CSV with user IDs and attributes**. To view all defined user attributes, go to **Users & Cohorts** > **All Attributes**. {% hint style="info" %} For example, define user attributes such as "user type," "subscription plan," or demographic details to effortlessly segment and reach out to the right users. All the user attributes and event properties will be available for download along with the users' responses. {% endhint %} ## Survey Triggering (when should users get the survey) ### Event-Based Targeting Blitzllama uses an event-based architecture to trigger surveys at the right moment as users browse the app or website. From the dashboard: * Choose the event to trigger the survey using the **Event Dropdown**. **Note:** Ensure all events are already defined in the codebase for mobile and web integrations. For web integrations, Blitzllama offers a no-code tracker setup.
**Features:** * **Triggering on Multiple Events:** * If multiple events are selected, the survey is shown at the first event the user encounters. * **Event Properties:** * Use event properties to filter users further. For example: * Event: "tournament page" * Properties: "games played" or "result." * Example: Show the survey only to users who land on the tournament page and have played specific games (e.g., X or Y). * **Event Performed Filter:** * Show the survey to users who have performed the event `n` times or fewer. ### Funnel-Based Targeting Use funnel-based targeting to address drop-offs in conversions or improve user journey understanding. **Example Use Case:** If the user: 1. Adds items to their shopping cart. 2. Lands on the shopping cart page. 3. Does not click "Buy Now." * You can trigger a survey immediately after they drop off at this stage.
**How to Configure:** * Create event sequences directly on the events configuration. * Define which events should be performed or not performed - these are the qualifying events. * Define the event at which the user should get the survey. #### Survey Delay Optionally delay the survey by `n` seconds to make it less jarring. * Example: If a user lands on the pricing page but performs no action for 10 seconds, trigger the survey after the delay.
#### **Survey Prioritization** If multiple surveys are configured for the same event or trigger point, you can prioritize which survey should be displayed first.
## Survey Frequency and Experience ### Resurvey Frequency To avoid oversurveying users, Blitzllama offers **Survey Frequency** controls with two components: **1. First-Time Frequency** Define the cooldown period between surveys for a user who has not seen any Blitzllama survey recently. * Example: If the first-time frequency is set to 7 days, a user who sees a survey on Day 1 will not see another survey until Day 7. **2. Repeat Frequency** Control how often users should see a survey with these configurations: | Option | Description | | -------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ | | **Display Only Once** | The user sees the survey only once, regardless of their response. | | **Display Survey Until User Responds** | Retry every X days until the user answers any survey question. Set the maximum number of views with **Max Views**. | | **Display Until Every Question Is Answered** | Retry every X days until all survey questions are answered. | | **Recurring Survey** | Users can retake the survey every X days, even if they’ve responded. Control the total views per user. |
### Survey Limits * **Response Limits:** * Set a cap on the total number of survey responses (up to 100,000). * Example: Stop showing the survey to new users once 50,000 responses are recorded. * **Daily Limits:** * Control the number of responses recorded per day. * Example: Collect up to 50 responses daily. The survey will pause for the rest of the day and resume the following day.
# Customization & Personalization Blitzllama's customization and personalization features ensure your surveys match your brand, have high response rates, and gather highly contextual insights. ## 1. Customizing Questions You can fully customize each question component, including: * **Text**: Modify the main question text, subtext, and labels. * **Choices**: Add, remove, or edit the options available for selection. * **Call-to-Action (CTA)**: Update the CTA text as needed. * **Images**: Upload images to accompany questions. * **Mandatory vs. Optional**: Mark any question as mandatory. Each question type has its unique properties. Click `More Options` CTA in each question card to checkout the customizable properties. For example, the screenshot below demonstrates a multi-select question:
Additionally, you can add a **Thank You Card** at the end of your survey to thank participants and optionally provide further instructions or links. ## 2. Conditional Logic The **conditional logic configurations** allow you to create complex and dynamic survey flows. These configurations include: * Branching logic based on user responses. * Multi-path surveys to cater to diverse user journeys. This feature mirrors the functionality of popular tools like Typeform and enables highly configurable survey flows.
## 3. Personalizing Language Our platform provides extensive multilingual capabilities to ensure global accessibility: * **Multi-Language Surveys**: A single survey can be launched in over 30 supported languages. All survey texts can be automatically translated from English to the desired language, with the option to manually edit translations for precision and tone. * **Matching Language to User's App Language**: Use user properties to automatically match the survey language with the user’s app language. For example, if a user is using the app in Spanish, they will receive the survey in Spanish. * **Automatic Translation**: Multilingual responses are detected and translated into English for analysis, while the original text is preserved for reference. These features save time and streamline the process of gathering and analyzing responses from diverse user bases. ## 4. Personalizing Questions Texts Using **Liquid Tags**, you can personalize survey content dynamically based on user attributes or backend triggers. This feature requires no custom code and significantly boosts response and completion rates. #### Key Features of Liquid Tags: * **User Attributes**: Access all user attributes from the dashboard under `Users & Cohorts > All Attributes`.
* **Event Properties**: Properties like date, time, boolean, and location from event properties can be used for personalization too. * **Dynamic Selection**: If multiple backend triggers are present, the most recent trigger’s properties are used. * **Data Type Support**: Strings, numbers, dates, and more are supported. All liquid tags are case-sensitive. #### Implementing Liquid Tags: To personalize a question, wrap the liquid tag with `##` within the text.
For example: * A user with `first_name = Brendan` will see: "Hi Brendan, how can we help you today?" * If `first_name` is empty, the question will not show the liquid tag parameter.
Users' liquid tags and event properties will be captured with each response and would appear in the Survey's Responses page.
## 5. Customizing the Look & Feel #### All Platforms All UI and UX elements of survey widgets can be customized from the dashboard, including: * Colors and styles. * Predefined themes (e.g., light mode, dark mode). * Theme assignment based on user segments or app settings. You can head over to Settings > Branding on Blitzllama Dashboard to go ahead and customize.
#### Web Surveys Web surveys offer additional customization options: * Upload custom CSS to modify the appearance. * Control survey positioning on the screen. * Upload custom fonts to align with brand guidelines.
#### c. Link Surveys For link-based surveys, you can: * Customize the URL to align with your branding. For instance, replace `link.blitzllama.com` with `feedback.acme.com`. You can * For more link survey features, refer to our [link survey documentation](https://documentation.blitzllama.com/sdk/links). # Extracting Insights from Surveys ## Categorization of Responses Blitzllama instantly organizes survey responses into **topics**, **sentiment**, **emotion**, and **intent**, saving you hours of manual work. As responses flow in, you’ll see the categorization on the survey results page. * **Topics**\ Automatically identifies topics most relevant to your industry. * Example (Fintech): *Payments, Security, Mobile App* * Example (Fitness): *Workout Plans, Nutrition, Equipment* * **Sentiment**\ Categorizes responses as *positive, neutral, or negative* to track customer mood at scale. * **Emotion**\ Detects 22 emotions—ranging from happiness and excitement to anger or sadness—giving deeper context to feedback. * **Intent**\ Determines the purpose behind each response: *complaint, improvement, praise, or help*.
#### Why It Matters * Focus on the most important themes in customer feedback. * Respond quickly to issues or requests that matter most. * Reduce manual work, so you can act faster on insights. ## Extracting Deeper Insights Blitzllama surfaces hidden patterns and relationships in your data through advanced analytics. * **Cross-Question Analysis**\ Understand how responses to one question relate to others. * Example: Customers giving 5-star ratings on satisfaction might highlight specific concerns elsewhere. * **Correlation Analysis**\ Uncover relationships between user attributes (e.g., location, behavior) and their survey feedback. * **Automatic Pattern Highlights**\ Blitzllama flags emerging trends or anomalies so you can focus where it matters most.
#### Why It Matters * Identify root causes of satisfaction or dissatisfaction. * Uncover actionable trends faster than manual analysis allows. * Use data-backed insights to guide decisions. ## Charts and Dashboards Visualize your survey data with customizable dashboards that are easy to share and interpret. * **Charts**\ Each question type has a different chart, which update in real time as the responses flow in.
* **Shareable Reports**\ Share insights with your team by generating dashboard links that work seamlessly in Slack or email.
#### Why It Matters * Turn complex data into clear visuals for faster decision-making. * Ensure team alignment by sharing consistent, data-driven insights. ## Chat with Your Data (beta) This cutting-edge feature allows you to interact with your survey data conversationally for instant answers. Available now for select customers. * **Ask Questions**\ Query your data in real time to uncover trends, patterns, or anomalies. * Example: *“What are the top complaints this month?”* * **Combine Behavioral Data**\ Enrich survey feedback with user attributes like location, demographics, or purchase history. * **Surface Instant Insights**\ Blitzllama automatically synthesizes data into clear takeaways for faster decision-making. #### Why It Matters * Spend less time exploring dashboards—get answers on demand. * Combine qualitative and quantitative data for a complete picture. * Act quickly on insights without needing a data scientist. ## Security & Compliance Blitzllama is **SOC2 Type 2 certified**, meeting the highest industry standards for data security and privacy. You can trust that your data is protected. # Core Concepts ### 1. **Triggers** A trigger launches the survey inside your mobile app or website, allowing you to ask users questions at the right moment in their product journey. * Triggers can be based on various user actions, such as: opening a specific screen, clicking a button, or completing an event. * For mobile apps, triggers must be defined in your codebase. However, web applications offer no-code trigger options. * You can add properties (e.g., screen\_name) to each trigger to provide context for each survey response. * When launching a survey, you can select the appropriate trigger from Blitzllama's dashboard. ### **2. Attributes** An attribute is a key-value pair that provides more context about each user. Pass the attribute data to Blitzllama via the SDK or from your analytics tools. Attributes are super useful to create targeted user cohorts. ### **3. Cohorts** A cohort is a segment of users that are created by filtering the user attributes. Use cohorts to precise target your micro-surveys. ### **4. Survey Frequency** **Wait period - t**his is the minimum number of days to wait before surveying the same user again. * The wait period applies across all of Blitzllama's surveys. * This feature ensures that users are not overwhelmed with frequent surveys. **Repeat frequency - y**ou can configure how often a user sees the same survey. * Options include setting limits based on: (i) number of times viewed (e.g., up to 3 times), (ii) response to the first question, (iii) completion of the entire survey. # Android ## Overview The Blitzllama Android SDK enables you to deliver in-product surveys directly inside your Android app. By integrating the SDK, you can collect targeted user feedback at critical moments in the user journey. **Key Features:** * Quickly embed surveys via triggers you define in your app. * Identify and track users to ensure they don’t receive duplicate surveys unnecessarily. * Personalize surveys with user attributes and event properties (optional). * Localize surveys by setting different languages (optional). **Requirements:** * Android 5.0 (API level 21) and above. * Java 8 compatibility (source and target). * Access to the Blitzllama dashboard (to retrieve your API key and manage triggers). ## Getting Started ### Before You Begin 1. **Obtain Your API Key:**\ Log in to the Blitzllama dashboard, navigate to Connections Tab, click Android, and find your `API_KEY`.
2. **Confirm Minimum SDK:**\ The SDK officially supports API level 21 and above. If your `minSdk` is below 21, override the library in your `AndroidManifest`: ```java ... ``` ## Quick Start (5 Minutes) ### 1. SDK Installation Add the SDK to your `app/build.gradle` and enable Java 8 (if not already): ```java // app/build.gradle dependencies { implementation 'com.blitzllama:Blitzllama:1.9.1' } android { ... compileOptions { sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8 } // For Kotlin projects kotlinOptions { jvmTarget = "1.8" } } ``` {% hint style="info" %} We recommend using AppCompatActivity while using the SDK, otherwise the surveys won't show up `HomeActivity extends AppCompatActivity{ }` {% endhint %} ### 2. Update AndroidManifest Declare your Blitzllama API key: {% code title="AndroidManifest.xml" %} ```xml ``` {% endcode %} ### 3. Initialize the SDK Create or update your `Application` class and extend `BlitzLlamaSDK`: {% tabs %} {% tab title="Java" %} ```java public class MyApplication extends BlitzLlamaSDK { @Override public void onCreate() { super.onCreate(); BlitzLlamaSDK.init(this); } } ``` {% endtab %} {% tab title="Kotlin" %} ```kotlin override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) BlitzLlamaSDK.init(this); } ``` {% endtab %} {% endtabs %} {% hint style="info" %} NOTE: If you are registering the activity lifecycle in your application class, please make sure to call the SDK's init function below that. {% endhint %} ### 4. Create a User Ensure you create a user with a unique ID before triggering surveys: {% tabs %} {% tab title="Java" %} ```java BlitzLlamaSDK.getSdkManager(this).createUser("user_id"); ``` {% endtab %} {% tab title="Kotlin" %} ```kotlin BlitzLlamaSDK.getSdkManager(this).createUser("user_id") ``` {% endtab %} {% endtabs %} ### 5. Trigger a Survey Add a trigger event to display surveys: {% tabs %} {% tab title="Java" %} ```java BlitzLlamaSDK.getSdkManager(this).triggerEvent("trigger_name") ``` {% endtab %} {% tab title="Kotlin" %} ``` BlitzLlamaSDK.getSdkManager(this).triggerEvent("trigger_name")� ``` {% endtab %} {% endtabs %} You’re now ready to collect targeted user feedback with Blitzllama's in-app surveys! 🚀 Read further to check other capabilities of Blitzllama and customize to your requirement. *** ## Triggers and Event Properties ### What are Triggers? **Triggers** are events in your app (e.g., button presses, screen loads) that prompt a survey if configured in the Blitzllama dashboard. ### Adding Trigger Properties (Optional) You can attach properties to a trigger event to provide additional context, such as screen names or user actions. These properties help refine your targeting. ```java HashMap eventProperties = new HashMap(); mapValues.put("event Key", "event Value"); mapValues.put("event Key1", "event Value1"); BlitzLlamaSDK.getSdkManager(this).triggerEvent("trigger_name",eventProperties) ``` Event schemas can be changed on the dashboard. You can use these properties to more filter users in the survey, as shown in the below screenshot. ![](/files/yFfwVi3cufc0xRrZDJHA) **Why Use Trigger Properties?** * Filter users more precisely in the Blitzllama dashboard. * Understand user context when surveys are triggered. {% hint style="success" %} You can also use **backend events** to launch in-app surveys. Check out for more details. {% endhint %} ## Personalizing and Localizing Surveys ### Setting User Attributes Attributes help you segment and target specific user groups (e.g., plan type, user role). Allowed `data_type` values are "string", "number", "date", "boolean". {% tabs %} {% tab title="Java" %} ```java BlitzLlamaSDK.getSdkManager(this).setUserAttribute("attribute_name","attribute_value", "data_type"); ``` {% endtab %} {% tab title="Kotlin" %} ```kotlin BlitzLlamaSDK.getSdkManager(this).setUserAttribute("attribute_name","attribute_value", "data_type") ``` {% endtab %} {% endtabs %} Set User Email or Name: {% tabs %} {% tab title="Java" %} ```java BlitzLlamaSDK.getSdkManager(this).setUserEmail("user_email_address"); BlitzLlamaSDK.getSdkManager(this).setUserName("user_name"); ``` {% endtab %} {% tab title="Kotlin" %} ```kotlin BlitzLlamaSDK.getSdkManager(this).setUserEmail("user_email_address") BlitzLlamaSDK.getSdkManager(this).setUserName("user_name") ``` {% endtab %} {% endtabs %} ### Setting Survey Language To display surveys in the user's preferred language, set the survey language using an ISO 639-1 code (e.g., `"en"` for English, `"es"` for Spanish). {% tabs %} {% tab title="Java" %} ```java BlitzLlamaSDK.getSdkManager(this).setSurveyLanguage("language_code"); ``` {% endtab %} {% tab title="Kotlin" %} ``` BlitzLlamaSDK.getSdkManager(this).setSurveyLanguage("language_code") ``` {% endtab %} {% endtabs %} **Why Set Survey Language?** * Improve user experience by displaying surveys in the user's native language. * Supports better localization for global apps. ## User Management ### Logout When a user logs out, call the logout method to clear their session and ensure subsequent events are not tied to the previous user’s data. {% tabs %} {% tab title="Java" %} ```java BlitzLlamaSDK.logout(); ``` {% endtab %} {% tab title="Kotlin" %} ```kotlin BlitzLlamaSDK.logout() ``` {% endtab %} {% endtabs %} **Why Logout?** * Prevents mixing user data between sessions. * Ensures a clean state when switching users. ## Advanced Features ### Survey Completion Callback Receive a callback when a user completes a survey. This can be useful for analytics or triggering follow-up actions. **Example:** ```java import com.blitzllama.androidSDK.common.OnSurveyCompletionListener; .. .. HashMap eventProperties = new HashMap(); mapValues.put("event Key", "event Value"); OnSurveyCompletionListener listener = result -> { Log.d("result",result.toString()); }; BlitzLlamaSDK.getSdkManager(this).triggerEvent("trigger_name",eventProperties,listener) ``` #### Sample Callback data ```json { "group_id": "g-d8ee8...", "survey_id": "s-d8ee8...", "event_name": "trigger name" } ``` ## **Performance Impact** Every release we extensively test our SDK in multiple sample apps across devices and Android versions for crashes and performance issues. The performance impact is negligible and below are the stats for the latest SDK version. * **Load times:** All calls are async and hence does not impact app or screen load times. * **App size:** Blitzllama SDK AAR size is 150kb and it's size impact on an Android app is about 200kb. * **CPU usage:** A negligible increase of 1-5% CPU usage only when the micro survey is on-screen. ## FAQ & Troubleshooting * **Survey not showing up?** * Ensure `createUser` is called before `triggerEvent`. * Check that the event name matches exactly what’s configured in the Blitzllama dashboard. * **Survey not showing up on the home screen or the first app page?** * This might be a race condition, please pass a callback function as the second argument to `createUser` function. ```java import com.blitzllama.androidSDK.SdkInitialisationSuccessCallback .. .. val clbk = object : SdkInitialisationSuccessCallback{ override fun onSuccess() { BlitzLlamaSDK.getSdkManager(this@HomeActivity).triggerEvent("MainActivity") } override fun onFailure() { BlitzLlamaSDK.getSdkManager(this@HomeActivity).triggerEvent("MainActivity") } } BlitzLlamaSDK.getSdkManager(this).createUser("user_id", clbk); ``` * **Switching users?** * Call `BlitzLlamaSDK.logout()` before creating a new user to avoid mixing sessions. * **How to create triggers?**\ There are two methods to create a trigger: 1\. Add new trigger\_name in your app and it will automatically be created if it doesn't exist and then be available for selection in the dashboard. 2.: To add a trigger into your app, first create a trigger on the Blitzllama dashboard with a trigger\_name, then use the same trigger\_name in the following function. Make sure to create a user before triggering a survey. * **Need more help?** * Reach out over the support chat or email . ### Next Steps 1. **Start with adding 5 triggers** for the most critical user actions in the app. 2. **Create your first survey** on the Blitzllama dashboard. 3. **Customize the UI/UX** of the survey on the Blitzllama dashboard. # iOS ## Overview The Blitzllama iOS SDK enables you to deliver in-product surveys directly inside your iOS app. By integrating the SDK, you can collect targeted user feedback at critical moments in the user journey. **Key Features:** * Quickly embed surveys via triggers you define in your app. * Identify and track users to ensure they don’t receive duplicate surveys unnecessarily. * Personalize surveys with user attributes (optional). * Localize surveys by setting different languages (optional). **Requirements:** * iOS 11 and above * Access to the Blitzllama dashboard (to retrieve your API key and manage triggers). ## Getting Started ### Before You Begin **Obtain Your API Key:**\ Log in to the Blitzllama dashboard, navigate to the Connections Tab, click iOS, and find your `API_KEY`. ## Quick Start (5 Minutes) ### 1. SDK Installation #### Option A: Cocoapods (Recommended) 1. Add the SDK to your Podfile: ```bash pod 'Blitzllama-ios', '1.6.29' ``` 2. Install the pods: ```bash pod install ``` #### Option B: Swift Package Manager (SPM) * In Xcode, go to File > Add Packages. * Use the [Blitzllama iOS SDK git](https://github.com/Blitzllama/ios-releases) repository. * Select the latest version from he master branch and add it to your project targets. ### 2. Initializing the SDK In your `AppDelegate` (or `SceneDelegate` if using newer lifecycle): ```swift import BlitzLlamaSDK import UIKit @main class AppDelegate: UIResponder, UIApplicationDelegate { func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool { //initialisation Blitzllama BlitzLlamaSDKController.getSDKManager.setBlitzLlamaAPIKey("API_KEY") return true } } ``` ### 3. Create a User Ensure you create a user with a unique user ID before triggering surveys to avoid duplicate survey prompts: ```swift BlitzLlamaSDKController.getSDKManager.createUser("user_id") ``` ### 4. Trigger a Survey Add a trigger in your app (e.g., on a button press or screen load) to display surveys: ```swift BlitzLlamaSDKController.getSDKManager.fetchSurvey(triggerName: "triggerName") ``` Make sure the trigger name matches the configuration on the Blitzllama dashboard. You’re now ready to collect targeted user feedback with Blitzllama’s in-app surveys! 🚀 *** ## Triggers and Event Properties ### **What are Triggers?** Triggers are events in your app (e.g., button presses, screen views) that prompt a survey if configured in the Blitzllama dashboard. ### **Adding Trigger Properties (Optional)** ```swift // Define your event properties let eventProperties: [String: Any] = [ "eventKey1": "eventValue1", "eventKey2": "eventValue2" ] // Trigger the survey with the event properties BlitzLlamaSDKController.getSDKManager().fetchSurvey(triggerName: "triggerName", properties: eventProperties) ``` **Why Use Trigger Properties?** * Filter users more precisely in the Blitzllama dashboard. * Understand user context when surveys are triggered. {% hint style="success" %} You can also use **backend events** to launch in-app surveys. Check out for more details. {% endhint %} ## Personalizing and Localizing Surveys ### Setting User Attributes Attributes help you segment and target specific user groups. Allowed data types are `"string"`, `"number"`, `"date"`, `"boolean"`. ```swift BlitzLlamaSDKController.getSDKManager.updateUserAttributes("attribute_name", attributeValue: "attribute_value", dataType: "string") ``` ### Set User Email or Name (Optional) Providing the user’s email or name is optional but can help personalize surveys. ```swift BlitzLlamaSDKController.getSDKManager.updateUserEmail("user_email") BlitzLlamaSDKController.getSDKManager.updateUserName("user_name") ``` ### Setting Survey Language Set the survey language using an [ISO 639-1 codes](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) (e.g., `"en"` for English). ```swift BlitzLlamaSDKController.getSDKManager.setLanguageCode("en") ``` **Why Set Survey Language?** * Improve user experience by displaying surveys in the user's native language. * Better localization for multi-lingual apps. ## User Management ### Logout User When a user logs out, call the logout method to clear their session: ```swift BlitzLlamaSDKController.getSDKManager.logout() ``` **Why Logout?** * Prevents mixing user data between sessions. * Ensures a clean state when switching users. ## FAQ & Troubleshooting * **Survey not showing up?** * Ensure `createUser` is called before triggering an event. * Check that the trigger name matches exactly what’s configured in the Blitzllama dashboard. * **Survey not showing on the first screen?** * This might be due to timing issues. Consider delaying the trigger call until after `createUser` completes. * **Switching users?** * Call `logout()` before creating a new user to avoid mixing sessions. * **How to create triggers?** * Add a new `trigger_name` in your app. If it doesn’t exist, it’s automatically created and will appear on the dashboard. * Alternatively, create the trigger on the Blitzllama dashboard first, then use the same `trigger_name` in the `fetchSurvey` call. * **Need more help?** * Reach out via support chat or email `tech@blitzllama.com`. ### Next Steps * Start by adding 5 triggers for the most critical user actions in your app. * Create your first survey on the Blitzllama dashboard. * Customize the UI/UX of the survey on the Blitzllama dashboard. # Web Blitzllama helps you collect user feedback seamlessly within your website. This guide shows you how to install and integrate the Blitzllama Web SDK, whether you’re a non-developer who wants a simple solution or a developer looking for advanced customization. ## For Non-Developers: Quick & No-Code Setup ### What You Need * Access to your website’s codebase, or the ability to add a script in the HTML `` section. * A Blitzllama account and your unique `API_KEY` (found in the Blitzllama dashboard under **Connections > Web**). ### **Setup Steps** 1. **Copy & Paste the Script**:\ Paste this snippet into your HTML file’s `` section (before ``): ```javascript ``` {% hint style="info" %} For WordPress integration, check out {% endhint %} 2. **Create No-Code Triggers in the Dashboard**: 1. **Login to Blitzllama Dashboard**: Go to **Events** tab. 2. Click **Add a Event**: Choose from: 1. **Page URL Trigger**: Show a survey when a user visits a page that matches certain criteria (e.g., URL contains `checkout`). 2. **CSS Selector Trigger**: Show a survey when a user interacts with an element (e.g., a button) on your site. {% hint style="info" %} For example, to show a survey on any page containing `checkout:` 1. Trigger Type: *Page URL* 2. Condition: *URL contains* `checkout` {% endhint %} That’s it! No coding or user management required. Your visitors will now see a survey based on the triggers you’ve set. You’ve integrated Blitzllama without writing custom code or managing users. Surveys will appear based on the rules you’ve configured in the Blitzllama dashboard. *** ## For Developers: Advanced Integration & Customization If you need more control, such as identifying users, setting attributes, or programmatically triggering surveys - these steps are for you.: ### Install via NPM For modern frontend frameworks (React, Vue, Angular) or TypeScript support, install via NPM: {% tabs %} {% tab title="NPM" %} ```javascript npm i blitzllama-js ``` {% endtab %} {% tab title="Yarn" %} ```javascript yarn add blitzllama-js ``` {% endtab %} {% endtabs %} {% hint style="warning" %} Please use **npm i blitzllama-js\@1.1.4** if you are using script injection (Angular). {% endhint %} Then, in your application, initialize Blitzllama: ```javascript import blitz from 'blitzllama-js'; //initialize blitzllama SDK. Place this as higher in your app as possible blitz.init("api_key"); //You can find your API_KEY by navigating to Connections tab > Web //on Blitzllama's dashboard. ``` ### User Management #### Identifying Users Identifying users can prevent duplicate surveys and enable personalization. This is not mandatory but highly recommended for more targeted feedback.. {% tabs %} {% tab title="HTML Script" %} ```javascript blitz('createUser', 'user_id'); ``` {% endtab %} {% tab title="NPM" %} ```javascript blitz.createUser('user_id'); ``` {% endtab %} {% endtabs %} #### Logout User You can call this function, if you wish to stop tracking the user & their events. Call the **logout** function or clear storage, if you are switching between projects in the same device. {% tabs %} {% tab title="Html Script" %} ```javascript blitz('logout'); ``` {% endtab %} {% tab title="NPM" %} ```javascript blitz.logout(); ``` {% endtab %} {% endtabs %} ### Personalize and Localize Surveys #### Setting User Attributes Add context to surveys and target specific user segments. Allowed data\_type values are "string", "number", "date", and "boolean". {% tabs %} {% tab title="HTML Script" %} ```javascript blitz('setUserAttribute','attribute_name','attribute_value', 'data_type'); ``` {% endtab %} {% tab title="NPM" %} ```javascript blitz.setUserAttribute('attribute_name','attribute_value', 'data_type'); ``` {% endtab %} {% endtabs %} Update multiple attributes at once using a JavaScript object: {% tabs %} {% tab title="HTML Script" %} ```javascript blitz('setUserProperties', {'property_name': 'value', age: 25, place: 'chennai'}); ``` {% endtab %} {% tab title="NPM" %} ```javascript blitz.setUserProperties({'property_name': 'value', age: 25, place: 'chennai'}); ``` {% endtab %} {% endtabs %} #### Setting User Email and Name: {% tabs %} {% tab title="HTML Script" %} ```javascript blitz('setUserEmail', 'user_email'); blitz('setUserName', 'user_name'); ``` {% endtab %} {% tab title="NPM" %} ```javascript blitz.setUserEmail('user_email'); blitz.setUserName('user_name'); ``` {% endtab %} {% endtabs %} #### **Set User Language** To display surveys in the user's preferred language, set the survey language using an [ISO 639-1 codes](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) (e.g., `"en"` for English, `"es"` for Spanish). {% tabs %} {% tab title="HTML Script" %} ```javascript blitz('setSurveyLanguage','language_code'); ``` {% endtab %} {% tab title="NPM" %} ```javascript blitz.setSurveyLanguage('language_code'); ``` {% endtab %} {% endtabs %} ### Creating Triggers Triggers display a survey to the user at critical moments in their journey—on button presses, page views, or any custom event. There are two main approaches: 1. **No-Code Triggers** (Already Covered Above)\ Set up triggers in the dashboard based on: * **Page URLs**: Ideal for launching surveys on page load. * **CSS Selectors**: Ideal for user actions like clicks on buttons or links. 2. **Code Triggers**\ For advanced scenarios, you can trigger surveys programmatically {% tabs %} {% tab title="HTML Script" %} ```javascript blitz('triggerEvent', 'trigger_name'); ``` {% endtab %} {% tab title="NPM" %} ```javascript blitz.triggerEvent('trigger_name'); ``` {% endtab %} {% endtabs %} #### Trigger Properties You can attach properties to a trigger event to provide additional context, such as screen names or user actions. These properties help refine your targeting. {% tabs %} {% tab title="HTML Script" %} ```javascript blitz('triggerEvent', 'trigger_name',{event_key: ""}); ``` {% endtab %} {% tab title="NPM" %} ```javascript blitz.triggerEvent('trigger_name', {event_key: ""}); ``` {% endtab %} {% endtabs %} This allows you to integrate triggers deeply into your business logic, ensuring surveys appear at precisely the right time. {% hint style="success" %} You can also use **backend events** to launch in-app surveys. Check out for more details. {% endhint %} ## Advanced Options ### Frontend Callback Blitzllama provides a completion event to let you run custom logic after the user finishes a survey: {% tabs %} {% tab title="HTML Script" %} ```javascript blitz('subscribeEvent', 'survey_completed', (data) => { console.log(data.detail); }); ``` {% endtab %} {% tab title="NPM" %} ```javascript blitz.subscribeEvent('survey_completed',(data) => { console.log(data.detail); })); ``` {% endtab %} {% endtabs %} #### Sample Callback data (data.detail) ```json [{ question_order: 1, question_text: "How well do you expect Blitz Demo to meet your needs?", question_type: "single_select_feedback", response: ['One'] //array value for select questions & string for other question types event: "event_name" }, ...] ``` ### Custom CSS For fine-tuned control over the survey’s appearance, Blitzllama supports custom CSS settings. You can configure this from the Settings tab in the Blitzllama dashboard: ```javascript //we support the following four configurations. { star_feedback: { textalign: 'center' }, nps_feedback: { textalign: 'center' }, scale_feedback: { textalign: 'center' }, close_icon_url: '', font_scale: 1 // 1 denotes font size of 16px } ``` ### Performance Impact **Thorough Testing:** Each release is tested across multiple websites and browsers to ensure no crashes or significant performance regressions. * **Speed:**\ The SDK script is loaded asynchronously, so it won’t slow down your page load. Blitzllama loads in two parts: * `controller.js` (12KB) for all users, * `microsurveys.js` (250KB) only for sessions where a survey is actually shown. * **CDN Hosting:**\ Blitzllama scripts are served from a global CDN, ensuring the fastest load times regardless of user location. * **CPU usage**\ Minimal increase (<0.4%) in CPU usage, only when the survey is displayed on-screen. ## Web Surveys Examples Below are a few screenshots showcasing how surveys appear on both mobile and desktop versions of your site. These examples can help you visualize the end-user experience.
## FAQ & Troubleshooting **Survey not appearing?** * Ensure you’ve initialized the SDK with the correct `API_KEY`. * Check that your no-code trigger conditions match the page URL or the correct CSS selector. * If using code triggers, confirm that `createUser` is called before `triggerEvent` if you’re leveraging user states. **Refining Triggers?** * Adjust or add triggers in the Blitzllama dashboard without changing code. **Need advanced integrations?** * Consider setting user attributes, hooking into completion callbacks, or using code triggers for precise control. *** ### Next Steps * **Non-Developers**: Start with the no-code setup, just paste the script and add triggers in the dashboard. * **Developers**: For deeper integration, install via NPM, manage user attributes, set code triggers, and leverage callbacks for advanced behaviors. **Support**: For additional help, reach out via support chat or email `tech@blitzllama.com`. *** ## **WordPress Integration** To integrate Blitzllama into a **WordPress** site, you can use the plugins like [Header Footer Code Manager (HFCM)](https://wordpress.com/plugins/header-footer-code-manager/blitzllamatest.wordpress.com) for a quick and seamless setup. Below we share the steps to integrate using HFCM but the same steps work for other plugins too. 1. **Install and Activate the Plugin** * In the **WordPress Admin Panel**, go to **Plugins** → **Add New**. * Search for **"Header Footer Code Manager"**, install, and activate it. 2. **Add the Blitzllama Script** * Navigate to **HFCM** → Click **Add New**. * Enter a **name** (e.g., Blitzllama Survey Script). * Select **Snippet Type:** **JavaScript**. * Choose **Display Options:** * **Site Display:** "Site Wide" (or specific pages). * **Location:** "Header". * **Paste the Blitzllama script** ([provided at the start of this page](#setup-steps)[ in step 1](#setup-steps)). * Click **Save** to apply the changes. 3. **Configure Triggers in Blitzllama Dashboard** * In the **Blitzllama Dashboard**, go to the **Events** tab. ([more at the start of this page in step 2](#setup-steps)) * **Set up triggers** such as: * **Page URL Trigger:** Display surveys on specific pages. * **CSS Selector Trigger:** Show surveys based on user interactions. Once saved, Blitzllama will be active on your WordPress site, displaying surveys as per your configured triggers. # React Native ## Overview The Blitzllama React Native SDK allows you to embed short in-app surveys directly into your React Native application (on both Android and iOS). By integrating the SDK, you can collect real-time user feedback at key points in the user’s journey. #### Key Features: * Quickly display micro-surveys using triggers you define. * Ensure unique user identification to avoid repeated surveys. * Add optional user attributes and event properties for better targeting. * Localize surveys by specifying language codes. #### Requirements: * Android API level 21 (Android 5.0) or higher for Android. * iOS 11 and above for iOS. * Access to the Blitzllama dashboard to retrieve your `API Key` and manage triggers. ## Getting Started ### Before You Begin **Obtain Your API Key:** * Log in to the Blitzllama dashboard. * Navigate to the **Connections** tab. * Select **React Native** and find your `api_key`. **Confirm Minimum Requirements:**\ For Android, ensure that your minimum SDK version is at least 21. For iOS and React Native setup, confirm that your environment meets standard React Native requirements. ## Quick Start (About 15 Minutes) ### 1. Install the SDK Install the Blitzllama React Native package and necessary dependencies. Replace `api_key` with your workspace’s API\_KEY. {% tabs %} {% tab title="NPM" %} ```javascript //dependency package needed npm install @react-native-async-storage/async-storage @react-native-community/checkbox react-native-webview npm install react-native-blitzllama@1.5.0 ``` {% endtab %} {% tab title="Yarn" %} ```javascript yarn add @react-native-async-storage/async-storage @react-native-community/checkbox react-native-webview yarn add react-native-blitzllama@1.5.0 ``` {% endtab %} {% endtabs %} ### 2. Initialize the SDK Initialize the Blitzllama SDK as early as possible in your app—ideally in your main application file. ```javascript import { blitz } from 'react-native-blitzllama'; //initialize blitzllama SDK. Place this as higher in your app as possible blitz.init(api_key); ``` You can find your `api_key` on the Blitzllama dashboard under **Connections > React Native**. ### 3. Create a User Before launching any survey, ensure that a unique user is created. The `user_id` should be unique and a string. {% tabs %} {% tab title="NPM" %} ```javascript blitz.createUser('user_id'); ``` {% endtab %} {% endtabs %} **Why Create a User?**\ This ensures consistent survey experiences and avoids repeated surveying of the same individual. If switching projects or user contexts, call `blitz.logout()` to clear stored data. ### 4. Trigger a Survey Use triggers to display surveys at critical moments in your application. Set `showSurvey` to `true` when you want to present the survey and provide a `trigger_name` that matches one configured in the dashboard. {% tabs %} {% tab title="NPM" %} ```javascript const [show, setShow] = React.useState(false); setShow(false)} /> ``` {% endtab %} {% endtabs %} Once the user completes or dismisses the survey, the `closeSurvey` callback is executed to hide it. You’re now ready to collect targeted user feedback with Blitzllama's in-app surveys! 🚀 Read further to check other capabilities of Blitzllama and customize to your requirement. *** ## Triggers and Trigger Properties **What are Triggers?**\ Triggers are events defined in your app that determine when a survey should display. They are managed and configured in the Blitzllama dashboard. **Attaching Trigger Properties (Optional):**\ Pass additional properties with a trigger to refine targeting. ```tsx ``` You can use these properties to more filter users in the survey, as shown in the below screenshot. ![](/files/yFfwVi3cufc0xRrZDJHA) {% hint style="success" %} You can also use **backend events** to launch in-app surveys. Check out for more details. {% endhint %} ## Personalizing and Localizing Surveys ### Setting User Attributes You can provide Blitzllama with additional user information. This helps with refining targeting and personalizing the survey experience. **Set a Single Attribute:** {% tabs %} {% tab title="NPM" %} ```javascript blitz.setUserAttribute('attribute_name','attribute_value', 'data_type'); //Allowed values for data_type are "string", "number", "date", "boolean". ``` {% endtab %} {% endtabs %} **Set Multiple Attributes at Once:** {% tabs %} {% tab title="NPM" %} ```javascript blitz.setUserProperties({'property_name': 'value', age: 25, place: 'chennai'}); ``` {% endtab %} {% endtabs %} **Set User Email and Name (Optional):** {% tabs %} {% tab title="NPM" %} ```javascript blitz.setUserEmail('user_email'); blitz.setUserName('user_name'); ``` {% endtab %} {% endtabs %} ### Setting Survey Language You can provide Blitzllama with the language you wish to survey your user. It is not mandatory to launch surveys. Language code should be in [ISO 639-1 codes](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes). {% tabs %} {% tab title="NPM" %} ```javascript blitz.setSurveyLanguage('language_code'); ``` {% endtab %} {% endtabs %} ## User Management #### Logout If you need to reset user tracking, for example when a user logs out of your app, call: {% tabs %} {% tab title="NPM" %} ```javascript blitz.logout(); ``` {% endtab %} {% endtabs %} This ensures subsequent surveys are not tied to the previous user’s data. ## Advanced Usage and Best Practices ### Survey Completion Callback Blitzllama can notify you when a survey completes, allowing you to trigger app-specific logic. {% tabs %} {% tab title="NPM" %} ```javascript blitz.subscribeEvent('survey_completed',(data) => { // data is an array of question/response objects //add you custom logic here }); ``` {% endtab %} {% endtabs %} Sample Data Format: ```json [{ question_order: 1, question_text: "How well do you expect Blitz Demo to meet your needs?", question_type: "single_select_feedback", response: ['One'] //array value for select questions & string for other question types }, ...] ``` ### Survey Display Event You can also subscribe to survey display events: {% tabs %} {% tab title="NPM" %} ```javascript blitz.subscribeEvent('survey_displayed',(data) => { console.log('data', data); //{trigger: triggerName, can_display_survey: false | true} }); ``` {% endtab %} {% endtabs %} ### Custom Fonts Customize your survey’s look and feel by specifying custom fonts: {% tabs %} {% tab title="NPM" %} ```javascript import { blitz } from 'react-native-blitzllama'; blitz.setCustomFont('regular_font_family', 'bold_font_family'); ``` {% endtab %} {% endtabs %} ### Initializing Blitzllama Early Make sure `blitz.init()` runs before mounting components that might trigger surveys. Ideally, run it in your main entry file (`App.js` or similar). {% tabs %} {% tab title="App.jsx" %} ```javascript import { blitz } from 'react-native-blitzllama'; const blitzSetup = async() => { await blitz.init('api_key'); // call createUser once in the app’s lifetime for each unique user await blitz.createUser('user_id'); // optionally set user attribute or set survey language here }; // Call blitzSetup() at a high point in the app lifecycle. // Ensure blitzSetup() loads before a component is mounted. ``` {% endtab %} {% tab title="Component.jsx" %} ```javascript import Blitzllama from 'react-native-blitzllama'; const [show, setShow] = React.useState(false); setShow(false)}/> ``` {% endtab %} {% endtabs %} ### Performance Impact The Blitzllama React Native SDK is designed to have a minimal footprint. Calls are asynchronous, so app performance is generally not affected. Surveys will briefly increase CPU usage when displayed, but the effect is negligible. ## FAQ & Troubleshooting **Survey not showing up?** * Verify that `blitz.createUser()` was called before showing the survey. * Confirm that the trigger name used in your code matches exactly with the one configured on the Blitzllama dashboard. **Survey not appearing on initial load?**\ This could be a timing issue. Make sure `blitz.init()` and `blitz.createUser()` are called early. If needed, you can trigger events only after the user creation callback completes. **Switching Users?**\ If you need to track a different user, call `blitz.logout()` before creating a new one. **Need more assistance?**\ Contact support via chat or email at . ## Next Steps * Add a few triggers for critical actions within your app. * Create and customize your first survey on the Blitzllama dashboard. * Personalize the survey experience by adding attributes, setting languages, and customizing fonts. # Flutter ## **Overview** The Blitzllama Flutter SDK allows you to deliver in-app surveys seamlessly within your Flutter application. By integrating the SDK, you can collect targeted user feedback during critical moments in the user journey. **Key Features** * Quickly embed surveys via configurable triggers. * Identify and track users to avoid duplicate surveys. * Personalize surveys using user attributes and event properties (optional). * Localize surveys by setting preferred languages (optional). **Requirements** * Access to the Blitzllama dashboard for API key retrieval and trigger configuration. *** ## Getting Started ### **Before You Begin** 1. **Obtain Your API Key:** Log in to the Blitzllama dashboard, navigate to the **Connections** tab, select **Flutter**, and retrieve your API key. 2. **Confirm Compatibility:** Ensure your Flutter project is set up and running. ### Quick Start (10 Minutes) 1. Open your `pubspec.yaml` file and add the following dependency: ```yaml dependencies: blitzllama_flutter: ^0.6.3 ``` 2. Run the command: ```bash flutter pub get ``` 3. Import Blitzllama in your Dart code: ```dart import 'package:blitzllama_flutter/blitzllama_flutter.dart'; ``` 4. Initialize the SDK: Add the initialization code in the file where Blitzllama functions will be invoked: ```dart BlitzllamaFlutter.init(""); ``` If you face issues with iOS builds, add the following to your `Podfile`: ```ruby target 'Runner' do use_frameworks! pod 'SwiftyJSON' flutter_install_all_ios_pods File.dirname(File.realpath(__FILE__)) end ``` {% hint style="info" %} Check [**pub.dev**](https://pub.dev/packages/blitzllama_flutter) for usages and examples. {% endhint %} ## Managing Users 1. **Create a User:** Create a unique user ID to ensure consistency and avoid multiple surveys for the same user ```swift BlitzllamaFlutter.createUser(user_id); ``` 2. **Update User Email (Optional):** You can associate an email address with the user ```swift BlitzllamaFlutter.setUserEmail(email) ``` 3. **Update User Name (Optional):** Personalize surveys by associating a user name ```swift BlitzllamaFlutter.setUserName(username) ``` 4. **Set User Attributes (Optional):** Add user attributes for targeting specific cohorts ```swift BlitzllamaFlutter.setUserAttribute(attribute, attributeValue, dataType); ``` Allowed data\_type values are "string", "number", "date", and "boolean". 5. **Set Survey Language (Optional):** Define the preferred survey language in [ISO 639-1 codes](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes). ```swift BlitzllamaFlutter.setSurveyLanguage("en"); ``` 6. **Logout User (Optional):** Clear the user session by calling ```swift BlitzllamaFlutter.logout(); ``` ## Adding Triggers 1. **Triggering a Survey:** Add triggers to initiate surveys at key moments (e.g., button press or page load) ```swift BlitzllamaFlutter.triggerEvent(triggerName); ``` 2. **Adding Event Properties (Optional):** Attach properties to a trigger for advanced targeting. You can pass a map of key-value pairs as properties. For example: ```swift BlitzllamaFlutter.triggerEvent(triggerName, eventProperties); //In below example, the event HomeActivity is triggered with the properties age and name. BlitzllamaFlutter.triggerEvent("HomeActivity", {"age": 10, "name": "John"}); ``` These properties help segment and target users based on context, and they can be configured in the Blitzllama dashboard. ![](https://documentation.blitzllama.com/~gitbook/image?url=https%3A%2F%2F713176431-files.gitbook.io%2F%7E%2Ffiles%2Fv0%2Fb%2Fgitbook-x-prod.appspot.com%2Fo%2Fspaces%252F-MagfF5JPg-8vm99iTd9%252Fuploads%252FJFVinyFxj3YupHRvgZJB%252Fimage.png%3Falt%3Dmedia%26token%3D983225e2-fa1b-4476-8788-72016865f05c\&width=300\&dpr=4\&quality=100\&sign=d8aaa2de\&sv=1) ## Advanced Usage and Best Practices ### Custom Fonts Customize your survey’s look and feel by specifying custom fonts: ```dart BlitzllamaFlutter.setCustomFont("Roboto-Regular", "Roboto-Bold"); ``` If the survey widget does not automatically apply the default font, use the method above to ensure the correct font is set. ## FAQ & Troubleshooting 1. **Survey not showing up?** 1. Ensure `createUser` is called before `triggerEvent`. 2. Verify that the event name matches the Blitzllama dashboard configuration. 2. **Survey not appearing on app launch?** 1. Add a callback to the `createUser` function to handle potential race conditions: ```dart BlitzllamaFlutter.createUser(user_id, onSuccess: () { BlitzllamaFlutter.triggerEvent("trigger_name"); }); ``` 3. **Switching users?** 1. Call `logout()` before creating a new user. 4. **How to create triggers?** 1. Add a new `trigger_name` in your app; it will automatically sync with the Blitzllama dashboard. 2. Alternatively, configure the trigger in the Blitzllama dashboard first, then use it in your app. ## Next Steps 1. Start by adding triggers for the top 5 critical user actions in your app. 2. Create your first survey on the Blitzllama dashboard. 3. Customize the survey UI/UX on the dashboard to align with your brand. For additional support, reach out via support chat or email at . # Google Tag Manager Google Tag Manager (GTM) provides an easy way to add tags and triggers. It requires little to no coding to setup Blitzllama and can be deployed in minutes. Once [`Blitzllama Tag`](https://tagmanager.google.com/gallery/#/owners/Blitzllama/templates/blitzllama-gtm-tag) is integrated with GTM you will be able to create users, add user attributes and launch surveys. ### Installing Blitzllama tag with GTM ### Step 1: Initialise Bltizllama Tag * Open the Google Tag Manager app and click on **Tags** Tab. * Click on **new** Tag and click on Tag Configuration section. Under the "**Discover more tag types in the Community Template Gallery**" option search for [`Blitzllama Tag`](https://tagmanager.google.com/gallery/#/owners/Blitzllama/templates/blitzllama-gtm-tag) * Click on Choose Template to add **Blitzllama Tag** to your GTM. * Copy API\_KEY from `Connections > Web` on the Blitzllama dashboard. * Under API key section in Blitzllama GTM template paste the copied API\_KEY.
### Step 2: Manage users There are two ways to manage users, you can either assign a unique user\_id to each user or keep the users anonymous. a. Identify users with user\_ids (recommended) * Make sure to set **Action Type** to **User Id**. * Click on ![plus](https://files.readme.io/f63db7a-brickplus.png), and choose the variable you would wish to use as UserId. Read more about the * Now click on **Triggering** Section, to choose the trigger. * Select **All Pages** (recommended) or on **Some Pages** as the Trigger. * Click on **save** button to save the changes to Blitzllama Tag. * Click **Submit** and then **Publish** to push your changes.
{% hint style="info" %} Read more about the variables here [GTM variables](https://support.google.com/tagmanager/answer/7683056) and triggers here [Triggering Section](https://support.google.com/tagmanager/answer/7679316). {% endhint %} b. Users are not assigned user\_ids but are anonymously surveyed * Make sure to set **Action Type** to **Install.** * Now click on **Triggering** Section, to choose the trigger. * Select **All Pages** as the Trigger. * Click on **save** button to save the changes to Blitzllama Tag. * Click **Submit** and then **Publish** to push your changes.
### Step 3: Send User Attribute to Blitzllama (optional) Adding user attributes will help in understanding user and creating cohorts for targeted surveys. * Set **Action Type** to **User Attribute**. * In **Attribute Key** text field, enter the user attribute field name you wish to send to Blitzllama. * In **Attribute Value** field, click on ![plus](https://files.readme.io/f63db7a-brickplus.png), and choose the variable you would want. * In **Data Type** drop-down, select apt data type (string, number, boolean, date) of the **Attribute Value** variable**.** * Now click on **Triggering** Section, to choose the trigger. * Select on appropriate pages or click actions (ensure the attribute value will be available when the tag is fired) as the Trigger. * Click on **save** button to save the changes to Blitzllama Tag. * Click **Submit** and then **Publish** to push your changes.
{% hint style="danger" %} Ensure user creation Blitzllama Tag is called before User Attribute Tag. Click here to read more on [**Trigger Sequencing**](https://support.google.com/tagmanager/answer/6238868). {% endhint %} ### Step 4: Setup survey triggers There are two ways to trigger surveys inside your web application. You can also use backend events to launch in-app surveys. Check out for more details. #### a. Creating triggers on Blitzllama's dashboard Refer to this section: [creating triggers on the web triggers](https://documentation.blitzllama.com/sdk/pages/kSMFdHStwTJv3AB8TTVL#3.-creating-triggers) We suggest creating triggers the above method, instead of triggering surveys via GTM (below section), as it requires a new GTM tag to be created for every trigger. #### b. Trigger Survey based on GTM triggering (optional) * Set **Action Type** to **Trigger Survey**. * In **Trigger Name** text field, enter the Trigger Name that is configured on Blitzllama dashboard. * Now click on **Triggering** Section, to choose the trigger. * Select **All Pages** as the Trigger. * Click on **save** button to save the changes to Blitzllama Tag. * Click **Submit** and then **Publish** to push your changes. {% hint style="success" %} You can also use **backend events** to launch in-app surveys. Check out for more details. {% endhint %} You are all set to launch your first Blitzllama survey using GTM! ### **DataLayer** A data layer is a JavaScript object that is used to pass information from your website to your Tag Manager container. You can then use that information to populate variables and activate triggers in your tag configurations. [Click here to read more on DataLayer](https://support.google.com/tagmanager/answer/6164391?hl=en) ```javascript ``` **Setting GTM variables to set to DataLayer variable** * In Google Tag Manager, click **Variables**. Under **User-Defined Variables,** click on **New** Button**.** * Enter the appropriate variable name. * Under **Variable Configuration**, click on choose the variable type and select **Data Layer Variable** option. * In **Data Layer Variable Name** text field, enter data Layer variable you want set as variable. * Click **Save**. # Links ## Overview Blitzllama’s Link Surveys enable fast, flexible, and data-rich feedback collection with zero code integration. Share surveys via links in emails, in-app banners, or landing pages, and quickly gather insights to inform product decisions. ### Why Use Blitzllama Link Surveys? * **Rapid Deployment:** Launch surveys in under a minute from pre-built templates. * **Deep Insights:** Multiple question types, conditional flows, and multi-language support help you gather context-rich feedback. * **Data Integrity:** Tie responses to unique user IDs, prevent duplicates, and auto-fill initial responses for better data quality. * **Brand Alignment:** Customize URLs, visuals, and messaging to match your brand. * **Secure & Integrated:** Encrypt user data and seamlessly integrate with tools like Intercom, Zendesk, Mailmodo, Pendo, and Clevertap. * **Real-Time Analytics:** Monitor results as they come in, use AI-powered categorization, and build shareable dashboards for cross-team collaboration. ## Quick Start Guide 1. **Select a Template:** Choose from ready-made templates targeting common product use cases. 2. **Generate Your Survey Link:** Blitzllama provides a unique survey URL on launching the survey. 3. **Share the Survey:** Distribute via email, in-app messages, or embed in a webpage banner. 4. **Collect Responses:** Gather feedback without coding or complex integration. 5. **Analyze Results:** View instant charts, categorize open-text responses automatically, and generate insights on the fly. **Example Link:** ``` https://link.blitzllama.com/survey123 ``` ## Core Configuration Options ### 1. Adding a User ID Attach a `user_id` query parameter to attribute responses to individual users. This ensures that the feedback can be correlated with user behavior or demographics later. **Format:** ```javascript https://link.blitzllama.com/?lang=en&user_id= ``` * **Allowed Characters:** Numbers, letters, hyphens, and underscores. * **Default:** If no `user_id` is provided, an anonymous ID is auto-generated. ### 2. Auto-Filling the First Response Use the `q1` parameter to prepopulate the first answer, improving the user experience and increasing completion rates. **Format:** ```javascript https://link.blitzllama.com/?lang=en&q1= ``` **Supported Response Formats:** | Question Type | Allowed Values | Example | | ----------------------- | ------------------------------ | -------------------- | | Opinion Scale (1–5) | `1` to `5` | `q1=4` | | Star/Emoji Rating (1–5) | `1` to `5` | `q1=5` | | NPS (0–10) | `0` to `10` | `q1=9` | | Single-Select (MCQ) | Option text | `q1=OptionA` | | Multi-Select (MCQ) | Comma-separated options | `q1=Option1,Option2` | | Text Input | String (no special characters) | `q1=feedback_text` | ## Creating Adaptive and Inclusive Surveys ### 1. Conditional Flows Create branching logic to adapt questions based on previous answers. This ensures more relevant and engaging surveys.
### 2. Multi-Language Support Offer surveys in users’ preferred languages by adding a `lang` parameter. Set the survey language using an [ISO 639-1 codes](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) (e.g., `"en"` for English). We support 30+ languages. ``` https://link.blitzllama.com/survey123?lang=es ``` ### 3. Embedding Surveys Place survey links in: * Email campaigns * In-app banners * Website pop-ups or dynamic sections * Chat support tools This integrates feedback collection seamlessly into your existing user flows. ## Customizing the Survey Experience ### 1. Brand-Aligned UI/UX Customize survey fonts, colors, and design elements to match your brand’s look and feel. Blitzllama’s responsive design ensures a seamless experience across mobile and desktop, enhancing user trust and participation.
### **2. Branded URLs and Logos** Use custom URLs and integrate your logo to reinforce brand trust and recognition, assuring users their feedback is securely reaching your company. ``` https://feedback.acme.com/feature-survey?user_id=u-54321 ``` ### **3. Automatic Progress Saving** Surveys automatically save progress, allowing users to resume later without losing their input. This reduces drop-offs and encourages more detailed responses. ## Integrations and Automation Blitzllama integrates with popular support and messaging tools, enabling you to trigger surveys based on user actions or support interactions: * **Support Tools:** Intercom, Zendesk, Freshdesk, etc. * **Messaging Tools:** Mailmodo, Pendo, Clevertap, MoEngage, etc. For example, automatically send a survey link after a support ticket is closed or a new feature is released. ## Analyzing Results and Generating Insights * **Real-Time Dashboards:** Monitor results as they come in with instant charts and graphs.
* **Shareable Reports:** Create custom dashboards and share them with stakeholders.
* **AI-Driven Categorization:** Automatically categorize open-text responses into meaningful themes.
* **Trend & Pattern Detection:** Use advanced data mining to identify hidden patterns, sentiment, and opportunities for improvement.
## Need Assistance? Contact our support team at **** or via our Support Chat. Blitzllama Link Surveys let you gather targeted, high-quality feedback with minimal effort, enabling product and support teams to make data-driven decisions quickly and confidently. # API To push your survey responses from other tools like Intercom and Verloop to Blitzllama, you'll need to follow these steps to get survey configurations and push user response data. ### **Authentication** **You'll need specific credentials to authenticate your requests:** 1. Log in to your Blitzllama dashboard. 2. Navigate to the Connections tab to find the necessary credentials. **Setting Up the Integration** 1. In your Blitzllama account, go to the Connections tab. 2. Select Export API and then click on Enable. 3. Copy the Blitzllama API Key. This key will be used as the Authorization header \[x-api-key] in your API requests. **API Request Details** 1. Base URL: ; Use this URL to send API requests, ensuring to include the copied API Key in the header for authentication. ### **Create New Survey** 1. Go to Research tab and create a new survey or use an existing survey template. 2. The question type and question order should match with the survey in the other tool. \ [Example: If you ask "Please rate your conversation" (rating of 1 to 5) and "What could we improve?" (open text question) after closing the Intercom conversation, you need to have the same questions on Blitzllama's survey too.](#user-content-fn-1)[^1] 3. Navigate to the Configuration tab and choose API as the platform. 4. Launch the survey. ### **Survey Config API** ```typescript //You can fetch the above created survey via this API. GET "/survey/:survey_id/config" { "data": { "survey": { "survey_name": "Testing Template", "created_at": "2024-04-24T17:41:43.466Z", "survey_id": "s-id value" }, "questions": [ { "properties": { "labels": { "left": "left label value", "right": "right label value" }, "randomize": "in_set", "options": [] }, "question_text": "Your first question!", "question_desc": "Tip1: You can change the colors of this widget from the Setting tab.", "question_order": 1, "question_type": "scale_feedback" }, ... ] } } ``` #### **Question Type Values** ```typescript Select Based Questions 'multi_select_feedback' 'single_select_feedback' Range-Based Question [0-10] 'nps_feedback' Range-Based Question [1-5] 'scale_feedback' 'star_feedback' 'emoji_feedback' Text-Based Question 'input_feedback' 'data_collection' Click-Based Question 'intro_prompt' ``` ### **User Response** ```json POST "/survey/:survey_id/response" { "user_id": "user_id", //string "group_id": "g-id", // id to indentify a individual user response collection. "question_order": 1, //int value "user_response": "Great" // user response with data type number/string/array } ``` ``` User Response Datatype number - Range [1 - 5] rating scale, star, emoji responses Eg. "user_response": 1 number - Range [0 - 10] NPS responses Eg. "user_response": 10 text-- text-based questions Eg. "user_response": "Great" array -- select based questions Eg. "user_response": ["Option A", "Option B"] ``` {% hint style="warning" %} ``` group_id has to be unique for each survey user response collection. Don't duplicate any user response.This has to be generated from the client side (preferably uuid string). ``` {% endhint %} [^1]: # Mixpanel Product Analytics Seamlessly export user cohorts from Mixpanel to Blitzllama for better-targeted micro surveys. We do this using Mixpanel's Cohort Sync feature, which enables one-click cohort exports to Blitzllama. ### Supported Capabilities Mixpanel integration enables the following capabilities: * Import Mixpanel cohorts via one-time export and dynamic sync * These cohorts can be used in Blitzllama for launching micro surveys to the right users ### Setting up the Mixpanel integration A common identifier `blitzllama_user_id` is used to match users between Mixpanel and Blitzllama. You will need to ensure that `blitzllama_user_id` user property is declared on Mixpanel user profiles so they can be joined with Blitzllama's user data. This can be achieved by declaring the `blitzllama_user_id` in the Mixpanel tracking code: {% tabs %} {% tab title="Android" %} ```kotlin //Sets user attribute "blitzllama_user_id" to "123" mixpanel.people.set("blitzllama_user_id", "123" ); ``` {% endtab %} {% tab title="iOS" %} ```swift Mixpanel.mainInstance().people.set(properties: [ "blitzllama_user_id":"Premium"]) ``` {% endtab %} {% tab title="Javascript" %} ```javascript //Sets user attribute "blitzllama_user_id" to "123" mixpanel.people.set("blitzllama_user_id", "123" ); ``` {% endtab %} {% endtabs %} ### Enable Blitzllama integration on Mixpanel's dashboard 1. Click the icon in the top navigation bar and then select **Integrations**. ![](/files/iZHwcqkKxTfaervMxELk) 2\. Scroll down on the **Integrations** page, find **Custom Webhook,** and click **Connect**. {% hint style="danger" %} Only the Mixpanel project owners and admins will be able to make the connection. {% endhint %} 3\. Go to the Connections tab on Blitzllama's dashboard, search for Mixpanel, and click connect to get the **URL** and **API KEY**. Under **PROPERTIES TO EXPORT** ensure to add `blitzllama_user_id` from the list of properties. ### Export Mixpanel Cohorts to Blitzllama To export a Mixpanel cohort to Blitzllama: 1\. Click **Data Management** at the top of Mixpanel. Navigate to **Cohorts**. 2\. Select the cohort to send to Blitzllama. Select **Export to Blitzllama**. ![](/files/ncRGwVNLyVLVnkZ0R8ee) 3\. Select one of the following sync types and then click Start Sync: **One-time Sync:** In the case of one-time sync, Mixpanel sends a one-time list of users who are currently part of the cohort to Blitzllama. **Dynamic Sync:** In the case of dynamic sync, Mixpanel initiates sync between a cohort and Blitzllama every 30 minutes. The imported segment is updated every 30 minutes to reflect the most recent list of users in the segment. The cohort name defined in the Mixpanel dashboard appears as a cohort under the Cohorts list page of the Blitzllama dashboard.
### Access the Imported Cohort in Blitzllama In order to access the imported cohorts in Blitzllama: 1. Navigate **Cohorts** tab, all the Mixpanel imported cohorts will have the source as Mixpanel. ![](/files/eY1RWW0a6JqyAVEJvSbJ) 2\. Mixpanel's cohorts can be used just like cohorts with the exception that these cohorts cannot be filtered further. {% hint style="info" %} Mixpanel exports only identified users to other partners, such as Blitzllama. When receiving cohorts from Mixpanel, the user identity is matched in the following manner: If the `blitzllama_user_id` is present, it is matched with the identity value of the user present in Blitzllama. If a match is found, the profile becomes part of the cohort. If `blitzllama_user_id` is not present or does not match with a user profile in Blitzllama, the user profile is not created in the cohort. {% endhint %} In case you are stuck at any of the above steps, please don't hesitate to email us at or hit us up on the support chat. # CleverTap Customer Engagement Platform Push your existing user segments from CleverTap with Blitzllama. We do this using Clevertap's Webhook campaigns which takes a few minutes to setup. Syncing cohorts into Blitzllama ensures you learn more about the same set of users. ### Supported Capabilities CleverTap integration enables the following capabilities: * Import CleverTap user segment via one time, multiple dates and recurring campaigns. * These cohorts can then be used in Blitzllama for launching micro surveys to the right users. ### Setting up the CleverTap Webhook Campaign CleverTap has a detailed and frequently updated documentation on creating Webhook campaigns on their dashboard. Please refer to this documentation to set up the cohort sync. When creating a Webhook template on CleverTap dashboard, * Set POST as the `HTTP method` * Get the `Destination URL` from Blitzllama's dashboard (navigate to Connections tab and select CleverTap) * To configure `Header parameters`, set `Key` to "x-api-key" and get the `Value` from Blitzllama's dashboard (navigate to Connections tab and select CleverTap) ![A screenshot of the "create webhook template" dialog on CleverTap dashboard.](/files/XyFJr41q8OvIKnrD721G) ### Identity Property {% hint style="warning" %} Ensure **Email,Identity and CleverTap ID** option is selected in **webhook content.** Blitzllama will not be able to add user without identity property not enabled. {% endhint %} ![](/files/0Sdvwbe3PZ5Eip6u0SSX) ### Use the Synced Cohorts on Blitzllama CleverTap campaigns take upto 30mins to sync to Blitzllama. Once synced you can view all synced cohorts on Blitzllama's Cohorts tab. ![A screenshot of the Cohorts tab on Blitzllama dashboard.](/files/4rL4Q6oWdigT2CmcdO8A) CleverTap's cohorts can be used just like all other cohorts with exception that these cohorts cannot be filtered further. In case you are stuck at any of the above steps, please don't hesitate to email us at or hit us up on the support chat. # Segment Customer Data Platform Connect Segment with Blitzllama to use push user attributes and cohorts from your existing tools to precisely target users through Blitzllama and generate powerful insights. {% hint style="warning" %} Segment integration is in beta. Please reach out to us over the support chat on Blitzllama's dashboard to whitelist your account. {% endhint %} ### Supported Capabilities * We support Segment's Identify and Group calls. * Segment's Identify and Groups calls are the equivalent of attributes and cohorts in Blitzllama. ### Connecting Segment to Blitzllama 1. Navigate to the Destination page inside Segment's Catalog tab. 2. Search for Blitzllama, click on the card to land on the Blitzllama's Catalog page 3. Select the data sources to send to Blitzllama destination 4. Get the API key within Blitzllama's dashboard: navigate to the Connections tab, search for Segment, click on the card to find and copy the API key. ### Data Mapping #### Segment - Identify Every single `traits` in Segment maps to single `Attributes` in Blitzllama. Use `Attributes` to identify users in Blitzllama. An example Identify call will look like this: ``` analytics.identify('97980cfea0067', { city: 'Bangalore', plan: 'premium', name: 'Peter Gibbons', logins: '5', email: 'peter@example.com', }); ``` For more information, refer to Segment Spec documentation - [Identify](https://segment.com/docs/connections/spec/identify/) On Blitzllama's dashboard, the corresponding data can be found in the `Preview` section in the `Cohorts` tab. ![](/files/bk9el7xzYSMon1jqePIm) #### Segment - Group `Group` in Segment map to `Cohorts` in Blitzllama. Use `Groups` to seamlessly sync cohorts to Blitzllama. An example `Group` call will look like this: ``` analytics.group("0e8c78ea9d97a7b8185e8632", { name: "Initech", industry: "Technology", employees: 329, plan: "enterprise", "total billed": 830 }); ``` For more information, refer to Segment Spec documentation - [Groups](https://segment.com/docs/connections/spec/group/) The synced Segment's Groups will be available on the `Cohorts` tab on Blitzllama's dashboard. ![](/files/j4Hazw3xTKP1EtTXDi26) {% hint style="info" %} Blitzllama accepts unlimited user attributes and will auto accept all user traits from Segment's Identify call. {% endhint %} {% hint style="info" %} Blitzllama accepts unlimited user cohorts and will auto accept all user groups from Segment's Group call. {% endhint %} In case you are stuck at any of the above steps, please don't hesitate to email us at or hit us up on the support chat. # Amplitude Cohort Sync & Events Streaming ## Cohort Sync The Cohort Sync integration with Amplitude allows you to launch in-product surveys to specific cohorts you’ve already created in Amplitude. Enabling you to generate highly contextual and actionable insights which help create a deeper understanding of user behaviours. ### **Considerations** Amplitude Cohort Sync is available to all customers on free and paid plans of Blitzllama. ### Setup #### Blitzllama Setup 1. Navigate to **Connections tab** on Blitzllama's dashboard 2. Click on **Amplitude** under **Sources**. 3. Click Connect and copy the **API key**. #### Amplitude Setup 1. In Amplitude Data, click **Catalog** and select the **Destinations** tab. 2. In the Cohort section, click **Blitzllama**. 3. Click **Add another destination**. 4. Enter *Name* and *Blitzllama's API Key*. 5. Save the destination. #### Send a cohort 1. In Amplitude, open the cohort you want to export. 2. Click Sync, and choose Blitzllama. 3. Select the destination. 4. Select the sync cadence. 5. Save when finished. After your cohort is synced, you can find it under Cohorts tab in the Blitzllama's dashboard. Expect updates to reflect within 15 minutes. ## Events Streaming You can use Amplitude events to trigger in-app surveys via Amplitude's Event Stream method, enabling seamless, real-time survey launches based on user actions. ### **Considerations** * **Amplitude Events Stream** integration is only available on Blitzllama's **Scale** plan. ### **Setup** #### **Amplitude Setup** 1. Navigate to Amplitude's dashboard. In **Amplitude Data**, click **Catalog** and select the **Destinations** tab. 2. In the **Event Streaming** section, click **Webhook**. 3. Enter a sync name like **"Blitzllama Events Stream"**, then click **Create Sync**. 4. Toggle **Status** to **Enabled**. #### **Blitzllama Setup** 5\. In Blitzllama, navigate to **Connections** > **Data Import** > **Amplitude**. 6\. Copy both the **Stream URL** and **API Key** from the **Events Streaming** section.
#### **Amplitude Setup (continued)** 7\. Return to the **Webhook** settings in Amplitude and paste the copied Stream URL into the **Webhook URL** field. 8\. In the **Headers** section, add a new header key `authorization` with the value set to the copied **API Key**.
9\. Toggle on **Send Events** to begin sending events. 10\. Keep Amplitude's default payload under the Event Payload section. 11\. Choose the events you want to trigger surveys on—these will be sent to Blitzllama. You can add more events at any time.
### **Launching Surveys with Amplitude Events** 1. In Blitzllama, open the **Survey Editor** and go to the **Configuration** tab. 2. Scroll to the **Select Survey Trigger** section, then choose the Amplitude event you wish to use as a trigger. 3. Surveys are launched after the Amplitude event occurs, so they require a **view trigger** - places in he app where the survey should be displayed - these are Blitzllama event (e.g., **MainActivity** in the screenshot).
For further reference, you can find more details in [Amplitude’s Webhook documentation](https://amplitude.com/docs/data/destination-catalog/webhooks) {% hint style="info" %} For any issues with setup, please write to . {% endhint %} # RudderStack The Blitzllama x RudderStack integration enables you export RudderStack Groups to Blitzllama. This helps to launch targeted surveys and conduct deeper analysis. ## **Configuring RudderStack** ### Blitzllama Dashboard Activate the RudderStack connection on Blitzllama's dashboard. 1. Navigate to Connections tab and scroll to Sources section. 2. Go to the Rudderstack card and click "Connect". 3. Copy the API key. ### RudderStack Dashboard Create a Webhook Destination for sending Group events to Blitzllama. 1. On the Rudderstack's dashboard, navigate to the "Destinations" tab. 2. Click "New Destination" and choose "Webhook" as the destination. 3. Optionally, choose the sources you want to route into this destination. Then, click "Continue". ### Webhook configuration Set up the Webhook. 1. Paste the below URL on the Webhook "Configuration" tab. Make sure the "URL Method" selected is POST. ``` https://events.blitzllama.com/api/v1/connections ``` 2. On headers, add "x-api-key" and paste the API Key copied from Blitzllama's dashboard as Value. Click "Continue".
3. Go to **Transformations** template select **Dynamic Path** and paste the below code. ```javascript export function transformEvent(event, metadata) { const userId = event.userId; // userId property const groupId = event.groupId; // groupId property const groupName = event.traits && event.traits.groupName ? event.traits.groupName : ''; // groupName property if (userId && groupId){ event.appendPath = `/rudderstack/hook?userId=${userId}&groupId=${groupId}&groupName=${groupName}`;} // Change property and appendPath else { return; } return event; } ``` 4. Click "**Continue**" to finalize the RudderStack destination. ## Syncing Groups to Blitzllama Your synced RudderStack groups will show up on Blitzllama's Cohort tab. You can use these cohorts inside your surveys for better targeting. # Backend Triggers Use backend events to trigger surveys inside your mobile app and website. Additional properties can be passed with the backend events to add more context to users' responses. ### Setting up the Backend Trigger * Navigate to Connections Tab > Backend Trigger on Blitzllama's dashboard * Click on the Backend Trigger card and then click 'Enable'. * Copy the URL :link:(send backend trigger events on this URL) & the unique API Key 🔑 (add in the API header \[x-api-key]). #### API call ```javascript var request = require('request'); var options = { 'method': 'POST', 'url': 'https://events.blitzllama.com/api/v1/connections/backend/event', //copied url 'headers': { 'x-api-key': '', 'Content-Type': 'application/json' }, body: JSON.stringify({ "user_id":"user_123", "event_name":"item_added_to_cart", "properties": { "id": 1, "name": "War and Peace", "author": "Leo Tolstoy", "type": "hardcover", "category": "novel" } }) }; request(options, function (error, response) { if (error) throw new Error(error); console.log(response.body); }); ``` {% hint style="info" %} **event\_name** - this is the name of the backend trigger, which will show up in the Trigger tab on Blitzllama's dashboard after the first successful API. **user\_id** - the unique user identifier. **properties** - JSON object that will be added to each survey responses. {% endhint %} **Sample payload** ```json { "user_id":"user_123", "event_name":"item_added_to_cart", "properties": { "id": 1, "name": "War and Peace", "author": "Leo Tolstoy", "type": "hardcover", ... "category": "novel" } } ``` ### ### **How to trigger an in-app survey using Backend Trigger** * In the survey editor navigate to "Configure & Launch" > "Select trigger" section * Click on "Activate with backend event" option * Choose the backend triggers (all your backend triggers will be populated in the dropdown) * Add event expiration time (max 100 hours). This allows you maintain relevancy of the survey questions. * Lastly, choose where the surveys should show up on your app or website by selecting the frontend triggers from the "Select Trigger" dropdown.

In the above screenshot of a Sleep Tracking app, a sleep quality monitoring survey will be shown to the users within 2 hours of them ending their sleep ("ended sleep" event) on the app's homepage ("MainActivity" frontend trigger).

# Hightouch Hightouch operates as a Data Activation platform, sitting directly atop your data warehouse and synchronizing data to over 150 destinations. The platform’s HTTP Request destination allows seamless integration with virtually any API - no coding required. ## Benefits Blitzllama x Hightouch integration enables the launch of Blitzllama surveys through Hightouch events. Leveraging Hightouch events makes it easy to personalize and target surveys to the right users at the right moments. This allows merging of quantitative and qualitative data and generates unique experiential insights. Here are a few practical applications: * Assessing user experience post-onboarding * Identifying opportunities for feature improvement immediately after a feature is used * Conducting NPS 30 days post user’s upgrade to a premium plan * Gaining real-time insights into why a user abandoned a product journey ## Setting Up The [HTTP Request documentation](https://hightouch.com/docs/destinations/http-request) provided by Hightouch is easy and simple to follow. Here additional details are provided for locating the relevant Blitzllama information. ### **Create a new destination** 1. Go to the Hightouch's Destinations overview page and click the Add Destination button. Select HTTP Request and click Continue. 2. Next, the UI prompts you to enter a base URL, HTTP headers, and certificate. Only the base URL is required, which is . 3. Click on Add Key button. Put "x-api-key" in the key and "\" in value. 1. You can find your "\" on Blitzllama's dashboard by navigating to Blitzllama's Connection > Backend Trigger > Connect Source. ### **Sync configuration** 1. Choose request triggers on depending on whether a row is added, changed, and/or removed. Blitzllama uses the same API for all request trigger methods. 2. You can send a single row or batch of multiple rows (batch is preferable) in each HTTP request. 3. Specify webhook endpoint as POST. 4. Customize request payload with JSON. Edit with the JSON Editor. Below is a sample payload and a corresponding Liquid template. Blitzllama expects a JSON payload like below. ```json { "user_id":"user_123", //mandatory "event_name":"subscription_success", //mandatory. You can freely customise the name. Keep it unique and easy to identify. "properties": { "plan": "Premium 12 months", "start_date": "2023-09-11", "count": "2", "platform": "Web" } } ``` The Liquid template you enter under **Define JSON payload** should look like this: ```liquid { "user_id": "{{row.user_id}}", "event_name":"subscription_success", "properties": { "plan": "{{row.plan_name}}", "start_date": "{{row.start_date}}", "count": "{{row.count}}", "platform": "{{row.platform}}" } } ``` 5. Configure rate limiting and concurrency as per your preference. 6. Configure error handling as per your preference. 7. Configure initial sync behavior. Choose "No, skip existing rows". As Blitzllama won't trigger surveys for past events. ## Validating your setup * **Locating Synced Events**: The events synced from Hightouch should be visible under the “Events” tab in Blitzllama, categorized as “Backend Event.”

Synced Hightouch events on Blitzllama's Events tab.

* **Utilizing the Events**: The synced backend events can be utilized as survey triggers. To do this, navigate to the “Configuration” tab of a survey. For more detailed instructions, [read more here](https://documentation.blitzllama.com/connections-sources/backend-triggers).

In the above screenshot of a Sleep Tracking app, a sleep quality monitoring survey will be shown to the users within 2 hours of them ending their sleep ("ended sleep" event) on the app's homepage ("MainActivity" frontend trigger).

* **Using Event Properties**: The properties of these events are displayed with each response and can be leveraged to personalize the survey questions. For more information on utilizing event properties, [read more here](https://documentation.blitzllama.com/best-practices/personalization).

Event properties are displayed with each user response.

Personalize question texts with event properties.

# Amplitude Event Stream Events streaming integration with Amplitude enables you to seamlessly stream feedback data from Blitzllama to Amplitude to further analyse the feedback data with user attributes or to create feedback dashboards. ## Considerations 1. You must enable this integration in each Amplitude project you want to use it in. 2. Amplitude matches the `user_id` to the id within Blitzllama to associated events. If user with that ID doesn't exist in Blitzllama, then Blitzllama creates one. Make sure that the Amplitude `user_id` field matches the Blitzllama id field to avoid user duplication. ## Setup ### Amplitude Setup 1. Log in to Amplitude, go to **Settings** 2. Under **Organization Settings**, click **Project** and navigate to project that you'd like to integrate with Blitzllama. 3. **Copy API key.** ### Blitzllama Setup 1. On the Blitzllama's dashboard, navigate to **Destinations** under the **Connections tab** and click on Amplitude. 2. Click **Connect** and paste the API Key into the textbox. 3. Click **Save**. The payload contains the answer data sent on submission of an answer by a user. A sample payload is below. ```json { "user_id":"user_123", "app_key":"blitzllama_api_key", "survey_id":"s-xxxxxx-id", "group_id":"g-xxxxxx-id", "question_id":"q-xxxxxx-id", "platform":"android", "trigger":"home-page-trigger", "question_order":1, "response":"image upload glitches", "question_text":"What do you think of our app?", "question_type":"input_feedback", "created_at":"2022-05-13T13:40:33+00:00" } ``` # CleverTap [CleverTap](https://clevertap.com/) is a customer engagement and retention platform that provides the functionality to integrate app analytics and marketing. With CleverTap as a destination, you can seamlessly send your Blitzllama's responses data to CleverTap. Configure the following steps to add CleverTap as a destination: 1. Log into your [CleverTap Account](https://eu1.dashboard.clevertap.com/login.html) and click **Settings** on the dashboard.
CleverTap Dashboard Settings

CleverTap Dashboard Settings

3. Click **Project**. Copy the `Project ID` and `Passcode`. We will need this information in the next step.
View Project Credentials

View Project Credentials

{% hint style="info" %} **CleverTap Account ID**: CleverTap service account ID. **CleverTap Passcode:** CleverTap passcode secret associated with your service account. {% endhint %} 4. Log in to your Blitzllama account and go to your **Connections** page. Navigate to CleverTap Destination option and click **Enable.** 5. Paste the `Project ID` and `Passcode` to Account ID and Passcode fields respectively and click on Save. ### **Data Fields** Here is a sample data that will be sent from Blitzllama to **CleverTap Destination**. ```json { "time": 1681336135142, "distinct_id":"user_123", "$insert_id":"0af2aeb8-f561-446d-84ed-5810dd01c7f9", "user_id":"user_123", "app_key":"blitzllama_api_key", "survey_id":"s-xxxxxx-id", "group_id":"g-xxxxxx-id", "question_id":"q-xxxxxx-id", "platform":"android", "trigger":"home-page-trigger", "question_order":1, "response":"image upload glitches", "question_text":"What do you think of our app?", "question_type":"input_feedback", "created_at":"2022-05-13T13:40:33+00:00" } ``` {% hint style="info" %} For details on the data format [click here](https://developer.clevertap.com/docs/upload-events-api). {% endhint %} # Mixpanel [Mixpanel](https://mixpanel.com/) is a powerful, self-serve product analytics solution for your web and mobile apps. By analyzing the actions your users perform, you can unlock valuable customer insights to drive retention, engagement, and conversion. Blitzllama supports Mixpanel as a destination where you can seamlessly send your event data. To configure Mixpanel as a destination and start sending events from Blitzllama, follow these steps: 1. Log in to your Blitzllama account and go to your **connections** page. From there, click on the Mixpanel Destination option. 2. Create a **Service Account** in the Mixpanel settings section. {% hint style="info" %} **Service Account Username**: Mixpanel service account username. **Service Account Secret:** Enter the secret associated with your service account. **Project ID**: Mixpanel project ID which is available under Project Settings. To set up your Mixpanel service account and get the username and secret, refer to this [Mixpanel Help Center ](https://help.mixpanel.com/hc/en-us/articles/115004490503-Project-Settings#viewing-project-details)page. {% endhint %} 3. Click on Save Button to save all Mixpanel account details. ### **Data Fields** Here is a sample data that will be sent from Blitzllama to **Mixpanel Destination** for your destination integrations. ```json { "time": 1681336135142, "distinct_id":"user_123", "$insert_id":"0af2aeb8-f561-446d-84ed-5810dd01c7f9", "user_id":"user_123", "app_key":"blitzllama_api_key", "survey_id":"s-xxxxxx-id", "group_id":"g-xxxxxx-id", "question_id":"q-xxxxxx-id", "platform":"android", "trigger":"home-page-trigger", "question_order":1, "response":"image upload glitches", "question_text":"What do you think of our app?", "question_type":"input_feedback", "created_at":"2022-05-13T13:40:33+00:00" } ``` {% hint style="info" %} For details on the data format [click here](https://developer.mixpanel.com/reference/track-event). {% endhint %} # Segment Streams Push response data from Blitzllama to Segment. Using Segment Streams, Blitzllama can push all response data to Segment. Enabling you to sync Blitzllama's feedback data across your product and data tools. ### Requirements Before connecting Blitzllama with Segment Streams, you'll need to make sure you have the following: * A Blitzllama account * A Segment account with access to the Streams feature ### Integration Steps To connect Blitzllama with Segment Stream, follow these steps: **Segment Dashboard** 1. Log in to your Segment account. 2. Click on the "**Sources**" tab in the left-hand menu and then add **HTTP API** as a source, after entering the Name and Labels info. 3. Copy the Segment HTTP API key to your clipboard or store it in a secure location. **Blitzllama Dashboard** 1. Log in to your Blitzllama account and navigate to the "Connections" section. 2. Click on "Segment Stream" from the list of available integrations and click on **Enable**. 3. Paste the Segment HTTP API Key into the corresponding field and then click on **Save**. Once you've completed these steps, Blitzllama will automatically send response data and interactions to Segment for analysis and processing. ### **Data Fields** Here is sample of data that will be sent from Blitzllama's Segment Stream to Segment Destination platforms. ```json { "user_id":"user_123", "app_key":"blitzllama_api_key", "survey_id":"s-xxxxxx-id", "group_id":"g-xxxxxx-id", "question_id":"q-xxxxxx-id", "platform":"android", "trigger":"home-page-trigger", "question_order":1, "response":"image upload glitches", "question_text":"What do you think of our app?", "question_type":"input_feedback", "created_at":"2022-05-13T13:40:33+00:00" } ``` {% hint style="info" %} For details on the data format [click here](https://segment.com/docs/connections/sources/catalog/libraries/server/http-api/#identify). {% endhint %} ### # Zapier Zapier is a workflow automation tool that enables you to connect with thousands of other applications through its connected marketplace. Zapier employs “zaps” to run tasks; these tasks are easy to set up and can serve highly customizable needs in minutes. Zapier supports applications including, but not limited to, Slack, HubSpot, Salesforce, Intercom, Zendesk, and Gmail. ## Setting up Blitzllama x Zapier Integration ### 1. Prerequisites To use the Blitzllama-Zapier integration, you will first need a Zapier account. If you don’t have one, you can register for a free account at Zapier.com.
Access Blitzllama on Zapier here -> .
### 2. Setting up a New Zap For this example, we will demonstrate how to send survey responses from Blitzllama to a Google Spreadsheet using Zapier. * Create a new Zap and select Blitzllama as the trigger. * Select 'New Survey Response' as the Trigger Event. * Click 'Continue' and then click 'Test Trigger'. * If prompted, sign in to Blitzllama using your Zapier API Key. To obtain your API Key, navigate to Blitzllama’s dashboard, go to Connections > Zapier > Get API Keys. * On Zapier’s dashboard, search for Google Spreadsheet as the action - in other words, this is where the data should be sent. * Add the action 'Create a Record'. For a list of all actions supported by Google Spreadsheet, visit the Zapier Library. * You may be prompted to authenticate or sign in to Google. * Select an existing Spreadsheet where the data will be populated. * Once finished, click 'Continue'. * You will have the option to test your Zap or skip this step and make it live. ## Popular Use Cases * Update a Google Sheet, Notion, or Airtable with new survey responses. * Implement a custom webhook integration with Blitzllama's webhook feature without coding. * Send user data collected via Blitzllama to email marketing tools (e.g., Mailchimp, Mailmodo). * Send user data collected via Blitzllama to CRM software (e.g., Salesforce, Hubspot). * Send user data collected via Blitzllama to customer support software (e.g., Freshdesk, Intercom). * Send an automated email when a user completes a Blitzllama survey. # Slack Connect Blitzllama with Slack to get survey updates and summaries on your channels. ### Supported Capabilities * Daily Digests * More coming soon ### Connecting Slack to Blitzllama {% hint style="warning" %} In Slack, application integration permissions are set by your Slack Administrators. Please check your permissions before beginning the integration. {% endhint %} 1. On Blitzllama's dashboard, Connections > Slack > Connect 2. You will be redirected to Slack's permission access page, click "Allow" 3. On Blitzllama's dashboard, choose the Slack public channel on which you want to receive the updates ### Schedules and Messages * You will receive **Daily Digests** at 5pm IST everyday if there are new responses to your surveys in the previous 24 hours. # Webhook Webhook sync survey responses data to the custom URL that is provided by you on our dashboard. We support two webhook events currently: * on completion of a response to a survey. * on submit of an answer by a user ### Setting up the Webhook integration * Navigate to Connections Tab > **Webhook** in Blitzllama Dashboard. Click on the **Webhook** section. * Enter **Webhook URL** and **Webhook secret** in the Webhook Section. We recommend using `https` your webhook URL because it is more secure. * Click on the **save** button to save webhook details. {% hint style="info" %} **group\_id** - every micro survey instance is uniquely identified as group\_id. This identifier can help to identify the group of users' responses to a specific survey instance. **response** - contains the user's response data. The data for all questions except multi-choice is a string. The multi-select question response is an array. **trigger** - the trigger event that requested the survey. **event\_type** - used to determine the type of webhook event being sent. **created\_at** - refers to the timestamp of the user's response in the ISO 8601 date and time format. {% endhint %} ### on completion of a response to a survey. The webhook payload data contains the response data grouped at a user level. A sample payload is below. ```javascript { "user_id":"user_123", "app_key":"blitzllama_api_key", "survey_id":"s-xxxxxx-id", "survey_name":"Continuous NPS survey", "group_id":"g-xxxxxx-id", "platform":"link", "trigger":"", "event_type":"response_group", "responses":[ { "question_id":"q-xxxxxx-id", "question_order":1, "response":"image upload glitches", "question_text":"What do you think of our app?", "question_type":"input_feedback", "created_at":"2022-06-07T22:01:07.000Z" }, { "question_id":"q-xxxxxx-id", "question_order":2, "response":["image upload", "crash issues"], "question_text":"Select the issues you are facing", "question_type":"multi_select_feedback", "created_at":"2022-06-07T22:01:09.000Z" }, ...] } ``` ### on submit of an answer by a user The webhook payload contains the answer data that is sent on submission of an answer by a user. A sample payload is below. ```json { "user_id":"user_123", "app_key":"blitzllama_api_key", "survey_id":"s-xxxxxx-id", "group_id":"g-xxxxxx-id", "question_id":"q-xxxxxx-id", "platform":"android", "trigger":"home-page-trigger", "question_order":1, "response":"image upload glitches", "question_text":"What do you think of our app?", "question_type":"input_feedback", "created_at":"2022-05-13T13:40:33+00:00" } ``` This webhook is selectively enabled for a few clients. ### Validate webhook (optional) Webhook request header **x-webhook-signature** has the hmac signature to validate**.** Please store **webhook\_secret** in environment variables. ```javascript import crypto from 'crypto'; const key = webhook_secret; //process.env.BLITZ_WEBHOOK_SECRET const message = webhook_body //request body req.body const received_signature = webhook_signature //req.headers["x-webhook-signature"] const expected_signature = crypto.createHmac('sha256', WEBHOOK_SECRET) .update(JSON.stringify(webhook_payload)) .digest('hex'); if expected_signature != received_signature throw SecurityError end ``` # Export APIs ### All APIs Use these **Export APIs** to push survey and user response data from Blitzllama to your system. 1. GET / Export the list of all surveys 2. GET / Export response data from a survey 3. GET / Export response data from a survey for a particular group\_id by adding "?group\_id=\". 4. GET / Export survey actiivty data from a survey Use this **Import API** to manage user cohort data into Blitzllama. 1. POST / Create cohorts and and update users in a cohort
The API documentation can be found in this [**Swagger Link**](https://app.swaggerhub.com/apis/blzswagger/export-survey_api)**.** ### Authentication **Required Credentials** 1. You can find the required credentials to connect to Blitzllama inside the **Connections** tab on Blitzllama dashboard. #### **Set up the integration** Go to connections tab in your Blitzllama account. Select Export API and then click **Enable**. 1. Copy Blitzllama API Key and use it as Authori**s**ation header **\[x-api-key]** for the api requests. 2. The base URL for the request would be '; In case you are stuck at any of the above steps, please don't hesitate to email us at or hit us up on the support chat. # Team Members & Projects ## Team Members ### Inviting Members Adding team members to Blitzllama enables everyone to share and collaborate on user insights. To add team members to your project: * Go to **Settings > Users** from the left menu. * ``` ![](/files/yza0VlhoDQ1fUY814Ner) ``` * Alternatively, Admins can add team members by navigating to **Settings Icon > My Organization**. ![](/files/K8yrWeFeEiFYoDcrVtd2) Invited team members must verify their email addresses before they gain access to Blitzllama. There is no upper limit to the number of members that can be added to a project or organization. Additionally, the number of members is not used for billing calculations, so feel free to invite your entire team! ### **Roles** Each person on Blitzllama has two independent roles: Organization (Admin and Member) and Project (Editor and Viewer). **Project Roles** Project roles determine what actions a person can perform within a project: * **Viewer:** Can view the dashboard, access all micro-surveys, and invite other Viewers to the project. * **Editor:** Has complete access to all project actions. Both Viewers and Editors can create their own projects. **Organization Roles** Organization roles govern actions outside specific projects: * **Member:** Has access to all areas except billing, managing organization-wide projects, and adding or removing organization members. * **Admin:** Has full access to all organizational actions. The account used to create the organization is designated as the **Primary Admin**. Admin and Primary Admin have the same access privileges. #### Role Independence Organization roles and project roles are independent of each other. For example: * An **Editor** in a project can be a **Member** at the organization level. * A **Viewer** in a project can be an **Admin** at the organization level. ## Creating New Projects Blitzllama allows you to create unlimited projects. Projects are designed to help you manage solo initiatives that remain exclusive and independent from each other, ensuring no data crossover between projects. #### Common Use Cases For most companies, it is typical to define at least two projects: * **Staging/Testing Project:** For testing in a controlled environment. * **Production Project:** For live, production-ready data. If your organization manages multiple apps or websites, you can create separate projects for each, ensuring that data is isolated and organized efficiently. #### Permissions Only **Admins** of an organization have the ability to create new projects. #### Steps to Create a New Project 1. Navigate to the dashboard and click on the **gear icon** located in the top-right corner. 2. In the dialog box that opens, select **Create a New Project**. 3. Your new project will be ready instantly. # MTU Sampling Blitzllama provides two primary methods for sampling the amount of MTUs (monthly tracked users) sent to its platform: “Customer Owned” and “Blitzllama Owned.”
Sampling MethodBest ForFlexibility
Customer-OwnedEnterprise organizations with demographic-based sampling needsHigh
Blitzllama-OwnedMid-sized businesses with straightforward needsLow
Opt for the customer-owned method if your sampling requirements are influenced by specific demographics or other unique market segments. This method is typically preferred by larger, enterprise-level organizations. Choose the Blitzllama-owned method if your needs are straightforward and primarily focused on keeping within your user threshold. This method is generally more suited for mid-sized businesses. ### Customer-Owned Sampling In the customer-owned sampling approach, the client establishes a system or rules for including a certain number of users into Blitzllama. This method offers flexibility, allowing clients to adjust the inclusion rate as needed. Here are two ways to do it: 1. **Build own function** This function checks if a user has already been selected to initiate the Blitzllama SDK, randomly selects them if their status is not set, and then loads the SDK if they are flagged for access. 2. **Sampling through A/B testing tools** This type of sampling can also be implemented using your company's A/B testing tools by applying feature flags to Blitzllama for designated user groups. Feature flags enable only selected users to access or interact with specific product features, in this case, Blitzllama. Collaboration with your in-house analytics or data science team is advised to identify user groups and strategize their inclusion in Blitzllama through feature flags. ### Blitzllama-Owned Sampling The Blitzllama-owned sampling is a configuration at the project level that applies to all surveys launched across platforms (Android, iOS, Web and Links) and managed by Blitzllama. It randomly selects which users will initiate Blitzllama and offers no customization options. To configure Blitzllama-owned sampling, reach out to your Blitzllama account executive. # Zendesk ### **Why Connect Zendesk with Blitzllama?** Integrating Blitzllama with Zendesk turns customer support tickets into a goldmine of actionable insights. By enriching Zendesk data with AI-driven analytics, customer feedback becomes more actionable, helping teams stay ahead of customer needs. #### **Key Benefits:** * Centralized Data Hub – Consolidate all Zendesk tickets in one place for a complete view of customer interactions. * AI-Powered Analytics – Identify trends, sentiment shifts, and recurring issues with intelligent insights. * Smarter Decision-Making – Use data-driven recommendations to refine products, services, and support strategies. * Automated Reporting – Generate detailed reports effortlessly, saving time and uncovering key customer concerns. * Advanced Categorization – Enrich tickets with metadata like topics, sentiment, emotions and intent for deeper analysis. *** To enable Blitzllama to pull data from Zendesk, follow these steps: ### 1. Retrieve Your Zendesk Subdomain * Your subdomain is the unique identifier for your Zendesk account, appearing before `.`[`zendesk.com`](http://zendesk.com/) in your URL.

Zendesk's Admin Center.

For more details, visit [this guide](https://support.zendesk.com/hc/en-us/articles/4409381383578-Where-can-I-find-my-Zendesk-subdomain). ### **2. Generate an API Token in Zendesk** * Go to Zendesk Admin Center. * Navigate to Apps and integrations > APIs > Zendesk API. * In the Settings tab, enable Token Access. * Click Add API Token under Active API Tokens to generate a new token. * Copy and securely store the token, as it won’t be visible again after saving. For more details, refer to [Zendesk API access management](https://support.zendesk.com/hc/en-us/articles/4408889192858-Managing-access-to-the-Zendesk-API). ### 3. Connect Zendesk to Blitzllama * Go to the [Blitzllama Dashboard](https://dashboard.blitzllama.com/connections). * Navigate to Connections > Feedback Sources > Zendesk. * Click Connect Source. * Enter your Zendesk subdomain and API token in the respective fields. # Freshdesk Connect Freshdesk with Blitzllama to seamlessly ingest customer support tickets and feedback into a centralized platform. By automating the process of analyzing support interactions, Blitzllama transforms raw data into actionable insights - empowering your team to uncover trends, address recurring issues, and drive data-driven product improvements. ### Why Connect Freshdesk to Blitzllama? Integrating Freshdesk with Blitzllama leverages AI-powered analysis to turn everyday customer support interactions into valuable business intelligence. This connection allows you to: * **Uncover Trends:** Identify recurring issues, feature requests, and customer pain points. * **Enhance Engagement:** Empower your support team with deeper insights for timely and effective responses. * **Drive Product Improvement:** Utilize actionable data to refine features and optimize your product roadmap. * **Streamline Operations:** Automate the ingestion and categorization process to reduce manual effort and always stay up-to-date. **Key benefits** * Centralized Data Hub: Consolidate all Freshdesk tickets and customer feedback in one place for a complete view. * Automated Analysis: Use AI to categorize and analyze support data, surfacing key themes and sentiments. * Real-Time Insights: Regular, automated data ingestion keeps your insights fresh and current. * Enhanced Decision-Making: Leverage data-driven insights to guide strategic improvements across support and product development. * Quick Setup: Connect your Freshdesk account in minutes by simply providing your helpdesk URL and API key. ### Connect Freshdesk to Blitzllama #### 1. Retrieve Your Freshdesk Domain and API Key **Find Your API Key:** * **Log in** to your Freshdesk account. * Click on your **profile picture** at the top right and select **Profile Settings**. * On the right pane, click **View API Key** and complete the captcha verification. * **Copy** your API key and store it securely.\ *Note:* Resetting the API key will disconnect all apps currently using it, so ensure to update them with the new key if needed. **Find Your Freshdesk URL:** * Go to your Freshdesk **Admin panel**. * Click on **Portals** to view your Freshdesk helpdesk URL (e.g., `yourcompany.freshdesk.com`). #### 2. Connect to Blitzllama 1. Open the **Blitzllama Dashboard**. 2. Navigate to **Connections** > **Feedback Sources** > **Freshdesk**. 3. Click **Connect Source**. 4. Paste your Freshdesk helpdesk URL and API key into the respective fields. 5. Click **Save**. Your Freshdesk integration with Blitzllama is now complete! # Intercom Connect Intercom with Blitzllama to analyze customer conversations and support tickets in one place. This integration helps support and product teams uncover trends, track feature requests and bug reports, and understand what prospective customers are asking—all within a centralized platform. ### **Why Integrate Intercom with Blitzllama?** Bringing customer conversations into Blitzllama transforms raw support interactions into actionable insights. With this integration, your team can: * **Spot Trends** – Identify recurring issues and common themes in customer feedback. * **Improve Engagement** – Understand customer needs to tailor proactive responses. * **Drive Product Decisions** – Use real-time insights to refine features and address pain points. #### **Key benefits** 1. Unified Insights – Consolidate customer feedback and support interactions in one view. 2. AI-Powered Analysis – Automate sentiment and theme extraction from conversations. 3. Operational Efficiency – Reduce manual effort with automated ingestion and categorization. 4. Actionable Intelligence – Get data-driven insights for smarter decision-making. 5. Real-Time Syncing – Keep up with the latest customer conversations as they happen. 6. Stronger Retention – Address issues proactively to boost customer satisfaction and loyalty. ### **Connect Intercom to Blitzllama** 1. Go to the [Blitzllama Dashboard](https://dashboard.blitzllama.com/connections). 2. Navigate to Connections > Feedback Sources > Intercom. 3. Click **Connect Source** to start the authorization process. 4. Authorize Access by logging in to Intercom and approve the requested permissions. 5. After authorization, you’ll be redirected to Blitzllama. Toggle on conversation ingestion to begin syncing Intercom data. # Play Store ### **Why sync your Play Store reviews with Blitzllama?** Manually analyzing Play Store reviews is time-consuming and inefficient. Blitzllama automates this process by fetching, translating, and categorizing reviews using AI, giving you **actionable insights in minutes**. Stay ahead of customer feedback, improve app ratings, and make data-driven product decisions effortlessly. **Key benefits:** * Automated Review Analysis – Fetches and categorizes reviews every 4 hours, saving manual effort. * AI-Powered Insights – Identifies top complaints, recurring issues, and improvement opportunities. * Multi-Language Support – Translates and analyzes reviews in 20+ languages for global insights. * Real-Time Alerts – Notifies you about sudden feedback spikes to prevent rating drops. * Quick Setup – Connect your Play Store URL and get structured insights in 5-10 minutes. * Boost App Ratings – Use AI-driven insights to fix pain points, optimize features, and enhance user satisfaction. ### Connect Play Store Reviews To enable Blitzllama to pull your Google Play Store reviews, follow these steps: * Copy your Play Store URL (the publicly listed page of your app on the Play Store)

Copy your Play Store URL (Coinbase for reference).

* Open the [Blitzllama Dashboard](https://dashboard.blitzllama.com/connections). * Go to Connections > Feedback Sources > Play Store. * Click Connect Source. * Paste the URL and click Save. # Appstore ### **Why Sync Your App Store Reviews with Blitzllama?** Manually analyzing App Store reviews is slow and inefficient. Blitzllama automates the process, fetching, translating, and categorizing reviews with AI to give you actionable insights in minutes. Stay ahead of customer feedback, improve app ratings, and make smarter product decisions—without the manual work. #### **Key Benefits** 1. Automated Review Analysis – Fetches and categorizes reviews every 4 hours, eliminating manual effort. 2. AI-Powered Insights – Identifies top complaints, recurring issues, and key improvement opportunities. 3. Multi-Language Support – Translates and analyzes reviews in 20+ languages for global insights. 4. Real-Time Alerts – Detects sudden feedback spikes so you can act before ratings drop. 5. Quick Setup – Connect your App Store listing and get structured insights in 5-10 minutes. 6. Boost App Ratings – Use AI-driven insights to fix pain points, optimize features, and enhance user satisfaction. ### **How to Connect App Store Reviews to Blitzllama** Syncing your App Store reviews is quick and easy: * Copy your App Store URL (your app’s public page on the App Store).
* Open the **Blitzllama Dashboard**. * Go to **Connections > Feedback Sources > App Store**. * Click **Connect Source**. * Paste the URL and click **Save**. That’s it - Blitzllama will start pulling and analyzing your reviews automatically.