> This is part 1 of 2 of the full documentation (pages 1–100 of 184). > The content is paginated: fetch every part to see all of it. > Next part: https://docs.zipy.ai/llms-full.txt/1 > Page index: https://docs.zipy.ai/llms.txt # Welcome to Zipy ai Welcome to a one stop platform which solves for customer experience. Zipy is a proactive debugging tool that helps your developers monitor session replays in your web app and track errors and exceptions occurring in the end user environment. This can be achieved by simply including a two-line JavaScript SDK provided by Zipy in your web app. Once the installation is successful, Zipy starts recording the user actions, request responses, console events, errors and exceptions on your app in the user environment, thus giving developers a way to proactively resolve issues on the user end. Here's a screenshot of the Error Classification screen in Zipy:
# Install Zipy How can I install Zipy on my product? Getting started is easy. Go to the Install page in the Zipy application after Signing In.
You can use either of the following methods: 1. **Install Zipy via SDK script** You can achieve this by simply including a two-line JavaScript SDK provided by Zipy in the head section of the html page of your web application. Sample SDK script: 
<script src="https://cdn.zipy.ai/sdk/v1.0/zipy.min.umd.js" crossorigin="anonymous"></script>
<script> window.zipy && window.zipy.init('YOUR_PROJECT_SDK_KEY');</script>
**Note:** If you are using **lazy loading** for external scripts on your website, please ensure that the Zipy script is downloaded before calling the `zipy.init()` function. \ 2\. **Install Zipy via npm** Following are the steps for installation: * Install zipy module in the app project: ``` npm i zipyai ``` * Then import zipy module and initialize in your \_app.js or any other source file: ``` import zipy from 'zipyai'; zipy.init('YOUR_PROJECT_SDK_KEY'); ``` Please sign into [*https://app.zipy.ai*](https://app.zipy.ai/) to get your Project SDK Key. # Installing with Google Tag Manager Installing Zipy with Google Tag Manager You will need to integrate the Zipy SDK before you can start recording sessions and errors. Here are the steps for Integrating Zipy through GTM **Step 1. Go to Google Tag Manager** [**https://tagmanager.google.com/#/home**](https://tagmanager.google.com/#/home) **Step 2. Select or Create the account where you would like to Install Zipy**
**Step 3. Select Tags from the Workspace Menu**
**Step 4. Create a New Tag**
**Step 5. Select Tag Configuration**
**Step 6. Choose Custom HTML tag in Tag Type**
**Step 7. Open a new tab in browser and sign into Zipy app -** [**https://app.zipy.ai/sign-in**](https://app.zipy.ai/sign-in) **Step8. Go to Project Settings and copy the Script Tag**
**Step 9. Paste this Script Tag in Custom HTML in GTM**
**Step 10. Select Triggering from Tag Configuration**
**Step 11. Select All Pages from Triggers**
**Step 12. Save the Tag Configuration**
**Step 13. Click on Submit, you are almost there.**
**Step 14. Add the Version Name and Publish! You are all set.**

# Supported frameworks What types of apps and frameworks does Zipy support? Zipy works with any JavaScript web app and supports most commonly used frameworks/libraries like ReactJS,Next.js Angular, Svelte, AngularJS, VueJS, JQuery, Ember etc. For Mobile support please join our waitlist here {% embed url="" %} {% embed url="" %}
# Security Overview Zipy Security Overview We believe that consumer experience data is very important for your business and security of this data is equally important. Hence to provide our customers peace of mind we follow certain security standards and practices, which will constantly keep evolving to protect the data against any security breaches. Our customers can control what data Zipy will record and store. Any data that our customers deem sensitive should not be recorded and Zipy will not store it. The following are the best practices followed by Zipy to ensure the security of our customers data. **System Security** * Servers and Networking All production servers running Zipy are hosted on Google Cloud and support only https connections on port 443. All recorded data transmitted from customer products to Zipy servers is over https and hence encrypted and secure. We support SSL certificates on all our network API endpoints. Our website is also secure and supports https. * Storage Security We are storing all customer data in Google Cloud Platform which allows multi layer access, encryption and monitoring. Each customer data is stored in a separate bucket. Data is stored in an encrypted manner using Google-managed keys. (Objects are encrypted automatically using keys that Google manages on Zipy’s behalf) We plan to use Customer-managed keys going forward. **Employee Access** We use Google account roles and policies to verify employee account identity. We also provide two factor authentication for all sensitive data access. All Google Cloud based access is based on Google accounts. **Application Security** * Sensitive Data Any data that is sensitive to the customer shall not be recorded by Zipy unless specified or enabled by the customer. Zipy provides configuration parameters to allow the customers to enable and disable what data is recorded by Zipy. * All recorded data is transferred over https ( Data security in transit) * All recorded data is stored in encrypted format in separate customer partitions ( Data security in store) * SDK ( javascript) which is embedded in customers code * The sdk is hosted at a secure endpoint on the Google cloud and it cannot cause security vulnerabilities as all the communication endpoints are behind SSL certificates and only allow an https connection. * Every customer has a unique sdk key which can only be used by them. It is verified and authenticated in Zipy backend before storing any data for that customer. There is an additional handshake Zipy provides before any communication is initiated with Zipy servers for recording and storing data. * Developer interface * Our developer console - app.zipy.ai allows only authenticated users to login. We support standard JWT email authentication and SSO currently. * All current developer console REST APIs are over https. # Sensitive User Data How does Zipy handle sensitive user data? At Zipy, data privacy and security is of utmost importance to us. Hence by default, our tool will disable the capture of all sensitive and Personal Identifiable Information of the users, which includes email IDs, passwords, usernames, credit card information, etc. Further, Zipy allows configuration of the following parameters, to ensure better privacy. Please reach out to us if you want to change the default values. | **Config Param Name** | **Description** | **Default Value** | | --------------------- | ---------------------------------------------------------------------------- | ----------------- | |

IP Capture

| Capture IP address of the user | true | | Input Masking | Masking of user inputs in TextFields, TextAreas, FormInputs, Passwords, etc. | true | Also, Zipy allows you to block additional sensitive data using the **zipy-block** class. **\
Sample div\
** Example Usage: ```html
``` # SOC2 Type II Zipy is SOC2 compliant Zipy is SOC2 Type II compliant. If you need more information please reach out to .
For access to the complete report, email us at: [support@zipy.ai](mailto:undefined) # Android Setup # Install in an Android app How do I install Zipy in my Android mobile application? ## Step 1: Add Dependency In your app-level `build.gradle` file with the latest version: Go to the following link for latest version:\ ```gradle dependencies { implementation 'ai.zipy:zipy-android:1.0.1' } ``` ## Step 2: Initialize SDK Initialize Zipy as early as possible (typically inside `Application` class). ```java import com.zipy.zipyandroid.Zipy; public class MyApplication extends Application { @Override public void onCreate() { super.onCreate(); // Provide application context Zipy.setApplicationContext(application); // Initialize with API Key Zipy.init("YOUR_API_KEY"); } } ``` If you just want the latest version without hardcoding the number—which gives you flexibility but reduces clarity—you can use a dynamic version specifier: ```gradle dependencies { implementation 'ai.zipy:zipyandroid:+' } ``` Add these rules in proguard rules file if you are minifying code in release ``` -dontwarn com.zipy.zipyandroid.** -keep class com.zipy.zipyandroid.** { *; } -keepclassmembers class com.zipy.zipyandroid.** { *; } -keepattributes *Annotation*,Signature,EnclosingMethod # Prevent protobuf Lite classes (used by Zipy events/types) from being stripped/obfuscated. # The crash "Field kind_ for j3.z1 not found" indicates Value/Struct fields were obfuscated. -dontwarn com.google.protobuf.** -keep class com.google.protobuf.** { *; } -keepclassmembers class com.google.protobuf.** { *; } # Keep generated proto event classes under types.* to preserve field names for reflection. -dontwarn types.** -keep class types.** { *; } -keepclassmembers class types.** { *; } ``` # Identify Users How do I identify my users or customers using Zipy? ## Identify a User To identify **users you will need to additionally call Zipy.identify(uuid, {userInfo}).** This will help you identify the users of your application by associating your own unique identifier with their activity. This method should typically be called when your users identify themselves by signing in to your application. To identify users you need to- 1. [Install zipy](/zipy-for-mobile/android-setup/install-in-an-android-app) for android in you application 2. Import Zipy where you want to identify the user ```swift import com.zipy.zipyandroid.Zipy; ``` 3. Call the identify function like this ```swift // Associates the current session with a specific user identity val userInfo = HashMap().apply { put("email", "john.doe@example.com") put("firstName", "John") put("lastName", "Doe") put("customerName", "ACME Corp") // Additional custom fields put("role", "developer") put("plan", "enterprise") put("region", "US-West") put("teamSize", 15) put("lastLogin", System.currentTimeMillis()) } // Call identify with a unique external ID and user info Zipy.identify("user_${System.currentTimeMillis()}", userInfo) ``` ## Anonymize a User To anonymize or disassociate a identified user of your application from the session, use the following code in a source file where the user signs out of your application: ```swift import com.zipy.zipyandroid.Zipy; // Clears all user-identifying information and creates a new session Zipy.anonymize(); ``` > **Note:** We recommend calling `Zipy.anonymize()` when the user logs out. This ends the current identified session and starts a fresh, anonymous session, ensuring that subsequent activity isn't mistakenly linked to the previous user. **The** `uuid` **sent to Zipy can be viewed in the Session Replays list in the user column, as shown in the image below:**
**Previously identified users of your application can be anonymized by calling the zipy.anonymize()** m**ethod. This will automatically split the session and associate the new session with a new anonymous user which Zipy will identify with its own identification. This method should typically be called when users sign out of your application.** ## Custom Identifiers We allow a maximum of 10 custom identifiers per project which can be created as per your use-case. To use custom identifiers, you can add them to the existing userInfo object in Zipy’s identify method: **In case you want to add your own custom identifiers in addition to the identifiers we have defined for you, please reach out to .** # Network Calls Monitor and log Network calls seamlessly with Zipy for enhanced debugging and performance optimization. Add this interceptor to Http client builder for capturing network calls ```java import com.zipy.zipyandroid.network.NetworkInterceptor OkHttpClient.Builder() .addInterceptor(NetworkInterceptor()) .build() ``` Example: ```java class NetworkDemoActivity : AppCompatActivity() { private lateinit var tvResult: TextView private val client by lazy { OkHttpClient.Builder() .addInterceptor(NetworkInterceptor()) .build() } ``` # Custom Logging Recording key events and managed errors to boost app reliability and debugging efficiency Logging Messages and Capturing Handled Exceptions enhances app reliability by recording key events and errors during app execution. ### Log Messaage Logs various types of informational, debug, warning, or error messages to capture events, notifications, or actions within the application. ```swift import com.zipy.zipyandroid.Zipy; // Simple message logging Zipy.logMessage("User completed onboarding"); // With additional context Zipy.logMessage("Cart updated", cartObject); // With custom max length Zipy.logMessage("Custom message", data, 2000); ``` ### Log Errors Logs all the error, providing all the details you pass for debugging. Captures and records error events within your application ```swift import com.zipy.zipyandroid.Zipy; // Simple error logging Zipy.logError("Payment processing failed"); // With error object Zipy.logError("API error", errorObject); // With custom max length Zipy.logError("Database error", error, 2000); ``` ### Log Exceptions Logs exceptions encountered by the application, providing detailed stack traces and context to aid in debugging and troubleshooting. This feature ensures critical data is logged promptly to diagnose and resolve issues. ```swift import com.zipy.zipyandroid.Zipy; try { // Your code here } catch (Exception e) { // Simple exception logging Zipy.logException("Operation failed"); // With exception details Zipy.logException("Failed to process payment", e); // With custom max length Zipy.logException("Custom error", e, 2000); } ``` **Note:** For custom logging, if `maxLength` is not provided, it will default to capturing the full length. # Session URL Retrieval Retrieve and utilize the current session URL dynamically with Zipy's getCurrentSessionUrl function. Retrieve the current session URL with Zipy's getCurrentSessionUrl function, enabling you to obtain and utilize the session's URL dynamically. Here is a sample code snippet: ```java import com.zipy.zipyandroid.Zipy String sessionUrl = Zipy.getCurrentSessionURL(); ``` This function can be useful for tracking and analyzing user behavior within your application. # Input Masking & Custom Masking Blocking sensitive data on Zipy Zipy's Input Masking feature ensures that all input field data on the screen is automatically masked during session recordings. This powerful feature prevents sensitive information from being visible in the recordings, safeguarding user privacy and maintaining compliance with data security standards. Key benefits: * Masks sensitive information to prevent unauthorized viewing * Automatically protects input fields like passwords and personal data * Maintains compliance with data security standards * Ensures user privacy in session recordings The SDK provides two types of masking: 1. **Automatic Input Masking**: Built-in protection for standard input fields 2. **Custom UI Masking**: Using `zipy_block` for additional UI elements ### Using ZipyBlock When screenshots are captured, the masked elements will appear as black rectangles in the screenshot while remaining fully visible to the user during normal app usage. Add the tag to do custom masking in xml files\ android:tag="zipy\_block" ```xml