# LinkedIn Company Audience Builder (ABM) (`memo23/linkedin-audience-builder`) Actor

Turn website domains into a LinkedIn Campaign Manager Company List audience. Paste any domain list — the actor finds each company's LinkedIn page URL, name, and location from its own website and emits upload-ready CSV columns with LinkedIn's exact template names. Optional contact emails.

- **URL**: https://apify.com/memo23/linkedin-audience-builder.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Lead generation, AI, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## LinkedIn Company Audience Builder — Domains → Campaign Manager CSV

Turn a list of **website domains** into a **LinkedIn Campaign Manager Company List audience** — ready to upload, no post-processing.
Paste your domain list and the actor resolves each company's **LinkedIn page URL, company name, and location metadata from the company's own website**, then emits rows with the exact column names LinkedIn's audience template expects.
No LinkedIn scraping, no login, no fragile third-party chains: one self-contained pipeline, billed per company.

#### How it works

![How it works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-linkedin-audience-builder.png)

#### ✨ Why use this audience builder?

- **Skip manual CSV construction.** LinkedIn's Company List template demands very specific column names — the dataset already uses them (`companyname`, `companywebsite`, `companyemaildomain`, `linkedincompanypageurl`, …).
- **No LinkedIn scraping = no blocks.** Everything is resolved from each company's own public website (social links, JSON-LD, OpenGraph), so the pipeline can't get stuck behind LinkedIn's authwall.
- **Any domain list works.** Bare domains and full URLs are both accepted — paste straight from a CRM export or spreadsheet column.
- **Higher match rates.** Rows carry name + website + email domain + LinkedIn page URL, giving Campaign Manager four match signals per company.
- **Optional contact emails.** Flip one toggle to also mine each site's contact/about pages for an email — the same list feeds your cold outreach.
- **Fast and self-contained.** One to five HTTP requests per domain, high concurrency, automatic retries.

#### 🎯 Use cases

| Who | What they do with it |
|---|---|
| **ABM marketers** | Turn a target-account domain list into a LinkedIn Company List audience in minutes |
| **Agencies** | Build per-client matched audiences from CRM exports without manual lookups |
| **Sales ops** | Enrich domain lists with LinkedIn company URLs + contact emails for outbound |
| **Growth teams** | Retarget the companies that visited your site (domain list → LinkedIn ads) |
| **Data teams** | Bulk-resolve LinkedIn company pages for thousands of domains |

#### 📥 Supported inputs

| Input | Example |
|---|---|
| Bare domains | `apify.com` |
| Full URLs | `https://www.apify.com/pricing` (reduced to `apify.com`) |

Domains are normalised and deduplicated. **Not supported:** scraping LinkedIn itself (member counts, follower counts, employee lists) — this actor deliberately never touches linkedin.com.

#### 🔄 How it works

1. **Collect** domains from the input field; normalise and deduplicate.
2. **Fetch** each company's homepage in parallel.
3. **Resolve** the LinkedIn company URL from social links and JSON-LD `sameAs`; if it's not on the homepage, check up to `maxPagesPerDomain − 1` contact/about/imprint pages.
4. **Extract** the company name (JSON-LD → OpenGraph → title) and any location metadata.
5. **Emit** one row per company with LinkedIn's exact template columns; diagnostics ride along in underscore-prefixed fields.
6. **Download** the CSV and upload it: Campaign Manager → Plan → Audiences → Create → Upload a list → **Company list**.

#### ⚙️ Input parameters

| Field | Type | Default | Description |
|---|---|---|---|
| `domains` | array | — | Bare domains or full URLs |
| `maxPagesPerDomain` | integer | `5` | Pages visited per domain hunting for the LinkedIn URL (1 = homepage only) |
| `skipDomainsWithoutLinkedIn` | boolean | `false` | Drop companies with no LinkedIn URL found |
| `enrichEmails` | boolean | `false` | Also mine each site for a contact email |
| `maxItems` | integer | `1000` | Hard cap on companies processed |
| `maxConcurrency` | integer | `10` | Domains processed in parallel |
| `proxy` | object | Apify proxy | Defaults work — these are ordinary websites |

