# Crawl Page
Source: https://docs.getmonita.io/api-reference/crawl-page

/api-reference/openapi.json post /api/v1



# Health Check
Source: https://docs.getmonita.io/api-reference/health-check

/api-reference/openapi.json get /



# Ingest Streaming Event
Source: https://docs.getmonita.io/api-reference/ingest-streaming-event

/api-reference/openapi.json post /stream/api/v1
Send vendor events from a whitelisted domain to the Monita streaming ingestion service. This endpoint expects the exact payload that the Monita tag emits (see example) and requires a valid token (`t`), vendor name (`vn`) and event (`e`).



# Alert Types
Source: https://docs.getmonita.io/documentation/alerting/alert-types

Learn what type of alerts you can cerate in Monita

This article explains how to create an Alert in Monita. Alerts are used to create notifications which can alert you when specific scenarios occur over a set period. Below are the Alert types available per system.

| Alert Type                                                      | Google Tag Manager Container Monitoring                                                                                                                                                                                                                                                                                                                                                                            | Global Monitoring (Adobe/Tealium/GTM/Any JS)                                                                                                                                                                                   |
| --------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Volume Threshold                                                | **Tag Volume Threshold (does not fire):** Alerts you when there are zero successful fires for a particular tag over a period                                                                                                                                                                                                                                                                                       | **Volume Threshold (does not fire):** Alerts you when there are zero successful executions for a particular Alert over a period.                                                                                               |
| Volume Change                                                   | **Tag Volume Change - Success:**<br />Increase/Decrease in the volume of Successful fires of a particular tag **Tag Volume Change - Failure:**<br />Increase/Decrease in the volume of Failures of a particular tag (failures are caused by either Javascript errors, timeouts or exceptions on your page.) This is only applicable for certain tags which support exception handling (predominantly Google tags). | **Volume change**<br />Allows you to be alerted when the volume of Alert executions is greater than or less than the value you set, as a percentage over two consecutive periods. Eg Hour on Hour, Day on Day or Week on Week. |
| [Volume Anomaly (ML)](/alerting/volume-anomalies-alert.mdx)     | **ML Tag Volume Anomalies:** Alerts you if there are anomalous spikes or drops in the volume of a tag                                                                                                                                                                                                                                                                                                              | **Volume Anomalies (ML):** Alerts you if there are anomalous spikes or drops in the volume of a tag                                                                                                                            |
| [Data Validation](/alerting/data-validation-alert-realtime.mdx) | **Data Validation:** Alerts you when conditions you have set are met for a specified tag variable.                                                                                                                                                                                                                                                                                                                 | **Data Validation:** Alerts you when your data validation conditions are met. This can also be run in realtime for Global Monitoring customers.                                                                                |


# Data Validation Alerts (realtime/scheduled)
Source: https://docs.getmonita.io/documentation/alerting/data-validation-alert-realtime

Checkout the instructions below for how to create a Data Validation Alert in Monita

### Instructions

1. Hover on your property/container and press Alerts
   <img alt="Hover over monitoring card" />
2. Click 'New Alert'
   <img alt="Hover over monitoring card" />

#### Select your Monitoring type below to see the alert setup for each.

<AccordionGroup>
  <Accordion title="For Google Tag Manager Containers">
    3. Select Select Tag Data Validation
       <img alt="Hover over monitoring card" />
    4. Select the Tag you would like to apply the alert to
       <img alt="Select tags" />
    5. Optionally set the Severity of this particular Alert
    6. Enter a condition which you would like your alert to trigger on
       1. ANY will apply an OR to any rows in the field key section
       2. ALL will apply an AND to any rows in the field/key section
          <img alt="Enter data conditions" />
    7. Select the Comparison period, this can be evaluated on a Realtime, Hourly, Daily, 3 day or Weekly basis
       1. If Realtime, you can provide a Stop. The example above ensures regardless of how many times it happens, you receive no more than 1 alert every hour
       2. If daily, enter what time you would like to be notified. *Note this is also the time window of evaluation eg if daily, we will count the number of times the conditions were met from 9am - 9am*
    8. Finally select the channel you would like to get notified on (either Slack or Email).
       <img alt="Select destination" />
       <Note>If you have not yet added a Slack integration, your slack workspace won't appear. To add a Slack Integration go to: <br />[Integrations](https://getmonita.io/integrations) > Click New Integration  > Select Slack<br />For detailed instructions on how to add a Slack Integration, see [this article](/integration/slack-integration).</Note>
    9. Press Save
       <img alt="Click save button" />
  </Accordion>

  <Accordion title="For Global Monitoring Container (Tealim/Adobe Launch/GTM/Tag Commander/JS)">
    3. Enter the name, select the domain, select Data Validation, select the Severity and provide the Vendor
       <img alt="Set vendor" />
    4. Enter in any conditions you would like be met to trigger the alert
       <img alt="Set conditions" />
       <Tip>If you would like to copy and paste multiple comma delimited values in the Value field you can do so and press Enter (which will split it up into multiple chips). Alternatively if you toggle the verbatim input mode on, this will process anything pasted as a single value.<img /></Tip>
    5. Provide an execution period
       <img alt="Set execution period" />
    6. Provide the Alert destination (slack, email)
       <img alt="Set destination" />
       <Note>If you have not yet added a Slack integration, your slack workspace won't appear. To add a Slack Integration go to: <br />[Integrations](https://getmonita.io/integrations) > Click New Integration  > Select Slack<br />For detailed instructions on how to add a Slack Integration, see [this article](/integration/slack-integration).</Note>
    7. Press Save
  </Accordion>
</AccordionGroup>


# Delete Alert(s)
Source: https://docs.getmonita.io/documentation/alerting/delete-alert

Learn how to delete alerts in bulk

This article explains how to delete one or many alerts in Monita. Alerts are used to create notifications which can alert you when specific scenarios occur over a set period.

<Note>Once alerts are deleted you will no longer receive Slack/Email notifications. If you would like to stop receive a notification for a single tag, instead Update the alert and by removing the tag reference from the alert.</Note>
<Warning>Alert deletion is not reversible</Warning>

### Instructions

1. Go to alerts page
2. Select alerts you want to delete
   <img alt="Select alerts from list" />
3. Press the Delete icon
   <img alt="Click delete button" />
4. confirm the delete
   <img alt="Confirm deletion" />
5. You will receive a notification toast indicating successful delete
   <img alt="Deletion Confirmed" />


# Disable Alert(s)
Source: https://docs.getmonita.io/documentation/alerting/disable-alert

Learn how to disable a disabled alerts

This article explains how to de-activate a alert in Monita. Alerts are used to create notifications which can alert you when specific scenarios occur over a set period.

<Note>Once alerts are deactivated you will no longer receive Slack/Email notifications. If you would like to stop receive a notification for a single tag, instead Update the alert and by removing the tag reference from the alert.</Note>

### Instructions

1. Go to alerts page
2. Press the toggle switch on any alert you wish to deactivate
   <img alt="Toggle alert activation" />
3. A toast notification will confirm the alert has been deactivated
   <img alt="Alert activation confirmed" />


# Enable Alert(s)
Source: https://docs.getmonita.io/documentation/alerting/enable-alert

