# Quickstart
URL: /api

***

title: Quickstart
description: Unlock powerful YouTube automation workflows with TubeLab's API
icon: intro
-----------

import { Step, Steps } from "fumadocs-ui/components/steps";
import { DynamicCodeBlock } from "fumadocs-ui/components/dynamic-codeblock";
import { Icon } from "@/components/ui/icon";

[TubeLab](https://tubelab.net/)'s API gives you access to the [Niche Finder](https://tubelab.net/youtube-niche-finder) & [Outliers Finder](https://tubelab.net/youtube-outliers-finder) data - including 400K+ channels, 4M+ outliers, and YouTube scans. Updated everyday, in real-time.

This unlocks powerful YouTube automation workflows, such as:

* Automatically finding new niches
* Automatically tracking trends based on a niche
* AI-powered ideation based on outliers

<Callout>
  **Why code when AI can do it for you?**

  [Paste this link](https://tubelab.net/docs/llms-full.txt) in your AI and he will get the full context of TubeLab's API.

  ```
  https://tubelab.net/docs/llms-full.txt
  ```
</Callout>

## Call the API

<Steps>
  <Step>
    ### Create a TubeLab Account

    Sign-up to [TubeLab](https://tubelab.net/login) if you don't have an account yet.
  </Step>

  <Step>
    ### Create an API Key

    <Callout>You must have an [active subscription with available credits](https://tubelab.net/settings).</Callout>

    Create an API key [here](https://tubelab.net/developers) and copy it.

    **Beaware, this key won't be shown again.**
  </Step>

  <Step>
    ### Make your first request

    Authenticate by using the `Authorization` header and value as `Api-Key your-api-key`:

    <Tabs items={['javascript', 'python', 'curl']}>
      <Tab value="javascript">
        <DynamicCodeBlock
          lang="ts"
          code={`const myHeaders = new Headers();

myHeaders.append('Content-Type', 'application/json');
myHeaders.append("Authorization", "Api-Key ••••••");

fetch('https://public-api.tubelab.net/v1/outliers?query=minecraft', {
method: 'GET',
headers: myHeaders,
})
.then((response) => response.text())
.then((result) => console.log(result))
.catch((error) => console.error(error));`}
        />
      </Tab>

      <Tab value="python">
        <DynamicCodeBlock
          lang="python"
          code={`import requests

url = "https://public-api.tubelab.net/v1/outliers?query=minecraft"

payload = {}
headers = {
'Authorization': 'Api-Key ••••••'
}

response = requests.request("GET", url, headers=headers, data=payload)

print(response.text)
`}
        />
      </Tab>

      <Tab value="curl">
        <DynamicCodeBlock
          lang="shell"
          code={`curl --location 'https://public-api.tubelab.net/v1/outliers?query=minecraft'
--H 'Content-Type: application/json'
--H 'Authorization: Api-Key ••••••'`}
        />
      </Tab>
    </Tabs>
  </Step>
</Steps>

## Next steps

Now that you have made your first TubeLab API request, it's time to explore what else is possible:

<Cards>
  <Card href="/api/automation/quickstart" title="YouTube Automation" icon={<Icon icon="n8n" />}>
    Use our powerful n8n templates to automate niche finding, competition
    tracking, trends, ideation and much more.
  </Card>

  <Card href="/api/reference" title="Read the API reference" icon={<Icon icon="terminal" />}>
    Understand what YouTube data is available, and how to use it.
  </Card>
</Cards>

<br />


# Introduction
URL: /api/introduction

***

title: Introduction
description: Find new niches automatically, track your competition, new trends and more.
----------------------------------------------------------------------------------------

The [TubeLab](https://tubelab.net/) API is organized around [REST](https://en.wikipedia.org/wiki/REST). The API returns [JSON-encoded](https://www.json.org/json-en.html) responses, and uses standard HTTP response codes, authentication, and verbs.

To use TubeLab's API you must have an [API Key](https://tubelab.net/developers) and an [active subscription](https://tubelab.net/pricing) with [available credits](https://tubelab.net/credits).

<Card title="API BASE URL:">`https://public-api.tubelab.net/v1`</Card>

## Authentication

<Callout>[Create an API key here](https://tubelab.net/developers).</Callout>

All requests to the TubeLab API must include an `Authorization` header with your API key. You'll need to send this header yourself as `Authorization: Api-Key <your-api-key>`.

Here's an example with `curl`:

```bash
curl --location 'https://public-api.tubelab.net/v1/outliers?query=minecraft'
--H 'Content-Type: application/json'
--H 'Authorization: Api-Key <your-api-key>'
```

## Rate limits

To mitigate misuse and manage capacity on our API, we have implemented limits per api key.

**You're limited to `10` requests every minute per api-key within your available credits.**

Limits are designed to prevent API abuse, while minimizing impact on common customer usage patterns.

## Content types

TubeLab's API accepts JSON in request bodies and returns JSON in response bodies. You will need to send the content-type: `application/json` header in requests.

## Request size limits

The API has a maximum request body size of `100kb` per request.

## Status page

Check the availability of TubeLab's APIs at our [status page](https://status.tubelab.net/).

<iframe src="https://status.tubelab.net/badge?theme=light" width="250" height="30" frameBorder="0" scrolling="no" style={{ backgroundColor: "#f5f5f5", borderRadius: "10px" }} />


# Pricing
URL: /api/pricing

***

title: Pricing
description: Learn about TubeLab's API pricing structure
--------------------------------------------------------

For the latest pricing updates, check out [tubelab.net/pricing](https://tubelab.net/pricing).

## Credits System

Some API calls to TubeLab's API uses credits from your account. Your [credit balance](https://tubelab.net/credits) determines how many requests you can make.

Different endpoints may require different credit amounts per request.

### How does the credits system work?

Some **subscriptions comes with credits that refresh each billing cycle** and don't expire right away. Monthly subscribers can use their credits for up to two months - so January credits work through February.

**Annual subscribers get all their credits upfront** and can use them flexibly throughout their subscription, with credits staying active for over a month into the following year.

**Purchased credits** never expire but you must have an active subscription to use them.

## Pricing Table

| Endpoint                | Cost per request    |
| ----------------------- | ------------------- |
| `GET /outliers`         | `5 credits`         |
| `GET /outliers/related` | `5 credits`         |
| `GET /channels`         | `10 credits`        |
| `GET /channels/related` | `10 credits`        |
| `POST /scan`            | `50 to 100 credits` |
| `GET /scan/:id`         | `free`              |

**Note:** The cost of a [scan](/reference/scans) is based on the mode you choose.

| Mode     | Cost            |
| -------- | --------------- |
| Fast     | **50** credits  |
| Standard | **100** credits |

**Cached responses do not use credits**. This means that if you make a request to the same endpoint within a short period of time, you will not be charged extra credits.

## How to get credits?

You can get credits by subscribing to a [TubeLab Pro plan](https://tubelab.net/pricing) and by [topping-up your credits](https://tubelab.net/credits/top-up).

## What happens if I run out of credits?

You can purchase more credits at any time.

These extra credits work alongside your regular subscription credits and stay valid while your subscription is active.

## What happens when a request fails?

When a request fails, the credit will be refunded (reverted).


# Scanning
URL: /api/scanning

***

title: Scanning
description: TubeLab's API let's you scan YouTube to find public channels and outliers in any topic.
----------------------------------------------------------------------------------------------------

You can trigger new YouTube scans, for any niche.
**Allowing for tailored competitor research, in real-time.**

## Starting a YouTube Scan

You can trigger a new YouTube scan by calling the [`/scan` endpoint](/api/reference/post-scan).

**To successfully trigger a scan you need to have an [active subscription with available credits](https://tubelab.net/settings).**

## Searching the results

Once a scan is complete, you can search for the results by calling the [`/channels` endpoint](/api/reference/get-channels) or the [`/outliers` endpoint](/api/reference/get-outliers) with the `referenceId` property set to the desired scan `id`.

```bash
curl -X GET "https://public-api.tubelab.net/v1/channels?referenceId=8794a2ba-b4ca-40ca-9585-ca3fc501e31d" \
-H "Authorization: Api-Key <token>"

curl -X GET "https://public-api.tubelab.net/v1/outliers?referenceId=8794a2ba-b4ca-40ca-9585-ca3fc501e31d" \
-H "Authorization: Api-Key <token>"
```

## Webhooks

You can get notified when a scan status changes by creating a [webhook](/api/webhooks).

Once you've set your [webhook](/api/webhooks), you will receive a payload when the scan status changes:

<Callout>
  [TubeLab n8n Node](https://www.npmjs.com/package/n8n-nodes-tubelab) does this
  automatically for you.
</Callout>

```json
// body payload
{
  "type": "ProcessStatus",
  "time": "2025-09-20T14:36:52.211Z",
  "data": {
    "id": "8794a2ba-b4ca-40ca-9585-ca3fc501e31d",
    "status": "Running",
    "endedAt": null,
    "updatedAt": "2025-09-20T14:36:52.186Z"
  }
}
```

## Scan Modes and Pricing

<Callout>
  Scans are **resource intensive** and can **take a while to complete**.
</Callout>

There's two available modes that will stop the scan when one of the thresholds is reached.

| Mode     | Outliers Threshold | Channels Threshold | Cost            | Estimated Time     |
| -------- | ------------------ | ------------------ | --------------- | ------------------ |
| Fast     | 1000               | 100                | **50** credits  | 30 mins to 2 hours |
| Standard | 2500               | 250                | **100** credits | 2-4 hours          |

Scans are queued and processed in order, so the expected time is an estimate and can vary.


# Webhooks
URL: /api/webhooks

***

title: Webhooks
description: Listen for Tubelab events on your webhook endpoint so you can automatically trigger reactions.
-----------------------------------------------------------------------------------------------------------

import { Step, Steps } from "fumadocs-ui/components/steps";
import { Accordion, Accordions } from "fumadocs-ui/components/accordion";

<Callout>
  [TubeLab's n8n Node](https://www.npmjs.com/package/n8n-nodes-tubelab) handles
  webhooks automatically for you.
</Callout>

## Get started

To start receiving webhook events in your app:

1. Create a webhook endpoint handler to receive event data POST requests.
2. Test your webhook endpoint handler locally with our [mock request example](/api/webhooks#2-test-your-handler).
3. Register an enpoint in the Tubelab's [Developers dashboard](https://tubelab.net/developers).
4. Secure your webhook (optional)

**n8n Integration**:
If you're using n8n this is done automatically for you.

<Steps>
  <Step>
    ### 1. Create a handler

    Set up your endpoint function so that it:

    * Handles POST requests with JSON payloads
    * Quickly returns a successfull status code `2xx` prior to any complex operations
      that might cause a timeout
  </Step>

  <Step>
    ### 2. Test your handler

    Before you go-live with your webhook endpoint function, we recommend that you test your application integration.

    You can simply POST to your webhook endpoint with the following payload for a completed scan:

    ```json
    {
      "type": "ProcessStatus",
      "time": "2025-09-20T14:36:52.211Z",
      "data": {
        "id": "8794a2ba-b4ca-40ca-9585-ca3fc501e31d",
        "status": "Completed",
        "endedAt": "2025-09-20T14:36:52.186Z",
        "updatedAt": "2025-09-20T14:36:52.186Z"
      }
    }
    ```

    * `type`: always `"ProcessStatus"`
    * `status`: one of `"Running" | "Completed" | "ContinuedAsNew" | "Failed" | "Terminated" | "Suspended"`
    * `endedAt` present when `status` is `"Completed" | "Failed" | "Terminated" `
  </Step>

  <Step>
    ### 3. Register your webhook

    Create your webhook in [TubeLab's Developer Dashboard](https://tubelab.net/developers).

    Scroll down to the "Webhooks" section and click "Create Webhook" then fill in the following:

    * `Payload URL`: the URL of your webhook endpoint
    * `Secret`: define a secret key to secure your webhook (optional)

    Payload URLs must be **Secure HTTPS URLs** and be in the following format:

    ```bash
    https://<your-website>/<your-webhook-endpoint>
    ```
  </Step>

  <Step>
    ### 4. Secure your webhook (optional)

    You can set a secret to verify that a webhook delivery is from TubeLab.

    **To do this, you need to:**

    1. Create a secret token for your webhook
    2. Store the secret on your server
    3. Validate incoming requests using the payload & secret

    Start by going to [TubeLab's Developer Dashboard](https://tubelab.net/developers). On the webhook row, click on the actions and "Edit". **Here you can set the secret token or change an existing one.**

    When a secret is set, all requests will include a `X-TubeLab-Signature-256` header with a HMAC-SHA256 signature of the request body.

    Headers example:

    ```json
    // headers
    "x-tubelab-signature-256": "sha256=9db81febbc4334e338ce23e783e9114a012d68aae59e51eba375ed9493d67f80",
    "x-tubelab-delivery": "6f8a7b0b-5602-49b8-9dbf-a1c7bc02bb5f",
    "x-tubelab-event": "ProcessStatus",
    "x-tubelab-hook-id": "d0b88613-9ca6-4de2-b692-31b869173e76",
    ```

    <Accordions type="single">
      <Accordion title="Example validation code (Javascript)">
        ```js
        import * as crypto from 'crypto';


        // signature is the value of the x-tubelab-signature-256 header
        function verifySignature(payload: string, signature: string) {
          if (!signature) return false;

          const secret = 'secret'
          const expectedSignature = 'sha256=' + crypto
            .createHmac('sha256', secret)
            .update(JSON.stringify(payload), 'utf8')  // Use payload directly, don't JSON.stringify again
            .digest('hex');

          return crypto.timingSafeEqual(
            Buffer.from(signature),
            Buffer.from(expectedSignature)
          );
        }
        ```
      </Accordion>
    </Accordions>
  </Step>
</Steps>

This webhook implementation follows Github's [Webhook Signature Verification](https://docs.github.com/en/webhooks/using-webhooks/validating-webhook-deliveries#validating-webhook-deliveries) practises. Please refer to it for further details.


# Quickstart
URL: /api/automation/quickstart

***

title: Quickstart
description: Learn how to setup TubeLab with n8n and create your first workflow.
--------------------------------------------------------------------------------

import { Step, Steps } from "fumadocs-ui/components/steps";

You can easily integrate [TubeLab](https://tubelab.ai/) with [n8n](https://n8n.io/) to create powerful YouTube automation workflows.

This is a practical guide, and we'll create one example workflow:

* [**Trends Tracker**](/api/automation/trends-tracker): leverages TubeLab and AI to automatically create trends reports;

### Pre-requisites

* An active [TubeLab](https://tubelab.net/) subscription
* A valid [TubeLab API Key](https://tubelab.net/developers)
* A [self-hosted n8n instance](https://docs.n8n.io/hosting/self-hosted/installation/)

## Setup n8n with TubeLab

<Steps>
  <Step>
    ### Install TubeLab's Node

    <Callout>[TubeLab's n8n node](https://www.npmjs.com/package/n8n-nodes-tubelab) is currently under-review to be available on the official n8n marketplace. For the time being you can only installed it on self-hosted n8n instances.</Callout>

    1. Go to **Settings** > **Community Nodes** (`/settings/community-nodes`)
    2. Select **Install**.
    3. Enter `n8n-nodes-tubelab` in npm package name.
    4. **Agree to the risks** of using community nodes: select I understand the risks of installing unverified code from a public source.
    5. Select **Install**.
  </Step>

  <Step>
    ### Setup Credentials

    You must first authenticate with TubeLab by setting the `Api Key` in the node.

    1. Use **TubeLab's node**
    2. Under Credential to connect with, click **Create New Credential**.
    3. Paste your **TubeLab API key** and save.
  </Step>
</Steps>

## Next steps

Now that you have setup TubeLab with n8n, it's time to create your [first workflow](/api/automation/trends-tracker).


# Trends Tracker
URL: /api/automation/trends-tracker

***

title: Trends Tracker
description: Learn how to create an n8n workflow to track YouTube trends.
-------------------------------------------------------------------------

import { Step, Steps } from "fumadocs-ui/components/steps";
import { DynamicCodeBlock } from "fumadocs-ui/components/dynamic-codeblock";
import { Accordion, Accordions } from "fumadocs-ui/components/accordion";

<Accordions type="single">
  <Accordion title="YouTube Trends Tracker N8N Template (JSON)">
    <DynamicCodeBlock
      lang="json"
      code={`{
"name": "YouTube Trends Tracker",
"nodes": [
  {
    "parameters": {
      "rule": {
        "interval": [
          {
            "field": "minutes",
            "minutesInterval": 15
          }
        ]
      }
    },
    "type": "n8n-nodes-base.scheduleTrigger",
    "typeVersion": 1.2,
    "position": [0, -96],
    "id": "5c6b443d-35ce-4149-be01-98e115859d52",
    "name": "Schedule Trigger"
  },
  {
    "parameters": {
      "resource": "scan",
      "findBy": "channels",
      "channelIds": [
        "={{ $json['Your Channel ID'] }}",
        "={{ $json['Competition Channel ID'] }}"
      ],
      "mode": "test",
      "requestOptions": {

      }
    },
    "type": "n8n-nodes-tubelab.tubeLab",
    "typeVersion": 1,
    "position": [288, -96],
    "id": "71b7dc6b-e1d0-437c-8ab1-3a1b6d6fad8c",
    "name": "Start a scan",
    "credentials": {
      "tubeLabApi": {
        "id": "GKdo0gNFQ09H8MNp",
        "name": "TubeLab account"
      }
    }
  },
  {
    "parameters": {
      "modelId": {
        "__rl": true,
        "value": "gpt-5",
        "mode": "list",
        "cachedResultName": "GPT-5"
      },
      "messages": {
        "values": [
          {
            "content": "=You're a YouTube Channel Analyst. Your goal is to analyse trending videos from the competition and create an actionable report.\n\n\u003CCompetition\u003E\n{{ $input.all().map(item =\u003E \`\${item.json.snippet.title}\n\nID: \${item.json.id}\nViews: \${item.json.statistics.viewCount}\nAvg. View Ratio: \${\n(Math.round((item.json.statistics.averageViewsRatio) * 100) / 100).toFixed(1)}\nPublished: \${item.json.snippet.publishedAt}\n\`).join('--- \\n') }}\n\u003C/Competition\u003E\n\n\n\u003CTemplate\u003E\n# :fire: 5 Trending Competitor Videos\n\n**[Video title](https://youtube.com/watch?v=[id])**\nViews: X | [Avg. Views To Subs Ratio]X Outlier\nUrl:\nPublished: X ago\n\n(Exclude channels's own content)\n\n## :mag: Winning Patterns\n- **Topics**: Recurring themes\n- **Triggers**: Emotional/psychological angles\n- **Title Formulas**: Title templates that get clicks\n\n## :bulb: Ideas\n- [5 simple ideas based on trends]\n\n\n[End with a very short paragraph of unique learnings that I can use to capture more attention & views.]\n\u003C/Template\u003E\n\n\u003CGuidelines\u003E\n# Aesthetic Guidelines\n- Leverage code blocks for formulas/examples\n- Apply italic for explanations and bold for emphasis\n- Structure with clear visual hierarchy\n- Understand the main topic and ignore irrelevant videos\n\n# Success Metrics\nEnable users to:\n- Identify current winning content in their niche\n- Extract proven viral patterns\n- Create optimized videos with higher view/retention potential\n\n# Optimization Rules\n- Prioritize highest-impact insights\n- Use concise, actionable language\n- Combine related points efficiently\n- Maintain visual appeal within character limits\n\n# Core Parameters\n## Response Format: Discord markdown only\n- Character Limit: 2000 characters maximum\n- Execution Mode: Auto-execute both data collection tools immediately, then analyze\n\n## Discord Formatting Arsenal\n- *bold* | _italic_ | ~strikethrough~ | \`code\`\n- :emoji: for visual appeal\n- do not use seperators\n- do not use headers\n- avoid double \\n\\n within same topic header\n\u003C/Guidelines\u003E\n\nAnalysis:"
          }
        ]
      },
      "options": {

      }
    },
    "type": "@n8n/n8n-nodes-langchain.openAi",
    "typeVersion": 1.8,
    "position": [784, 272],
    "id": "b629e26d-787b-46aa-8897-6cad58be9e53",
    "name": "Analyse",
    "executeOnce": true,
    "credentials": {
      "openAiApi": {
        "id": "UsovRNT7XaBxAvud",
        "name": "OpenAi account"
      }
    }
  },
  {
    "parameters": {
      "assignments": {
        "assignments": [
          {
            "id": "6b331c06-8f77-4974-9c43-2bfe97083063",
            "name": "Your Channel ID",
            "value": "UChn5jutPQB_bRjnG80pzl5w",
            "type": "string"
          },
          {
            "id": "74b8051e-5d44-43e6-834c-28c7e3ca886a",
            "name": "Competition Channel ID",
            "value": "UCZLFu8bHbwtnIgWLg5UtINw",
            "type": "string"
          },
          {
            "id": "a1eecaa9-d1b6-45b4-9068-758c9871f7e5",
            "name": "Data Table ID",
            "value": "MkVwEdsCyF3voUYn",
            "type": "string"
          }
        ]
      },
      "options": {

      }
    },
    "type": "n8n-nodes-base.set",
    "typeVersion": 3.4,
    "position": [144, -96],
    "id": "031649f0-72e4-49fa-b886-fded72c8508d",
    "name": "Configuration"
  },
  {
    "parameters": {
      "authentication": "webhook",
      "content": "=**TubeLab Trends Report**",
      "options": {
        "avatar_url": "https://cdn.tubelab.net/icon-128x128.png",
        "username": "TubeLab"
      },
      "embeds": {
        "values": [
          {
            "description": "={{ $json.message.content }}",
            "author": "TubeLab",
            "color": "#FF0000",
            "timestamp": "={{ $now }}"
          }
        ]
      }
    },
    "type": "n8n-nodes-base.discord",
    "typeVersion": 2,
    "position": [1104, 272],
    "id": "c1fab59a-a185-4aa1-bd6f-e4a5d873dbce",
    "name": "Done",
    "webhookId": "92f239e2-810a-43f7-9811-f3d014ea4ae0",
    "credentials": {
      "discordWebhookApi": {
        "id": "3f9v78bblrCxYAsY",
        "name": "TubeLab Team Private"
      }
    }
  },
  {
    "parameters": {
      "content": "## YouTube Trends Tracker\n\nThis n8n template leverages [TubeLab](https://tubelab.net/) to scan your competition and then searches for high-performing videos related to your channel and creates a custom weekly report!\n\nUse cases:\n- Tracking your competition\n- Generating new ideas based on proven formats\n- Tracking trends\n\n### How it works\n1. Scans your niche every week\n2. Waits for scan completion\n3. Searches for outliers related to your channel\n4. Analyses outliers & creates a report\n5. Sends them to your Discord\n\n### How to use\nFor more information check the [official guide](https://tubelab.net/docs/api/automation/trends-tracker).\n\n1. Click on the \"Configuration\" node and fill out the inputs.\n\nHow to see a channel's ID? Use this: https://tubelab.net/video-extractor\n\n### Requirements\n- TubeLab Credentials\n- Discord Webhook\n\n### Improve for your use-case:\n- Rework prompt for your channel\n- Add transcript analysis of hooks\n- Add thumbnail analysis",
      "height": 816,
      "width": 448
    },
    "type": "n8n-nodes-base.stickyNote",
    "typeVersion": 1,
    "position": [-528, -272],
    "id": "dd7c1394-1fd8-4ee0-ba0b-03d3dcea7bda",
    "name": "Sticky Note"
  },
  {
    "parameters": {
      "content": "## Starts a Niche Scan (Every Week)\n\nFinds public channels and outliers of your niche.\n\nMore info: https://tubelab.net/docs/api/scanning",
      "height": 352,
      "width": 656,
      "color": 7
    },
    "type": "n8n-nodes-base.stickyNote",
    "typeVersion": 1,
    "position": [-48, -272],
    "id": "6a8f0225-f970-4f0d-a877-192746a7f3c3",
    "name": "Sticky Note1"
  },
  {
    "parameters": {
      "content": "## Create a Report\n\nWaits for niche scan, analyses the outliers & sends the report.",
      "height": 448,
      "width": 1360,
      "color": 7
    },
    "type": "n8n-nodes-base.stickyNote",
    "typeVersion": 1,
    "position": [-48, 96],
    "id": "480d80b0-7e16-4648-b1d1-15d8f92b321c",
    "name": "Sticky Note2"
  },
  {
    "parameters": {
      "conditions": {
        "options": {
          "caseSensitive": true,
          "leftValue": "",
          "typeValidation": "strict",
          "version": 2
        },
        "conditions": [
          {
            "id": "782064b8-b1d4-488d-a712-039b732ffa60",
            "leftValue": "={{ $json.status }}",
            "rightValue": "Completed",
            "operator": {
              "type": "string",
              "operation": "equals"
            }
          }
        ],
        "combinator": "and"
      },
      "options": {

      }
    },
    "type": "n8n-nodes-base.if",
    "typeVersion": 2.2,
    "position": [368, 272],
    "id": "c2331547-eea2-479e-ab40-c29d742b5fad",
    "name": "If"
  },
  {
    "parameters": {
      "operation": "update",
      "dataTableId": {
        "__rl": true,
        "value": "MkVwEdsCyF3voUYn",
        "mode": "list",
        "cachedResultName": "scans",
        "cachedResultUrl": "/projects/owxDEMWbp9q620sz/datatables/MkVwEdsCyF3voUYn"
      },
      "filters": {
        "conditions": [
          {
            "keyName": "scan",
            "keyValue": "={{ $json.data.id }}"
          }
        ]
      },
      "columns": {
        "mappingMode": "defineBelow",
        "value": {
          "status": "={{ $json.data.status }}"
        },
        "matchingColumns": [],
        "schema": [
          {
            "id": "scan",
            "displayName": "scan",
            "required": false,
            "defaultMatch": false,
            "display": true,
            "type": "string",
            "readOnly": false,
            "removed": true
          },
          {
            "id": "status",
            "displayName": "status",
            "required": false,
            "defaultMatch": false,
            "display": true,
            "type": "string",
            "readOnly": false,
            "removed": false
          }
        ],
        "attemptToConvertTypes": false,
        "convertFieldsToString": false
      }
    },
    "type": "n8n-nodes-base.dataTable",
    "typeVersion": 1,
    "position": [192, 272],
    "id": "ace9f6b8-7a97-4e88-94f0-d7d184151487",
    "name": "Update row(s)",
    "executeOnce": false,
    "alwaysOutputData": true
  },
  {
    "parameters": {
      "events": [
        "ProcessStatus"
      ]
    },
    "type": "n8n-nodes-tubelab.tubeLabTrigger",
    "typeVersion": 1,
    "position": [16, 272],
    "id": "9eac0846-9665-4aa3-841c-3b7caae65fbc",
    "name": "TubeLab Trigger",
    "webhookId": "4b5a959a-c5c8-406e-b189-861f28b0e8bb",
    "credentials": {
      "tubeLabApi": {
        "id": "GKdo0gNFQ09H8MNp",
        "name": "TubeLab account"
      }
    }
  },
  {
    "parameters": {
      "dataTableId": {
        "__rl": true,
        "value": "MkVwEdsCyF3voUYn",
        "mode": "list",
        "cachedResultName": "scans",
        "cachedResultUrl": "/projects/owxDEMWbp9q620sz/datatables/MkVwEdsCyF3voUYn"
      },
      "columns": {
        "mappingMode": "defineBelow",
        "value": {
          "scan": "={{ $json.id }}",
          "status": "={{ $json.status }}",
          "channelId": "={{ $('Configuration').item.json[\"Your Channel ID\"] }}",
          "competitionChannelId": "={{ $('Configuration').item.json[\"Competition Channel ID\"] }}"
        },
        "matchingColumns": [],
        "schema": [
          {
            "id": "scan",
            "displayName": "scan",
            "required": false,
            "defaultMatch": false,
            "display": true,
            "type": "string",
            "readOnly": false,
            "removed": false
          },
          {
            "id": "status",
            "displayName": "status",
            "required": false,
            "defaultMatch": false,
            "display": true,
            "type": "string",
            "readOnly": false,
            "removed": false
          },
          {
            "id": "channelId",
            "displayName": "channelId",
            "required": false,
            "defaultMatch": false,
            "display": true,
            "type": "string",
            "readOnly": false,
            "removed": false
          },
          {
            "id": "competitionChannelId",
            "displayName": "competitionChannelId",
            "required": false,
            "defaultMatch": false,
            "display": true,
            "type": "string",
            "readOnly": false,
            "removed": false
          }
        ],
        "attemptToConvertTypes": false,
        "convertFieldsToString": false
      },
      "options": {

      }
    },
    "type": "n8n-nodes-base.dataTable",
    "typeVersion": 1,
    "position": [448, -96],
    "id": "af36cc34-bb58-41b6-8df9-ca6bc389ca29",
    "name": "Insert row"
  },
  {
    "parameters": {
      "operation": "searchOutliersRelated",
      "relatedSearch": {
        "relatedChannelId": [
          "={{ $json.channelId }}",
          "={{ $json.competitionChannelId }}"
        ]
      },
      "filters": {

      },
      "requestOptions": {

      }
    },
    "type": "n8n-nodes-tubelab.tubeLab",
    "typeVersion": 1,
    "position": [592, 272],
    "id": "4e60b94e-cb1d-4137-8dd3-aed1982ca4cb",
    "name": "Search for similar outliers",
    "credentials": {
      "tubeLabApi": {
        "id": "GKdo0gNFQ09H8MNp",
        "name": "TubeLab account"
      }
    }
  }
],
"pinData": {

},
"connections": {
  "Schedule Trigger": {
    "main": [
      [
        {
          "node": "Configuration",
          "type": "main",
          "index": 0
        }
      ]
    ]
  },
  "Analyse": {
    "main": [
      [
        {
          "node": "Done",
          "type": "main",
          "index": 0
        }
      ]
    ]
  },
  "Configuration": {
    "main": [
      [
        {
          "node": "Start a scan",
          "type": "main",
          "index": 0
        }
      ]
    ]
  },
  "Start a scan": {
    "main": [
      [
        {
          "node": "Insert row",
          "type": "main",
          "index": 0
        }
      ]
    ]
  },
  "If": {
    "main": [
      [
        {
          "node": "Search for similar outliers",
          "type": "main",
          "index": 0
        }
      ],
      []
    ]
  },
  "Update row(s)": {
    "main": [
      [
        {
          "node": "If",
          "type": "main",
          "index": 0
        }
      ]
    ]
  },
  "TubeLab Trigger": {
    "main": [
      [
        {
          "node": "Update row(s)",
          "type": "main",
          "index": 0
        }
      ]
    ]
  },
  "Search for similar outliers": {
    "main": [
      [
        {
          "node": "Analyse",
          "type": "main",
          "index": 0
        }
      ]
    ]
  }
},
"active": false,
"settings": {
  "executionOrder": "v1"
},
"versionId": "f253f864-9821-49cb-9407-797bc7a7afce",
"meta": {
  "templateCredsSetupCompleted": true,
  "instanceId": "6b8e3b2e55cb06bbceeafc3b3f360ddc1dcc8fbbc8bd162464a41d1bb0ff411c"
},
"id": "S7nqPN1VFGwoFUu4",
"tags": []
}
  `}
    />
  </Accordion>
</Accordions>

Instead of manually searching for what's trending on your niche, you can automate the process with [TubeLab](https://tubelab.net/) and [n8n](https://n8n.io/).

Before starting, it helps to break down the process in smaller steps:

1. **Research**: we'll start by using your channel and TubeLab to spot outliers from your competitors;
2. **Analysis**: we can then prompt ChatGPT to analyse those videos;
3. **Report**: finally we prompt ChatGPT to create a report with the findings and send it to you.

**Note**: This is a simplified version of the workflow. You can extend it to include more steps, such as:

* Analysing viral hook formulas with the [Video Transcript](/api/reference/get-video-transcript) endpoint;
* Creating new ideas from comments with the [Video Comments](/api/reference/get-video-comments) endpoint;

![Trends Tracker](/trends-tracker.png)

## Pre-requisites

1. Refer to the [Quickstart](/api/automation/quickstart) guide to setup n8n with TubeLab and create the workflow.
2. OpenAI n8n node setup - check the [official n8n guide here](https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-langchain.openai/) or watch this [video](https://www.youtube.com/watch?v=IAhx81VLUlk).

<Steps>
  <Step>
    ## Research

    We want to spot what's trending first with fresh data:

    1. [Scan your niche](/api/automation/trends-tracker#scan-your-niche-optional) to get fresh data (optional);
    2. [Search for outlier videos](/api/automation/trends-tracker#search-for-outliers-from-your-competitors) from your competitors;

    ### Scan your niche (optional)

    With TubeLab you can scan any niche to find outliers and channels that relevant & real-time

    * Add a **TubeLab** node to your workflow and select **Start a scan**. Set:
      * Find by: **Channels**;
      * Channel IDS: **Your Channel ID and your competitors.** (max 5 channels)

    <Callout>
      **How to find channel IDs?** Paste any video in [TubeLab's Video
      Extractor](https://tubelab.net/video-extractor) and copy the channel ID.
    </Callout>

    **Note**: a niche scan is an expensive operation (credits-wise). You can skip this step. Check the [pricing table here](/api/pricing#pricing-table).

    ### Search for outliers from your competitors

    * Add a **Wait** node to wait for 2 hours to complete the scan.
    * Add a **TubeLab** node and select **Search for similar outliers**. Set:
      * Similar by: **Channels**;
      * Channels: **Channel IDs from previous step**;
      * Filters:
        * Content Kind: **Video**;
        * Published At: **Last 3 Months**;
        * Views: **From 5,000**.

    <Callout>
      The [**Wait**
      node](https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.wait/)
      won't grantee that the fresh data is available. However TubeLab's data is
      probably already enough to get decent results.
    </Callout>

    **Note:** For better results use TubeLab's **On scan status change** trigger node in another flow (within the same workflow) so you can run the workflow again when the scan is complete.
  </Step>

  <Step>
    ## Analysis

    Now let's ask ChatGPT to analyse the videos and create a report.

    Here's the prompt:

    <DynamicCodeBlock
      lang="mdx"
      code={`
You're a YouTube Channel Analyst. Your goal is to analyse trending videos from the competition and create an actionable report.

<Competition>
{{ $input.all().map(item => \`\${item.json.snippet.title}

ID: \${item.json.id}
Views: \${item.json.statistics.viewCount}
Avg. View Ratio: \${
(Math.round((item.json.statistics.averageViewsRatio) \* 100) / 100).toFixed(1)}
Published: \${item.json.snippet.publishedAt}
\`).join('--- \n') }}
\`} />

</Competition>

<Template>
# :fire: 5 Trending Competitor Videos

**[Video title](https://youtube.com/watch?v=[id])**
Views: X | [Avg. Views To Subs Ratio]X Outlier
Url:
Published: X ago

(Exclude channels's own content)

## :mag: Winning Patterns

- **Topics**: Recurring themes
- **Triggers**: Emotional/psychological angles
- **Title Formulas**: Title templates that get clicks

## :bulb: Ideas

- [5 simple ideas based on trends]

[End with a very short paragraph of unique learnings that I can use to capture more attention & views.]

</Template>

<Guidelines>
# Aesthetic Guidelines
- Leverage code blocks for formulas/examples
- Apply italic for explanations and bold for emphasis
- Structure with clear visual hierarchy
- Understand the main topic and ignore irrelevant videos

# Success Metrics

Enable users to:

- Identify current winning content in their niche
- Extract proven viral patterns
- Create optimized videos with higher view/retention potential

# Optimization Rules

- Prioritize highest-impact insights
- Use concise, actionable language
- Combine related points efficiently
- Maintain visual appeal within character limits

# Core Parameters

## Response Format: Discord markdown only

- Character Limit: 2000 characters maximum
- Execution Mode: Auto-execute both data collection tools immediately, then analyze

## Discord Formatting Arsenal

- \_bold\_ | \_italic\_ | ~strikethrough~ | \`code\`
- :emoji: for visual appeal
- do not use seperators
- do not use headers
- avoid double \n\n within same topic header
</Guidelines>

Analysis:
`}
    />
  </Step>

  <Step>
    ## Send Report

    Finally I decided to send the report to a Discord channel.

    All you need to do is install the **Discord Node** and connect your channels' webhook.
  </Step>
</Steps>

## That's it!

Imagine trying to do all of this manually. It would take you hours to search for this outliers and then you would need to manually analyse the videos and write up the report.

With TubeLab and n8n you can automate the process and get the report every week without any effort.

## Next steps

Now that you have setup TubeLab with n8n, it's time to create your first workflow.


# Channel Shorts
URL: /api/reference/get-channel-shorts

***

title: Channel Shorts
full: true
\_openapi:
method: GET
route: /channel/shorts/{id}
toc: \[]
structuredData:
headings: \[]
contents:

* content: Get shorts from a YouTube channel with sampled metrics.

***

{/* This file was generated by Fumadocs. Do not edit this file directly. Any changes should be made by running the generation command again. */}

Get shorts from a YouTube channel with sampled metrics.

<APIPage document={"./openapi.json"} operations={[{ path: "/channel/shorts/{id}", method: "get" }]} webhooks={[]} hasHead={false} />


# Channel Videos
URL: /api/reference/get-channel-videos

***

title: Channel Videos
full: true
\_openapi:
method: GET
route: /channel/videos/{id}
toc: \[]
structuredData:
headings: \[]
contents:

* content: Get videos from a YouTube channel with sampled metrics.

***

{/* This file was generated by Fumadocs. Do not edit this file directly. Any changes should be made by running the generation command again. */}

Get videos from a YouTube channel with sampled metrics.

<APIPage document={"./openapi.json"} operations={[{ path: "/channel/videos/{id}", method: "get" }]} webhooks={[]} hasHead={false} />


# Scan
URL: /api/reference/get-scan

***

title: Scan
full: true
\_openapi:
method: GET
route: /scan/{id}
toc: \[]
structuredData:
headings: \[]
contents:

* content: >-
  Get a scan by id.

  Read the [**scanning** documentation](/api/scanning) to understand how
  to use this endpoint.

***

{/* This file was generated by Fumadocs. Do not edit this file directly. Any changes should be made by running the generation command again. */}

Get a scan by id.

Read the [**scanning** documentation](/api/scanning) to understand how to use this endpoint.

<APIPage document={"./openapi.json"} operations={[{ path: "/scan/{id}", method: "get" }]} webhooks={[]} hasHead={false} />


# Video Comments
URL: /api/reference/get-video-comments

***

title: Video Comments
full: true
\_openapi:
method: GET
route: /video/comments/{id}
toc: \[]
structuredData:
headings: \[]
contents:

* content: Get the last 100 comments of a YouTube video.

***

{/* This file was generated by Fumadocs. Do not edit this file directly. Any changes should be made by running the generation command again. */}

Get the last 100 comments of a YouTube video.

<APIPage document={"./openapi.json"} operations={[{ path: "/video/comments/{id}", method: "get" }]} webhooks={[]} hasHead={false} />


# Video Details
URL: /api/reference/get-video-details

***

title: Video Details
full: true
\_openapi:
method: GET
route: /video/{id}
toc: \[]
structuredData:
headings: \[]
contents:

* content: Get details of a YouTube video.

***

{/* This file was generated by Fumadocs. Do not edit this file directly. Any changes should be made by running the generation command again. */}

Get details of a YouTube video.

<APIPage document={"./openapi.json"} operations={[{ path: "/video/{id}", method: "get" }]} webhooks={[]} hasHead={false} />


# Video Transcript
URL: /api/reference/get-video-transcript

***

title: Video Transcript
full: true
\_openapi:
method: GET
route: /video/transcript/{id}
toc: \[]
structuredData:
headings: \[]
contents:

* content: Get the transcript of a YouTube video.

***

{/* This file was generated by Fumadocs. Do not edit this file directly. Any changes should be made by running the generation command again. */}

Get the transcript of a YouTube video.

<APIPage document={"./openapi.json"} operations={[{ path: "/video/transcript/{id}", method: "get" }]} webhooks={[]} hasHead={false} />


# Scan
URL: /api/reference/post-scan

***

title: Scan
full: true
\_openapi:
method: POST
route: /scan
toc: \[]
structuredData:
headings: \[]
contents:

* content: >-
  Start a YouTube scan to search for outliers and channels on any given
  topic.

  Read the [**scanning** documentation](/api/scanning) to understand how
  to use this endpoint.

***

{/* This file was generated by Fumadocs. Do not edit this file directly. Any changes should be made by running the generation command again. */}

Start a YouTube scan to search for outliers and channels on any given topic.

Read the [**scanning** documentation](/api/scanning) to understand how to use this endpoint.

<APIPage document={"./openapi.json"} operations={[{ path: "/scan", method: "post" }]} webhooks={[]} hasHead={false} />


# Similar Channels
URL: /api/reference/search-channels-related

***

title: Similar Channels
full: true
\_openapi:
method: GET
route: /search/channels/related
toc: \[]
structuredData:
headings: \[]
contents:

* content: >-
  Search for YouTube channels with **related content to another
  channel**.

***

{/* This file was generated by Fumadocs. Do not edit this file directly. Any changes should be made by running the generation command again. */}

Search for YouTube channels with **related content to another channel**.

<APIPage document={"./openapi.json"} operations={[{ path: "/search/channels/related", method: "get" }]} webhooks={[]} hasHead={false} />


# Channels
URL: /api/reference/search-channels

***

title: Channels
full: true
\_openapi:
method: GET
route: /search/channels
toc: \[]
structuredData:
headings: \[]
contents:

* content: >-
  Search for channels directly from the [YouTube Niche
  Finder](https://tubelab.net/youtube-niche-finder) with AI enhanced
  data and 30+ filters. Updated in real-time, 24/7.

***

{/* This file was generated by Fumadocs. Do not edit this file directly. Any changes should be made by running the generation command again. */}

Search for channels directly from the [YouTube Niche Finder](https://tubelab.net/youtube-niche-finder) with AI enhanced data and 30+ filters. Updated in real-time, 24/7.

<APIPage document={"./openapi.json"} operations={[{ path: "/search/channels", method: "get" }]} webhooks={[]} hasHead={false} />


# Similar Outliers
URL: /api/reference/search-outliers-related

***

title: Similar Outliers
full: true
\_openapi:
method: GET
route: /search/outliers/related
toc: \[]
structuredData:
headings: \[]
contents:

* content: >-
  Search for YouTube outliers with **related content to another
  outlier(s)**.

***

{/* This file was generated by Fumadocs. Do not edit this file directly. Any changes should be made by running the generation command again. */}

Search for YouTube outliers with **related content to another outlier(s)**.

<APIPage document={"./openapi.json"} operations={[{ path: "/search/outliers/related", method: "get" }]} webhooks={[]} hasHead={false} />


# Outliers
URL: /api/reference/search-outliers

***

title: Outliers
full: true
\_openapi:
method: GET
route: /search/outliers
toc: \[]
structuredData:
headings: \[]
contents:

* content: >-
  Search for videos directly from the [YouTube Outliers
  Finder](https://tubelab.net/youtube-outliers-finder) library with AI
  enhanced data and 30+ filters. Updated in real-time, 24/7.

***

{/* This file was generated by Fumadocs. Do not edit this file directly. Any changes should be made by running the generation command again. */}

Search for videos directly from the [YouTube Outliers Finder](https://tubelab.net/youtube-outliers-finder) library with AI enhanced data and 30+ filters. Updated in real-time, 24/7.

<APIPage document={"./openapi.json"} operations={[{ path: "/search/outliers", method: "get" }]} webhooks={[]} hasHead={false} />