#### 📊 Output overview

One row per company. The first ten columns are LinkedIn's Company List template, verbatim — export those and upload. Underscore-prefixed fields are diagnostics (status, pages checked, where the LinkedIn URL was found) and are easy to exclude from the CSV export.

#### 📦 Output sample

```json
{
    "companyname": "Anthropic",
    "companywebsite": "https://anthropic.com",
    "companyemaildomain": "anthropic.com",
    "linkedincompanypageurl": "https://www.linkedin.com/company/anthropicresearch",
    "stockticker": "",
    "industry": "",
    "city": "",
    "state": "",
    "companycountry": "",
    "zipcode": "",
    "_domain": "anthropic.com",
    "_status": "ok",
    "_pagesChecked": 1,
    "_linkedinFoundOn": "https://anthropic.com/",
    "_scrapedAt": "2026-07-15T09:33:26.566Z"
}
````

To export ONLY the template columns, add `&fields=companyname,companywebsite,companyemaildomain,linkedincompanypageurl,stockticker,industry,city,state,companycountry,zipcode` to the dataset's CSV download URL.

#### 🗂 Key output fields

| Group | Fields |
|---|---|
| **LinkedIn template** | `companyname`, `companywebsite`, `companyemaildomain`, `linkedincompanypageurl`, `stockticker`, `industry`, `city`, `state`, `companycountry`, `zipcode` |
| **Diagnostics** | `_domain`, `_status`, `_pagesChecked`, `_linkedinFoundOn`, `_scrapedAt` |
| **Email enrichment**\* | `_contactEmail`, `_emailEnrichment` (\*with `enrichEmails`) |

#### ❓ FAQ

**Why doesn't the actor scrape LinkedIn for industries and locations?**
LinkedIn aggressively blocks anonymous access, which makes chained LinkedIn scrapers slow, expensive, and flaky. Campaign Manager matches uploaded companies on name + website + email domain + page URL — all resolvable from the company's own site — so this pipeline stays fast and reliable. Location fields ARE filled when the company publishes them in its own structured data.

**What if a company's LinkedIn URL isn't found?**
The row is still emitted with an empty `linkedincompanypageurl` (LinkedIn matches on the other three signals). Set `skipDomainsWithoutLinkedIn` to drop those rows instead. `_linkedinFoundOn` tells you which page the URL came from when found.

**What's the minimum audience size LinkedIn accepts?**
Campaign Manager requires at least 300 matched members for an audience to serve; LinkedIn recommends uploading 1,000+ companies. Plan your list size accordingly.

**Do I need a proxy?**
The default Apify proxy is fine — the actor only fetches ordinary company websites.

#### 💬 Support

- 🐛 Found a bug? Open an issue on the actor's **Issues** tab in the Apify Console.
- 💡 Need a custom column, CRM integration, or bigger pipeline? Message me through Apify.

#### 🛠 Additional services

Need audience refreshes on a schedule, deduplication against an existing CRM export, or a combined "audience + verified contact emails" pipeline? I build custom solutions — get in touch via Apify.

#### 🔎 Explore more scrapers

Check my Apify profile for 300+ actors: [apify.com/memo23](https://apify.com/memo23) — lead-gen, directories, marketplaces, and more.

***

### ⚠️ Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by LinkedIn Corporation, Microsoft, or Google. All trademarks mentioned are the property of their respective owners.

The actor accesses only the public websites of the companies you supply — it does not access linkedin.com, does not scrape LinkedIn member data, and does not bypass any login. Users are responsible for ensuring their use complies with the target sites' Terms of Service, LinkedIn's advertising policies, applicable data-protection law (GDPR, CCPA, etc.), and any contractual obligations of their own organisation.

***

### SEO Keywords

linkedin audience builder, linkedin company list csv, linkedin campaign manager audience upload, abm audience builder, account based marketing tool, domain to linkedin company url, linkedin matched audience generator, company list template linkedin, linkedin ads audience csv, bulk find linkedin company pages, website to linkedin page finder, b2b audience builder, target account list linkedin, linkedin ads targeting data, domain list to linkedin audience, company enrichment for linkedin ads, linkedin abm campaign data, find company linkedin url from domain

# Actor input Schema

## `domains` (type: `array`):

Website domains to enrich into a LinkedIn audience. Bare domains (`apify.com`) and full URLs are both accepted; duplicates are removed.

## `maxPagesPerDomain` (type: `integer`):

How many pages the actor visits per domain while hunting for the LinkedIn company URL: the homepage plus up to N-1 contact/about/imprint pages. 1 = homepage only.

## `skipDomainsWithoutLinkedIn` (type: `boolean`):

Drop companies whose LinkedIn page couldn't be found instead of emitting them with an empty `linkedincompanypageurl`. Campaign Manager still matches on name + website + email domain, so keeping them usually widens the audience.

## `enrichEmails` (type: `boolean`):

Best-effort: also reads each company site's contact/about pages for a contact email — adds `_contactEmail` and `_emailEnrichment` columns. Handy when the same list feeds cold outreach.

## `maxItems` (type: `integer`):

Hard cap on companies processed.

## `maxConcurrency` (type: `integer`):

Domains processed in parallel.

## `proxy` (type: `object`):

Company sites are ordinary websites — the default Apify proxy works fine.

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "anthropic.com",
    "notion.so"
  ],
  "maxPagesPerDomain": 5,
  "skipDomainsWithoutLinkedIn": false,
  "enrichEmails": false,
  "maxItems": 1000,
  "maxConcurrency": 10,
  "proxy": {
    "useApifyProxy": true
  }
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "domains": [
        "apify.com",
        "anthropic.com",
        "notion.so"
    ],
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/linkedin-audience-builder").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "domains": [
        "apify.com",
        "anthropic.com",
        "notion.so",
    ],
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/linkedin-audience-builder").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "domains": [
    "apify.com",
    "anthropic.com",
    "notion.so"
  ],
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call memo23/linkedin-audience-builder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=memo23/linkedin-audience-builder",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Company Audience Builder (ABM)",
        "description": "Turn website domains into a LinkedIn Campaign Manager Company List audience. Paste any domain list — the actor finds each company's LinkedIn page URL, name, and location from its own website and emits upload-ready CSV columns with LinkedIn's exact template names. Optional contact emails.",
        "version": "0.0",
        "x-build-id": "NSOBTId5mgyCRsMia"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~linkedin-audience-builder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-linkedin-audience-builder",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/memo23~linkedin-audience-builder/runs": {
            "post": {
                "operationId": "runs-sync-memo23-linkedin-audience-builder",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/memo23~linkedin-audience-builder/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-linkedin-audience-builder",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "domains": {
                        "title": "Website domains",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Website domains to enrich into a LinkedIn audience. Bare domains (`apify.com`) and full URLs are both accepted; duplicates are removed.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPagesPerDomain": {
                        "title": "Max pages per domain",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many pages the actor visits per domain while hunting for the LinkedIn company URL: the homepage plus up to N-1 contact/about/imprint pages. 1 = homepage only.",
                        "default": 5
                    },
                    "skipDomainsWithoutLinkedIn": {
                        "title": "Skip companies without a LinkedIn URL",
                        "type": "boolean",
                        "description": "Drop companies whose LinkedIn page couldn't be found instead of emitting them with an empty `linkedincompanypageurl`. Campaign Manager still matches on name + website + email domain, so keeping them usually widens the audience.",
                        "default": false
                    },
                    "enrichEmails": {
                        "title": "Find contact emails (experimental, free)",
                        "type": "boolean",
                        "description": "Best-effort: also reads each company site's contact/about pages for a contact email — adds `_contactEmail` and `_emailEnrichment` columns. Handy when the same list feeds cold outreach.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Maximum companies",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on companies processed.",
                        "default": 1000
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Domains processed in parallel.",
                        "default": 10
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Company sites are ordinary websites — the default Apify proxy works fine.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