Learn how to enable a disabled alerts

This article explains how to re-activate a alert in Monita. Alerts are used to create notifications which can alert you when specific scenarios occur over a set period.

<Note>Once alerts are Active you will begin receiving Slack/Email notifications if the alert condition is met.</Note>

### Instructions

1. Go to alerts page
2. Press the toggle switch on any alert you wish to Activate
   <img alt="Toggle alert activation" />
3. A toast notification will confirm the alert has been Activated
   <img alt="Alert activation confirmed" />


# ML Volume Anomaly Alert
Source: https://docs.getmonita.io/documentation/alerting/volume-anomalies-alert

Checkout the instructions below for how to create an ML Volume Alert in Monita

<Warning>ML Anomaly alerts requires a minimum of 1000 rows of data and/or 1 week of training data to begin working. If you have any questions [contact support](mailto:support@getmonita.io) or your account manager.</Warning>

### Instructions

1. Hover on your property/container and press Alerts
   <img alt="Hover over monitoring card" />
2. Click 'New Alert'
   <img alt="Hover over monitoring card" />

#### Select your Monitoring type below to see the alert setup for each.

<AccordionGroup>
  <Accordion title="For Google Tag Manager Containers">
    3. Select ML Tag Volume Anomalies
       <img alt="Hover over monitoring card" />
    4. Select the Tag you would like to apply the alert to
       <img alt="Select tags" />
    5. Optionally set the Severity of this particular Alert
    6. Enter any conditions
       <img alt="Set anomaly conditions" />
       <Note>If you are receiving too many alerts (false positives) try reducing the sensitivity. Alternatively if you feel like it you are not alerted frequently enough try increasing the sensitivity</Note>
    7. Finally select the channel you would like to get notified on (either Slack or Email).
       <img alt="Select destination" />
       <Note>If you have not yet added a Slack integration, your slack workspace won't appear. To add a Slack Integration go to: <br />[Integrations](https://getmonita.io/integrations) > Click New Integration  > Select Slack<br />For detailed instructions on how to add a Slack Integration, see [this article](/integration/slack-integration).</Note>
    8. Press Save
       <img alt="Click save button" />
  </Accordion>

  <Accordion title="For Global Monitoring Container (Tealim/Adobe Launch/GTM/Tag Commander/JS)">
    3. Provide an alert name name, select the domain, select AI Anomaly Detection, select the Severity and select the Vendor
       <img alt="Set vendor" />
    4. Enter in any conditions you would like be met to trigger the alert
       <img alt="Set conditions" />
       <Tip>If you would like to copy and paste multiple comma delimited values in the Value field you can do so and press Enter (which will split it up into multiple chips). Alternatively if you toggle the verbatim input mode on, this will process anything pasted as a single value.<img /></Tip>
    5. Provide an execution period
       <img alt="Set execution period" />
    6. Provide the Alert destination (slack, email)
       <img alt="Set destination" />
       <Note>If you have not yet added a Slack integration, your slack workspace won't appear. To add a Slack Integration go to: <br />[Integrations](https://getmonita.io/integrations) > Click New Integration  > Select Slack<br />For detailed instructions on how to add a Slack Integration, see [this article](/integration/slack-integration).</Note>
    7. Press Save
  </Accordion>

  Anomaly alerts look like this in Slack

  <img alt="Anomalies-alert" />
</AccordionGroup>


# SSO Setup Guide
Source: https://docs.getmonita.io/documentation/authentication/sso-setup

Set up Single Sign-On (SSO) for your organization in Monita

# Monita SSO Setup Guide

This guide explains how to set up Single Sign-On (SSO) for your organization in Monita.

## Overview

Monita supports SSO authentication through OAuth providers, primarily Microsoft Entra ID (Azure AD). This allows users from your organization to sign in using their corporate credentials.

## Prerequisites

* A Monita account with team management privileges (delegator role)
* SSO feature enabled in your billing plan
* Access to your organization's OAuth provider (Azure AD, etc.)

## Setup Steps

<Note>Steps 1-3 are done in Monita and may be done on your behalf by your account manager</Note>

### 1. Create a Monita Account

* Sign up for a Monita account at [https://app.getmonita.io](https://app.getmonita.io)
* Complete the account verification process
* Ensure you have team management privileges (delegator role)

### 2. Initial Login via Email

* Log in to your Monita account using email-based authentication
* Navigate to the team management section to access SSO configuration

### 3. Verify SSO Billing Limits

**Important:** The SSO configuration option will only appear if your billing plan includes SSO functionality.

* Go to your billing/subscription settings
* Ensure that SSO is enabled in your plan limits
* Contact support if you need to upgrade your plan to include SSO

### 4. Create OAuth Application in Your Provider

<Note>Steps 4 is done in your SSO providers interface. You must create the OAuth application first, as the configuration details will be needed for the Monita SSO setup.</Note>

<AccordionGroup>
  <Accordion title="Microsoft Entra ID" icon="microsoft">
    #### For Microsoft Azure AD:

    1. Go to [Azure Portal](https://portal.azure.com)
    2. Navigate to **Azure Active Directory** > **App registrations**
    3. Click **New registration**
    4. Configure the application:
       * **Name**: Monita SSO
       * **Supported account types**: Accounts in this organizational directory only
       * **Redirect URI**:
         * Type: **Web**
         * URI: `https://api.app.getmonita.io/api/v1/oauth2callback/sso`
       * Click **Register**
    5. After creation, note down:
       * **Application (client) ID**
       * **Directory (tenant) ID**
    6. Create a client secret:
       * Go to **Certificates & secrets**
       * Click **New client secret**
       * Add a description (e.g., "Monita SSO Secret")
       * Select expiration period (recommend 12-24 months)
       * Click **Add**
       * **Important**: Copy the secret value immediately - you won't be able to see it again
       * Store this securely - you'll need it for Monita configuration
    7. Configure API permissions:
       * Go to **API permissions**
       * Click **Add a permission**
       * Select **Microsoft Graph**
       * Choose **Delegated permissions**
       * Add the following permissions:
         * `email` (View users' email address)
         * `profile` (View users' basic profile)
         * `User.Read` (Sign in and read user profile)
       * Click **Add permissions**
       * Click **Grant admin consent** (if you have admin privileges)
    8. Configure Authentication:
       * Go to **Authentication**
       * Under "Select the tokens you would like to be issued by the authorization endpoint":
         * ✅ **Access tokens**
         * ✅ **ID tokens**
    9. Configure Token Configuration:
       * Go to **Token configuration**
       * Click **Add optional claim**
       * Add the following claims:
         * `upn` (User Principal Name)
         * `given_name` (First Name)
    10. Verify Configuration:
        * Ensure your app registration shows:
          * Status: Active
          * Supported account types: Single tenant
          * Redirect URI: `https://api.app.getmonita.io/api/v1/oauth2callback/sso`
          * Required permissions: email, profile, User.Read
          * Optional claims: upn, given\_name
  </Accordion>

  <Accordion title="Google Workspace" icon="google">
    Go to our sign in page and press Sign In with Google.
    [https://app.getmonita.io/login](https://app.getmonita.io/login)
  </Accordion>
</AccordionGroup>

### 5. Configure SSO in Team Settings

<Note>Steps 5-7 are done in Monita and may be done on your behalf by your account manager</Note>

1. Navigate to **Team Management** (accessible from the main menu)
2. Scroll down to find the **OAuth Domain SSO Config** section
3. This section will only be visible if you have SSO enabled in your billing limits

### 6. Create OAuth Configuration in Monita

Fill in the following details in the SSO configuration form using the values from your OAuth application:

* **Provider Type**: Select your OAuth provider (Microsoft Entra ID, Google, or Custom)
* **Client ID**: Your OAuth application's client ID (from step 4)
* **Client Secret**: Your OAuth application's client secret (from step 4)
* **Tenant ID**: Your Azure AD tenant ID (for Microsoft Entra ID, from step 4)
* **Redirect URL**: This is automatically populated as `https://api.app.getmonita.io/api/v1/oauth2callback/sso`

For custom providers, additional fields may be required:

* Authorization URL
* Token URL
* User Info URL
* Scope

**Note:** The domains field is not editable in this form. You must request platform admin to add your domains.

### 7. Request Domain Configuration from Platform Admin

<Warning> After creating your OAuth configuration, you must contact the Monita platform admin to add your organization's email domains to the SSO configuration.</Warning>

Provide the platform admin with:

* Your organization's email domains (e.g., `company.com`, `subsidiary.company.com`)
* Your OAuth configuration details for verification

The platform admin will:

1. Add your domains to the OAuth configuration
2. Verify the configuration is working correctly
3. Enable SSO for users from your specified domains

### 8. Test SSO Login

1. Log out of your Monita account
2. Go to the login page
3. Enter an email address from your organization's domain
4. Click "Continue with SSO"
5. You should be redirected to your OAuth provider
6. After successful authentication, you'll be redirected back to Monita

### 9. User Onboarding

When users from your organization log in via SSO for the first time:

* They are automatically added as delegates under your account
* They get access to the monitoring features under your organization

## Troubleshooting

### Common Issues

1. **SSO option not visible**: Ensure SSO is enabled in your billing plan
2. **Domain not configured error**: Contact platform admin to verify your domains are added to the OAuth configuration
3. **Authentication failed**: Check your client ID, client secret, and redirect URLs
4. **Access denied**: Ensure the user's email domain is included in the allowed domains list

## Security Considerations

1. **Client Secret**: Keep your OAuth client secret secure and rotate it regularly
2. **Redirect URLs**: Ensure redirect URLs are exactly as configured
3. **Domain Validation**: Only domains explicitly added by platform admin are allowed
4. **User Permissions**: SSO users are automatically added as delegates with limited permissions

## Support

If you encounter issues during setup:

1. Check the browser console for error messages
2. Verify all OAuth configuration details
3. Ensure your billing plan includes SSO functionality
4. Contact Monita support with specific error messages
5. Contact platform admin to verify domain configuration


# PII Viewer
Source: https://docs.getmonita.io/documentation/compliance/pii-viewer

See where personally identifiable information (PII) is leaking from your site into your marketing and analytics vendors, and set up custom alerts to be notified when it happens.

The **PII Viewer** gives you a single, near‑realtime view of any Personally Identifiable Information (PII) that Monita has detected leaving your site or app and being sent to your marketing, analytics, and ad‑tech vendors.

It's designed to help compliance, privacy, and analytics teams answer two questions at a glance:

1. *Are we leaking PII to any of our vendors?*
2. *Which vendors, events, and fields are involved?*

<Frame>
  <img alt="PII Viewer" />
</Frame>

## How Monita handles detected PII

Monita is built privacy‑first. We never store the raw PII values that we observe in your traffic.

When PII is detected in a request leaving your site:

1. The original value is **immediately replaced with a SHA‑256 hash** before the record is written to our database.
2. A `pii_type` label (e.g. `email`) is attached to the record so it can be surfaced in the PII Viewer.
3. The hashed record is retained so you can still see the **vendor**, **event**, **field name**, and **volume** of leaks without ever exposing the underlying PII.

<Note>Because values are one‑way hashed in flight, even Monita support cannot retrieve the raw PII that was detected. The hash is, however, stable — meaning the same email address will always produce the same hash, which is enough to let you de‑duplicate or count unique users.</Note>

<Warning>Monita does **not** automatically notify you when PII is detected. Detection is always visible in the PII Viewer, but if you want to be alerted in Slack or email when PII appears, you need to set up a [custom PII alert](#setting-up-custom-pii-alerts) — see below.</Warning>

## What you see in the PII Viewer

The viewer is split into two sections.

#### Summary card

A high‑level count of distinct PII data points detected in the selected time window, broken down by **domain**, **PII type**, and the **vendors** involved.

#### Detailed Data Breakdown

A row‑level table showing every detected leak, including:

| Column            | What it means                                                                            |
| ----------------- | ---------------------------------------------------------------------------------------- |
| **Domain**        | The domain the request originated from.                                                  |
| **Vendor**        | The vendor the data was being sent to (e.g. Google Analytics 4, Meta Pixel, Floodlight). |
| **Type**          | The type of PII detected (e.g. `Email`, `Credit Card`, `SSN`, `Phone`).                  |
| **Event**         | The event the PII was attached to (e.g. `purchase`, `lead`, `pageview`).                 |
| **Variable name** | The field/key in the vendor's payload that contained the PII (e.g. `ep.email`, `u1`).    |
| **Value Hash**    | The SHA‑256 hash of the leaked value. The raw value is never stored.                     |
| **Volume**        | How many times that exact (hashed) value was seen in the selected window.                |

You can filter by **domain** and **vendor**, and adjust the **time window** (1 hour through to 3 months) using the controls at the top of the page.

## What types of PII does Monita detect?

Monita continuously scans every request streamed through Global Monitoring and looks for the following PII types:

| PII type                            | Notes                                                                                                                                                |
| ----------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Email address**                   | Detected by format — works regardless of the field name.                                                                                             |
| **Credit card number**              | Visa, Mastercard, Amex and Discover. Validated with the Luhn checksum algorithm to virtually eliminate false positives from random digit sequences.  |
| **US Social Security Number (SSN)** | Excludes known‑invalid number ranges. Requires a relevant field name (e.g. `ssn`, `social`, `tax`, `tin`) to confirm intent.                         |
| **US mobile number**                | Supports the optional `+1` country code. Requires a relevant field name (e.g. `phone`, `mobile`, `cell`, `tel`, `contact`, `sms`) to confirm intent. |
| **Australian mobile number**        | Supports the `04xx` format and the optional `+61` country code. Requires a relevant field name as above.                                             |

<Tip>For ambiguous PII types like phone numbers and SSNs, Monita combines pattern matching with the **field/variable name** to avoid false positives — e.g. a 10‑digit order ID won't be flagged as a phone number unless the field is named something like `phone` or `mobile`.</Tip>

### Out of scope (today)

To keep detection accuracy high, the following are **not** currently detected automatically:

* Names, postal addresses, dates of birth
* Passport / driver's licence numbers
* Phone numbers from countries other than the US and Australia
* PII buried inside long blocks of unstructured free text

If any of the above are critical for your compliance posture, please reach out to your account manager or [contact support](mailto:support@getmonita.io) — we are continuously expanding coverage.

## Setting up custom PII alerts

While Monita surfaces all detected PII inside the PII Viewer, **alerts are opt‑in**. This is intentional — different organisations have very different policies about which vendors are allowed to receive which fields, so you remain in control of when and how you're notified.

To get a Slack or email notification any time PII is detected against a particular vendor, create a **Data Validation alert** with a `Contains email` (or equivalent) operator on the relevant parameter.

<Frame>
  <img alt="Set up a custom PII alert via Data Validation" />
</Frame>

To create one:

1. Hover on your domain card and click **Alerts**, then **New Alert**.
2. Set **Alert Type** to **Data Validation** and pick the **Vendor(s)** you want to monitor (e.g. Meta Pixel, Google Ads).
3. Under **Trigger Conditions**, set the **Parameter** you want to inspect and choose an operator like `Contains email`, `Contains credit card`, etc.
4. Optionally add **Filters** (e.g. only on the `purchase` event) to scope the alert.
5. Choose your **Execution period** and **destination** (Slack or email) and save.

For full step‑by‑step instructions, see [Data Validation Alerts](/documentation/alerting/data-validation-alert-realtime).

<Note>Data Validation alerts can run in **realtime** for Global Monitoring customers — meaning you'll be notified within seconds of a PII leak, rather than waiting for a scheduled evaluation window.</Note>

## FAQ

<AccordionGroup>
  <Accordion title="Will Monita ever store the raw PII it detects?">
    No. Detected PII values are SHA‑256 hashed in flight, before any data is written to our database. The raw value cannot be recovered, by you, by us, or by anyone else.
  </Accordion>

  <Accordion title="Why hash instead of dropping the value entirely?">
    Hashing preserves the ability to **count unique users**, **de‑duplicate**, and **trend leakage volumes over time** in the PII Viewer, all without ever exposing the underlying value.
  </Accordion>

  <Accordion title="Why didn't Monita detect a particular PII value I can see in the raw payload?">
    Monita's detection is conservative by design — we'd rather miss an edge case than flood the platform with false positives. Common reasons a value isn't flagged include: the value is a PII type we don't yet cover (e.g. a name or address), the field name doesn't include a recognised keyword for ambiguous types like phones/SSNs, or the value is embedded inside a larger free‑text blob. If you have a specific case you'd like reviewed, [contact support](mailto:support@getmonita.io).
  </Accordion>

  <Accordion title="Can I be alerted automatically when PII is detected?">
    Yes — set up a [Data Validation alert](/documentation/alerting/data-validation-alert-realtime) using a `Contains email` (or similar) operator. This is opt‑in so you control exactly which vendors and parameters trigger a notification.
  </Accordion>
</AccordionGroup>


# Disconnect an Integration
Source: https://docs.getmonita.io/documentation/integration/disconnect-integration

Learn how to disconnect any integration in Monita, such as a GTM integration or Slack Workspace

### Instructions

1. [Login](https://app.getmonita.io) to the app
2. Go to [Integrations](https://app.getmonita.io/integrations)
3. Press 'Disconnect' on integeration card
   <img alt="Click disconnect" />
4. The integration should disappear if successful.
   <Warning>Disconnecting an integration will render related monitoring and alerting ineffective. It's recommended to remove all related monitoring cards or re-assign alert destinations before disconnecting an integration</Warning>
   <Note>Disconnecting integration from 3rd-party system first may cause the integration to break in Monita.</Note>


# GTM Container Integration
Source: https://docs.getmonita.io/documentation/integration/gtm-integration

This article takes users through how to integrate with a Google Tag Manager container.

### Instructions

1. [Login](https://app.getmonita.io) to the app
2. Go to [Integrations](https://app.getmonita.io/integrations)
3. Click 'New Integration'
   <img alt="" />
4. Select Google Tag Manager and press 'Connect with Google'
   <img alt="" />
5. Confirm GTM permissions required by checking the boxes (view may vary from image)
   <img alt="" />
6. Select Google Account. You may see a different screen if the user is not logged into any Google account, or the target Google account is not logged in.
   <Warning>Selected account must have full-write access to the container being monitored. Failure to have adequete perrmissions will result in monitoring errors. At a minimum, the account must be able to modify containers and container versions. Currently Monita does not Publish via the integration. The user is required to published manually. This is done to ensure user had total control over release cycle of GTM.</Warning>
   <img alt="Google account selection" />
7. Confirm permmissions being allowed to Monita
   <img alt="Allow" />
8. If integration is successful, a tile will appear with a green status light.
   <img alt="New integration tile" />
   <Note>After connecting it may take up-to 5mins before your containers propagate into our system. Please allow time after before deploying tags.</Note>


# Slack Integration
Source: https://docs.getmonita.io/documentation/integration/slack-integration

This article takes users through how to integrate with a Google Tag Manager container.

### Instructions

1. [Login](https://app.getmonita.io) to the app
2. Go to [Integrations](https://app.getmonita.io/integrations)
3. Click 'New Integration'
   <img alt="" />
4. Select Slack and press 'Connect with Google'
   <img alt="" />
5. Allow Slack to integrate with a workspace and select a channel which the App will post to
   <img alt="" />
6. Press 'Allow'
7. If integration is successful, a tile will appear with a green status light.
   <img alt="" />
8. (Optional) Select a default workspace. This will speed up alert ceration by negating the need to select a slack channel for alerts destination
   <img alt="" />
   <Note>After connecting it may take a few minutes for the changes in the Slack workspace to take effect.</Note>


# Deployment Troubleshooting
Source: https://docs.getmonita.io/documentation/monitoring/deployment-troubleshooting

Use these steps if you are deploying Monita to your website and Monita still has not received data

Please check the following steps before contacting support.

### 1. Confirm that any Monita changes in the tag manager have been 'Submitted' or 'Published' to production

<AccordionGroup>
  <Accordion title="Google Tag Manager">
    <img alt="Click Submit Button" />

    Make sure to submit any changes Monita has made in the default workspace your tag manager container. Be careful not to deploy any of your own unfinished work.

    After submitting Monita changes, the workspace changes should be blank and your container version should have increased.

    <img alt="Check GTM Workspace Version" />
  </Accordion>

  <Accordion title="Adobe Launch">
    In order for Monita to receive requests you must Publish the monita\_setup\_library to the appropriate environment (dev/staging/prod).

    Please ensure the library is built/published to the environment you wish to run Monita on (dev/stage/prod)

    <img alt="Open Deployment Screen in Adobe Launch" />

    <Frame>
      <img alt="Check deployment environment" />
    </Frame>
  </Accordion>
</AccordionGroup>

### 2. Please fire off any tags which you have monitored

Monita will not receive data unless the tags which you have monitored have fired. To make your life easier we recommend you monitor an all pages tag.

<Accordion title="Network request checking on Chrome Network Tab">
  To confirm that data is being sent to Monita on the client side:

  1. Open the dev console (by pressing F12)
  2. Select the network tab
  3. search for raptor.digital
  4. Open the payload and Confirm requests being sent to monita
     <img alt="Inspect network tab" />
</Accordion>

### 3. If all of these don't work please reach out to support by [Raising a ticket here](https://rnadigital.atlassian.net/servicedesk/customer/portal/2/group/3/create/9)


# Monita Collect
Source: https://docs.getmonita.io/documentation/monitoring/monita-collect

Learn how to send events directly to Monita based on custom javascript execution

You many want to want to send a custom event to Monita based on a user action or other condition that is not associated with a server call made by the vendor.

### Instructions

1. [Configure Global Monitoring](/monitoring/setup-global-monitoring)

2. Choose a vendor you want to send events for. You may create your own custom vendor

3. Enable Monita collect
   <img alt="Enable Monita Collect" />

4. <p>Open Vendor code detail panel by clicking on code <Icon icon="code-simple" /></p>
   <img alt="Open vendor code detail pane" />

5. Copy code example
   <img alt="copy code" />

6. Paste and modify the code in your website Javascript code
   <Tip>If you want to keep track of certain variables, call monita collect `monitaSendBeacon(...)` at the same spot inthe code the variables are set before being processed.</Tip>
   <img alt="Enable Monita Collect" />

7. Test execution

If you have successfully send data to Monita from the client, you should see a network call on the Network tab in your browser (filter for v1/) and it should be visible in the platform visualisation dashboard.

<img alt="Check Monita Collect traffic" />

#### Sending custom data to Monita

If you want to send any arbitrary event and data to Monita, you can use 'Monita' as the Vendor (or even add your own custom Vendor in the UI.)
See a sample code snippet below:

<Info>The monitaSendBeacon function will work so long as the Monita Global JS SDK has been initialised on the page. If not, it should be loaded. To check if it has been loaded you can try and access `__monita_settings`, if it is available then Monita has been loaded. If not you can manually add our initialisation script with your token [as per this guide.](/documentation/monitoring/setup-global-monitoring#checking-that-monita-script-is-being-loaded-on-the-client-side-your-domain) </Info>

```javascript theme={null}
<script>
  // This simple example assumes the Monita SDK is already loaded on the page.
  monitaSendBeacon("Monita", "customEvent", {
    // Add any additional data such as data layer keys you want to send below:
    // url: window.location.href,
    // path: window.location.pathname,
    // userId: 'user123',
    // pageCategory: 'landing'
  });
</script>
```


# Set Up Global Monitoring - JS SDK
Source: https://docs.getmonita.io/documentation/monitoring/setup-global-monitoring

This is a step by step guide to setup and manage Monita Global Monitoring Setup/Manage Global Monitoring (Tealium/Adobe/GTM/JS)

Global Monitoring is an Enterprise feature, which enables companies to agnostically monitor any network request departing the webpage. This is especially useful if you are intending to monitor more than just  tags/pixels/events from a particular JS container, but you are looking to monitor any request no matter which JS based container it is made from whether the script was loaded on the HTML head/body, a via a tag manager or a CMS etc).

This can be used to monitor:

* Marketing/conversion events to platforms like google ads or facebook
* Data layer events
* Analytics or CDP events to platforms like GA4, Adobe Analytics or Tealium/Segment CDP
* Any outgoing HTTP event (so long as you know the URL header)

### Instructions

1. Click 'New Domain' and your domain and select the Monitoring Tab
   <img alt="" />
2. Provide the System you wish to Monitor events from.
   <img alt="" />

<Note>
  Note the base Javascript for all Global Monitoring is quite similar, the various tag manager flavours differ in the specific metadata they automatically pick up from the browser.

  <ul>
    <img />Google Tag Manager Global will access `google_tag_manager` and take the container name and version.
    <img />Tealium Global will access `utag` and take the profile name and version.
    <img />Adobe Global will access `_satellite` and access the launch property and version.
    <img /> Tag commander will access `tC` and access account, container and environment.

    <Icon icon="code" />

    Other is an Agnostic Browser JS SDK and can be run on any browser or any system not specifically mentioned (e.g Segment, Ensighten etc).
  </ul>
</Note>

3. Next provide the Domain you wish to ingest events from and press enter (you can add subdomains here)
   <img alt="Add domain" />
4. Start adding Vendors by Clicking new Vendor
   <img alt="Vendor List" />
5. Search for an existing Vendor or create a Custom Vendor
   <Frame>
     <img alt="Add custom vendor" />
   </Frame>
   <Frame>
     <img alt="Add existing vendor" />
   </Frame>
6. Fill in the Monitoring Form for the specific Vendor you have Chosen
   <img alt="Vendor configuration screen" />
   The form has several crucial fields to complete:

<AccordionGroup>
  <Accordion title="Domains">
    This is the domain which client side pixel/tag requests are sent to.
    Typically known as the request URL e.g. for Facebook, "facebook.com/tr".
  </Accordion>

  <Accordion title="Excluded Parameters">
    Use this field to specify which keys you would like to exclude from monitoring. e.g. Facebook sends an "sw" parameter with screen width. If you don't want/need to monitor that key, enter it here. This field also accepts regex. Regex should be encapsulated within forward slashes `/`. As an example if you entered `/^(data\.loader|data\.timing)\./` this would ensure that anything starting with `data.loader.` and `data.timing.` would not be monitored.
  </Accordion>

  <Accordion title="Event Mapping Field">
    Used to specify which key in the vendors payload corresponds to the event name.
    You can specify either a single field by name, or multiple fields inside curly braces e.g. `{{fieldA}}-{{fieldB}}`. Here is an example request with the event in the "ev" parameter:

    <img alt="Mapped event examples" />

    You can also extract a field value via regular-expression.

    E.g. You may want to extract a sub-domain from a URL and add it to the event, this can be done by find inf the correct regex and applying it to the field parameter in the following format:

    `regex::(?<=https:\/\/)[\w|-]*::url`

    This format represents 3 sections, separated by double-colons (`::`). The 3 sections are:

    * `regex` which inpforms the expression parser that the user is passing a regex expression
    * `(?<=https:\/\/)[\w|-]*` is the regular expression  itself (javascript regex supported. Test your regex in any regex editor such are [Regexr](https://regexr.com/))
    * `url` is the field from which the content is extracted. You may use a dot (`.`) separated field path. (`url`, `host`, `method` and `vendorName` are automatically added to the payload)

    The following event field `eve-{{regex::(?<=https:\/\/)[\w|-]*::url}}` (multiple digits) on value of field "myfield". In a payload `{ url: "https://subdomain.myapp.com" }`, the event field will be `eve-subdomain`.

    <Tip>Regular Expression allows for capturing text in relation to the existence of other text before it or after it. This is called [lookahead](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Lookahead_assertion) and [lookbehind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Lookbehind_assertion)</Tip>
  </Accordion>

  <Accordion title="Filters">
    Use this to focus your monitoring to specific vendor requests e.g. only where "ev" = "orderSuccess". This can also help reduce API call consumption.
  </Accordion>
</AccordionGroup>

7. After completing your Vendor Form press the Apply and then the Save button. To Manage simply enter this form again, edit and you will notice the Deployment Version at the bottom increment by 1.
   <img alt="Vendor added to list" />
8. Follow your installation guide which will provide you with your particular installation guide (depending on which System you selected).
   <img alt="Installing monitoring script" />
9. Once you have deployed your Monita Script to your Domain, test and troubleshoot to make the script is deployed, the Monita tag is firing and events are streamed to Monita.

<AccordionGroup>
  <Accordion title="Checking that Monita Script is being loaded on the Client side (your Domain)">
    1) Visit the domain where you installed Monita on (make sure ad blockers are off)
    2) Open the browser console and type `__monita_settings`
    3) If that loads this means the Script is present on your page
    4) Within the Global object you will notice the script version this should align with what you see within Domain Setup in the Deployment Version (visible next to the Bin icon)
    5) If you want to refresh the script on your page just add the following query string paramater to your url which and refresh the page. `?monitarefresh=1`
       <Frame>
         <img alt="Monita settings in dev console" />
       </Frame>
       <Frame>
         <img alt="Monita deployment version" />
       </Frame>
  </Accordion>

  <Accordion title="Checking Monita calls are firing on the Client side (your Domain)">
    1. Go to the domain you are monitoring
    2. Open the Developer Network Tab (F12)
    3. Fire off any of the Vendors/Events you have monitored in the platform
    4. Filter requests for v1/or raptor.digital
    5. Confirm you can see successful 🟢 204 requests going to our endpoint
       <Frame>
         <img alt="Monita deployment version" />
       </Frame>
  </Accordion>

  <Accordion title="Checking Monita calls are being received on the Server Side (Monita)">
    Open the Visualisation Tab in Monita.

    You should be able to see your events grouped by Vendor and Event and filter for any of the keys that have been ingested from each vendor/event by Expanding an event and filtering on the Data Tab.

    <Warning>
      If you have not completed your Event Mapping Field, from your Vendor Setup, events will not group by event, they will be instead only be grouped by a Vendor with the event being blank. You will know event is mapped properly if it appears on the client side in the `e` parameter shown below

      <img alt="Mapped event examples" />
    </Warning>

    <img alt="Visualisation" />
  </Accordion>
</AccordionGroup>

### Custom Functions

When installing Monita script, you can declare custom functions calculate some fields in the *Monita* payload. The fields that can be overridden include:

* Session ID `sid` \[`get_session_id`]
* Customer ID `cid` \[`get_customer_id`]
* Consent `cn` \[`get_consent`]
* event `e` \[`get_event`] (takes vendor name and payload as parameters)

You can add the functions in this object: <img alt="Mapped event examples" />

You can also prevent Monita from executing using a function \[`is_monita_allowed`] that takes *Monita* payload as argument and returns `true` (allowed) or `false` (not allowed).

If you have specific environment fields, related to a TMS (Tag Management System) not supported by Monita, or other ebvironment fields you want to override, you can sepcify a function \[`get_tms_data`] that takes `window`as parameter and return an object of environment fields.
The fields you can override are:

* System `s` (e.g. `tealium`)
* System release version `rl` (.e.g `v1.1.5`)
* Environment name `env` (e.g. `prod`)
* Domain / Container ID ...etc `do` (e.g. `GTM-123456`)
* Execution time `et` in milliseconds (e.g. `1733731798766`),
* Tag ID, where you can tell which "tag" is associated with this vendor event fire (e.g. `110`)

#### Examples

```javascript theme={null}
// custom object example
{
  get_session_id: function() {
    return sessionStorage.getItem("sid");
  },
  get_customer_id: function() {
    return getCookie("cust_id"); // custom function can be found here https://stackoverflow.com/a/15724300
  },
  get_consent: function() {
    return getCookie("allow_instruments"); // custom function can be found here https://stackoverflow.com/a/15724300
  },
  get_event: function(vendorName, data) {
    if(vendorName == "Google Analytics 4") {
      return data.en;
    } else if (vendorName == "Custom") {
      if(data.commerce) {
        if(data.commerce.purcahse) {
          return "purchase"
        } else if (data.commerce.checkout) {
          return "checkout"
        } else {
          return "cart"
        }
      } else {
        return "pageview"
      }
    } else {
      return null; // will default to whatever default event field or user-specified event field is set for this vendor
    }
  }, is_monita_allowed: function(monitaPayload) {
    return monitaPayload.p == "/checkout"; // `p` = path name
  },
  get_tms_data: function(windowArg) {
    return {
      s: "custom",
      rl: windowArg.customEnv.v,
      env: windowArg.customEnv.name
    };
  }
}
```


# Set Up Global Monitoring - Android Kotlin SDK
Source: https://docs.getmonita.io/documentation/monitoring/setup-global-monitoring-android-kotlin

This is a step by step guide to setup and manage Monita Global Monitoring Setup/Manage Global Monitoring for Android Kotlin

Global Monitoring is an Enterprise feature, which enables companies to agnostically monitor network requests departing your client.

### Instructions

1. Click 'New Domain' and your domain and select the Monitoring Tab
   <img alt="" />
2. Select Android SDK or Global Monitoring (Use Global if you would like to use the same Domain for both web and mobile)
3. Next provide the Domain you wish to ingest events from and press enter (you can add subdomains here)
   <img alt="Add domain" />
4. Start adding Vendors by Clicking new Vendor
   <img alt="Vendor List" />
5. Search for an existing Vendor or create a Custom Vendor
   <Frame>
     <img alt="Add custom vendor" />
   </Frame>
   <Frame>
     <img alt="Add existing vendor" />
   </Frame>
6. Fill in the Monitoring Form for the specific Vendor you have Chosen
   <img alt="Vendor configuration screen" />
   The form has several crucial fields to complete:

<AccordionGroup>
  <Accordion title="Domains">
    This is the domain which client side pixel/tag requests are sent to.
    Typically known as the request URL e.g. for Facebook, "facebook.com/tr".
  </Accordion>

  <Accordion title="Execluded Parameters">
    Use this field to specify which keys you would like to exclude from monitoring. e.g. Facebook sends an "sw" parameter with screen width. If you don't want/need to monitor that key, enter it here.
  </Accordion>

  <Accordion title="Event Mapping Field">
    Used to specify which key in the vendors payload corresponds to the event name.
    You can specify either a single field by name, or multiple fields inside curly braces e.g. `{{fieldA}}-{{fieldB}}`. Here is an example request with the event in the "ev" parameter:

    <img alt="Mapped event examples" />

    You can also extract a field value via regular-expression.

    E.g. You may want to extract a sub-domain from a URL and add it to the event, this can be done by find inf the correct regex and applying it to the field parameter in the following format:

    `regex::(?<=https:\/\/)[\w|-]*::url`

    This format represents 3 sections, separated by double-colons (`::`). The 3 sections are:

    * `regex` which inpforms the expression parser that the user is passing a regex expression
    * `(?<=https:\/\/)[\w|-]*` is the regular expression  itself (javascript regex supported. Test your regex in any regex editor such are [Regexr](https://regexr.com/))
    * `url` is the field from which the content is extracted. You may use a dot (`.`) separated field path. (`url`, `host`, `method` and `vendorName` are automatically added to the payload)

    The following execnt field `eve-{{regex::(?<=https:\/\/)[\w|-]*::url}}` (multiple digits) on value of field "myfield". In a payload `{ url: "https://subdomain.myapp.com" }`, the event field will be `eve-subdomain`.

    <Tip>Regular Expression allows for capturing text in relation to the existence of other text before it or after it. This is called [lookahead](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Lookahead_assertion) and [lookbehind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Lookbehind_assertion)</Tip>
  </Accordion>

  <Accordion title="Filters">
    Use this to focus your monitoring to specific vendor requests e.g. only where "ev" = "orderSuccess". This can also help reduce API call consumption.
  </Accordion>
</AccordionGroup>

7. After completing your Vendor Form press the Apply and then the Save button. To Manage simply enter this form again, edit and you will notice the Deployment Version at the bottom increment by 1.
   <img alt="Vendor added to list" />
8. See the below Android Kotlin installation guide to install the Android SDK on your Kotlin App.

### Step 1: Add the JitPack Repository

Add the following lines to your root `settings.gradle.kts`:

```gradle theme={null}
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        mavenCentral()
        maven { url = uri("https://jitpack.io")  }
    }
}
```

### Step 2: Add the Dependencies

Include the Monita SDK and the Monita Adapter Library in your **module-level** `build.gradle.kts` or `build.gradle` file:

```gradle theme={null}
dependencies {
    implementation ("com.github.rnadigital.monita-android-sdk:monita-android-sdk:v1.10.0")
    implementation ("com.github.rnadigital.monita-android-sdk:monita-adapter-library:v1.10.0")
    byteBuddy ("com.github.rnadigital.monita-android-sdk:monita-adapter-library:v1.10.0")
}
```

### Step 3: Byte Buddy Plugin Integration

Add the Byte Buddy Gradle plugin to your project by including the following in your `build.gradle.kts` or `build.gradle` file:

```gradle theme={null}
plugins {
    id("net.bytebuddy.byte-buddy-gradle-plugin") version "1.15.5"
}
```

### Step 4: Sync the Project

Once you've added the dependencies, sync your project with Gradle by clicking **"Sync Now"** in Android Studio or running:

```bash theme={null}
./gradlew build
```

## Usage

After successful integration, you can initialize Monita SDK in your application class:

```kotlin theme={null}
import android.app.Application
import com.rnadigital.monita_android_sdk.MonitaSDK

class MyApplication : Application() {
    val token = "fe041147-0600-48ad-a04e-d3265becc4eb"

    override fun onCreate() {
        super.onCreate()
        MonitaSDK.Builder(this)
            .enableLogger(true)
            .setToken(token)
            .setBatchSize(10)
            .setCustomerId("123456")
            .setConsentString("Granted")
            .setSessionId("123456")
            .setAppVersion("1.0")
            .build {
                // Callback when initialization is complete
            }
    }
}
```


# Set Up Global Monitoring - iOS Swift SDK
Source: https://docs.getmonita.io/documentation/monitoring/setup-global-monitoring-ios-swift

This is a step by step guide to setup and manage Monita Global Monitoring Setup/Manage Global Monitoring for iOS Swift

Global Monitoring is an Enterprise feature, which enables companies to agnostically monitor network requests departing your client.

### Instructions

1. Click 'New Domain' and your domain and select the Monitoring Tab
   <img alt="" />
2. Select iOS SDK or Global Monitoring (Use Global if you would like to use the same Domain for both web and mobile)
3. Next provide the Domain you wish to ingest events from and press enter (you can add subdomains here)
   <img alt="Add domain" />
4. Start adding Vendors by Clicking new Vendor
   <img alt="Vendor List" />
5. Search for an existing Vendor or create a Custom Vendor
   <Frame>
     <img alt="Add custom vendor" />
   </Frame>
   <Frame>
     <img alt="Add existing vendor" />
   </Frame>
6. Fill in the Monitoring Form for the specific Vendor you have Chosen
   <img alt="Vendor configuration screen" />
   The form has several crucial fields to complete:

<AccordionGroup>
  <Accordion title="Domains">
    This is the domain which client side pixel/tag requests are sent to.
    Typically known as the request URL e.g. for Facebook, "facebook.com/tr".
  </Accordion>

  <Accordion title="Execluded Parameters">
    Use this field to specify which keys you would like to exclude from monitoring. e.g. Facebook sends an "sw" parameter with screen width. If you don't want/need to monitor that key, enter it here.
  </Accordion>

  <Accordion title="Event Mapping Field">
    Used to specify which key in the vendors payload corresponds to the event name.
    You can specify either a single field by name, or multiple fields inside curly braces e.g. `{{fieldA}}-{{fieldB}}`. Here is an example request with the event in the "ev" parameter:

    <img alt="Mapped event examples" />

    You can also extract a field value via regular-expression.

    E.g. You may want to extract a sub-domain from a URL and add it to the event, this can be done by find inf the correct regex and applying it to the field parameter in the following format:

    `regex::(?<=https:\/\/)[\w|-]*::url`

    This format represents 3 sections, separated by double-colons (`::`). The 3 sections are:

    * `regex` which inpforms the expression parser that the user is passing a regex expression
    * `(?<=https:\/\/)[\w|-]*` is the regular expression  itself (javascript regex supported. Test your regex in any regex editor such are [Regexr](https://regexr.com/))
    * `url` is the field from which the content is extracted. You may use a dot (`.`) separated field path. (`url`, `host`, `method` and `vendorName` are automatically added to the payload)

    The following execnt field `eve-{{regex::(?<=https:\/\/)[\w|-]*::url}}` (multiple digits) on value of field "myfield". In a payload `{ url: "https://subdomain.myapp.com" }`, the event field will be `eve-subdomain`.

    <Tip>Regular Expression allows for capturing text in relation to the existence of other text before it or after it. This is called [lookahead](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Lookahead_assertion) and [lookbehind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Lookbehind_assertion)</Tip>
  </Accordion>

  <Accordion title="Filters">
    Use this to focus your monitoring to specific vendor requests e.g. only where "ev" = "orderSuccess". This can also help reduce API call consumption.
  </Accordion>
</AccordionGroup>

7. After completing your Vendor Form press the Apply and then the Save button. To Manage simply enter this form again, edit and you will notice the Deployment Version at the bottom increment by 1.
   <img alt="Vendor added to list" />
8. See the below iOS Swift installation guide to install the iOS SDK on your Swift App.

## Installation

Follow these steps to integrate Monita SDK into your iOS project:

### Step 1: Add the Package Dependency

1. Open Xcode and navigate to **File > Swift Packages > Add Package Dependency**.
2. In the search box, enter the URL:
   ```
   https://github.com/rnadigital/monita-ios-sdk.git
   ```
3. Click **Next**.
4. Select the **branch** option and enter `master` as the branch name.
5. Click **Finish**. The SDK will be added under **Swift Package Dependencies**.

### Step 2: Configure the SDK Token

1. Open your project's `Info.plist` file in Xcode.
2. Add a new key called `MonitaSDKToken` with your SDK token as the value:

   ```xml theme={null}
   <key>MonitaSDKToken</key>
   <string>Your-Token-Here</string>
   ```

## Usage

After installing the SDK, initialize it in your application delegate. For example, update your `AppDelegate.swift` as follows:

```swift theme={null}
import MonitaSDK

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    // Initialize Monita SDK with your custom configuration
    MonitaSDK.configure(
        enableLogger: true,
        batchSize: 10,
        customerId: "123456",
        consentString: "Granted",
        sessionId: "123456",
        appVersion: "1.0"
    )
    
    return true
}
```


# Set Up Global Monitoring - Server Side
Source: https://docs.getmonita.io/documentation/monitoring/setup-global-monitoring-server-side

This is a step by step guide to setup and manage Monita Global Monitoring Setup/Manage Global Monitoring for Server Side Accounts

Global Monitoring is an Enterprise feature, which enables companies to agnostically monitor/stream network requests departing your client or server.

## Installation in Monita

### Domain Setup

1. Click 'New Domain' and your domain and select the Monitoring Tab
2. Select Global Monitoring (Use Global if you would like to use the same Domain for both web/mobile/server)
3. Next provide the Domain you wish to ingest events from and press enter.
   <Tip>For Server side be sure to determine the URL that requests will originate from. Users who wish to stream events from multiple clients (Web/Mobile/Server) should make sure they whitelist each domain/origination server URL here. The first domain entered will become it's 'Domain' name inside Monita.</Tip>

<img alt="Add domain" />

### Vendor Setup

4. Start adding Vendors by Clicking new Vendor
   <img alt="Vendor List" />

5. Search for an existing Vendor or create a Custom Vendor
   <Frame>
     <img alt="Add custom vendor" />
   </Frame>
   <Frame>
     <img alt="Add existing vendor" />
   </Frame>

6. Fill in the Monitoring Form for the specific Vendor you have Chosen
   <img alt="Vendor configuration screen" />
   The fields in this form only matter if the user is deploying to a client side platform (web/mobile). For server side you can simply add a vendor and press save.:

### Monita Collect switch

7. Turn on the 'Monita Collect' switch
   <Note>Monita Collect will enable a code button on the left of every vendor, when clicked shows you the names of Vendors, which you can then map in your API Call in the `vn` parameter. The `vn` parameter can take in any arbitray value, but it is recommended to use the exact spelling provided by Monita if you would like to see the logo appear in the platform visualisation dashboard. <img alt="Monita Collect Vendor Name" /></Note>

### Getting your token

8. Press the Save button, this will provide your token.
   <Tip>If you already have an existing Domain, press Manage > Installation Guide and copy your token.</Tip>
   <img alt="Vendor added to list" />
9. Now that you have a token, you can use it to send events to Monita from your server.

## Installation in your server side platform

Enter your server side platform (Adobe, Tealium, Segment etc)

### Select a generic HTTP/Webhook outbound event/action

1. Use the spec found on [API Reference](/api-reference/ingest-streaming-event) to craft a `POST` request to send events to Monita.
   <Info>This is where you should map an event name in the `e` parameter, any data inside the `dt` object and the Vendor Name (from step 7) in the `vn` parameter.</Info>

2. Use the token provided to you to send arbitrary events to Monita.

3. Confirm in your platform's logging that you are recieving `204` responses from Monita.

4. Confirm in Monita that you are recieving events in the Visualisation Tab.


# Set Up GTM Tag Monitoring
Source: https://docs.getmonita.io/documentation/monitoring/setup-tag-monitoring

Use this article if you have added new tags in GTM and would like to monitor them

### Instructions

To monitor a new tag follow these instructions:

1. Make sure you have integrated Monita with the GTM container you would like to Monitor. See this article \[Integrating with GTM Container] **\[TODO: ADD LINK]**
2. Go to the [Monitoring home page](https://beta.raptor.digital/monitoring)
3. Click 'New Container' (your integrated containers and tags will appear)
   <img alt="Click &#x22;New Container&#x22; button" />
4. Select the Account and Container you would like to Monitor
   <img alt="Select Container" />
5. Enter all Domains which this container is deployed to. This can be a root domain, or a subdomain.
6. Select the Tags you would like to monitor within your container
   <img alt="Tag selection" />
   <Warning>Before proceeding to deployment please ensure that no one is creating/editing anything in the Google Tag Manager container which you are setting up.</Warning>
7. Click 'Monitor Tags'

This will begin deploying our Tag Template, Tag Monitoring Tag, Endpoint variable, Token Variable. The following message will appear:

<img alt="Deployment progress message" />

7\. Upon completion a summary message will appear in the bottom left indicating the amount of tags that have either been created, updated, removed or unmodified.

<img alt="Deployment completion message" />

8\.  Enter into the target Google Tag Manager container and verify the deployment. For net new monitoring setups  it should look like this (tags being monitored should be Modified as the bottom tag in this image):

<img alt="Deployment review in GTM" />

9\. You can either Preview or Submit your container to production.
<Note>If previewing tags, they will fire as usual, although traffic will not be admitted to Monita so that outliers are not introduced to your production data.</Note>
10\. Your integration and GTM setup is now complete. You will now need to integrate to Google Data Studio or your Visualisation platform of choice.

To setup visualisation for your Tag Monitoring in Google Data Studio seeSetup Google Data Studio visualisation **\[TODO: ADD LINK]**


# Update GTM Tag Monitoring
Source: https://docs.getmonita.io/documentation/monitoring/update-tag-monitoring

This is a step by step guide to update Monita Tag Monitoring for GTM Container Monitoring

### Instructions

1. Make sure you have integrated Monita with the GTM container you would like to Monitor. See this article Integrating with a GTM container **\[TODO: ADD LINK]**
2. Hover over the container you would like to update tag monitoring for and press 'Manage'
   <img alt="" />
3. Use the checkboxes to fine tune how you would like to monitor the tag
   1. To monitor **only the volume of a tag** - select only the top level checkbox only
   2. To monitor **a specific tag data/variable** - select the checkbox next to the specific tag variable

<Frame>
  <img alt="" />
</Frame>

4. Press 'Save'

This update the associated Monitoring Tag within Google Tag Manager

<img alt="" />

<Note>By default Monita will create a workspace called "Monita Deployment Workspace" and push any required Monita template changes to that workpspace.
If you are using the free version GTM, make sure to have no more than 2 workspaces in use as there is a limit of 3 workspaces. In these cases Monita will push to the default workspace.</Note>

5. Upon completion a Domain Setup modal will close.
6. Enter into the target Monita Deployment Workspace and verify the changes.

<Frame>
  <img alt="" />
</Frame>

You will notice a modification to your Monita tag (your Monita tag name may be different)

<Frame>
  <img alt="" />
</Frame>

7. You can either Preview or Submit your container to production.
   <Note>If previewing tags, they will fire as usual, although traffic will not be admitted to Monita so that outliers are not introduced to your production data.</Note>
8. You can confirm your tag is firing by looking on the Client side and filtering network requests for raptor.digital, or by entering your by filtering your Monita Dashboard for results

<Frame>
  <img alt="" />
</Frame>

Checking in the platform

<Frame>
  <img alt="" />
</Frame>