# Company Lookalike Finder (`cloudastra-technologies/company-lookalike-finder`) Actor Find similar companies from 1 to 10 seed domains. A ranked lookalike list for prospecting and account list building, each match with the source page that proves it. No LinkedIn, no API key, pay per result. - **URL**: https://apify.com/cloudastra-technologies/company-lookalike-finder.md - **Developed by:** [Cloudastra Technologies](https://apify.com/cloudastra-technologies) (community) - **Categories:** Lead generation, Business, Marketing - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $8.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/actors/running/actors-in-store.md#pay-per-event ## What's an Apify Actor? An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes. 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. Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md. ## 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. Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run. For examples already wired to this Actor's own input schema, see the [API](#api) section below. Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`). # README ## Company Lookalike Finder **Give it 1 to 10 companies you already like. Get back a ranked list of similar companies, with the evidence for every single match.** Every lead tool returns a list. This one shows you why each row is on it. **Try it on your own seeds first.** Turn on `preview` and a trial of up to 25 results costs about $0.20. An Apify free account comes with monthly platform credit, so a first trial normally costs nothing out of pocket. *** ### What you get Seed it with three payment companies: ```json { "seedDomains": ["stripe.com", "adyen.com", "checkout.com"], "maxResults": 100 } ``` You get back a ranked dataset. Every row carries its reasoning: | domain | score | country | matched terms | |---|---|---|---| | spreedly.com | 77 | null | agentic commerce, payment methods, fraud prevention | | payplug.com | 76 | null | acceptance rate, every stage | | embed.co | 76 | NL | payment methods, help you build, payment providers | | monei.com | 76 | ES | payment methods, accept payments, customer experience | | quickpay.net | 76 | null | payment methods, accept payments, flexible payment | | connectpay.com | 74 | LT | accept payments, financial services, customer experience | | gocardless.com | 74 | null | one platform, make payments, integration options | | hyperswitch.io | 73 | null | payment methods, customer experience, everything you need | | tipalti.com | 73 | US | payment methods, one platform, customer stories | **What is measured and what is not, so you can weigh the table.** These are the first nine rows of an ordinary run on 2026-08-27 against those three seeds, with no settings changed, copied out unedited. Not a hand-picked list: the run found and ranked them. **Including the one we would call a miss.** Tipalti at 73 does accounts payable automation, which is the paying side rather than the accepting side, so by our own definition it is not a lookalike for these seeds. It is in the table because it was in the run, and hiding it would tell you less about what you are buying than showing it does. Of the top ten on that run, eight were companies genuinely in the seeds' business, one was Tipalti, and one we could not judge either way. We are counting the way we would want a supplier to count for us. That evidence array is the part nobody else gives you. Each row records the page that produced it, so you can click through and check our work in about five seconds. If a match is wrong, you can see exactly why it was wrong. `country` is filled where the site states one and `null` where it does not. We read it from a postal address, a country-code domain or an explicit "headquartered in" claim, and leave it blank otherwise, because a wrong country on a list you are about to contact is worse than a missing one. On the run above it was populated on twelve rows of thirty-six. #### What the score means, and how to filter on it **Read the score as a ranking, not as a percentage.** It is not "50% similar". It places a company in the similarity range this scorer produces against your seeds, and it is comparable between runs of the same actor version. Real bands, measured by hand-checking every row of the run above against what each company actually sells: Well over a hundred rows across four runs, every one checked by hand against what the company actually sells: | score | what it means in practice | how often it was a real match | |---|---|---| | **70 and up** | the same business as your seeds | **about 8 in 10** | | 60 to 69 | mixed, and more often adjacent than not | about 3 to 4 in 10 | | 50 to 59 | close competitors and unrelated businesses both land here | see the note below | | 1 to 49 | usually a different business that happens to use similar words | not separately measured | | 0 | we read the page and identified it as not a company at all | never returned by default | **Seventy is where the list is strongest, and seventy is the default.** Above 70, about eight rows in ten are genuinely in your seeds' business. Between 60 and 69 it is three to four in ten, and we would rather not bill you for a band where most rows are ones you have to sort out by hand. **The rows just under the cut are not thrown away.** Everything that scored from 60 to 69 is written to the `nearMisses` output next to the run summary, with its score and the terms it matched, and you are not charged for any of it. If a company you expected is sitting there at 64, you can re-run at 60 knowing exactly what you will get. **Be honest about the 50 to 59 band, because we are not certain about it.** In some industries real competitors sit there: when we checked the actor against seed sets outside payments we found two well known HR platforms at 59 and 53 and two large e-commerce platforms at 59 and 53, so a buyer seeding three e-commerce platforms at a floor of 70 gets a short list. Against that, in payments that band was mostly companies in other businesses. Both measurements are real and they disagree. **If your seeds are outside payments and the list comes back short, set `minSimilarity` to 50** and judge the close calls yourself; the run summary tells you how many rows the floor removed. We used to default to 1 and return everything we scored. On a run we checked by hand that meant thirty-six rows of which eighteen were companies in an unrelated business, and you paid for all thirty-six. We would rather bill you for the rows you can use than the ones you have to sort. **The run tells you how many rows the filter removed**, so a short list always explains itself. **Lower it when you want reach rather than precision.** `minSimilarity: 1` returns everything we could score, including real companies in other lines of work. `0` also returns the pages we identified as not companies at all: parked domains, directories, trade publications and review sites, which all score 0. Nothing you filter out is ever charged for. **Raise it when you want a shortlist.** The top ten of any run is the strongest part of it: on the run above, **nine of the ten** were companies genuinely in the seeds' business, and across four measured runs the top 25 was between 78% and 92% genuine. **One honest caveat about the default.** On the run above, Square scored 30. Its homepage is built in the browser and gives us very little to read, so a company you would certainly want sits below the default cut. If a name you expected is missing, set `minSimilarity` to 1 and look further down before concluding we did not find it. ### Who this is for - **Agencies and SDR teams** building a prospect list from a handful of good accounts - **Founders** sizing a niche before committing to it - **Anyone with a customer list** who wants more companies that look like the best ones - **Recruiters and researchers** mapping who else operates in an industry If you can name three companies you want more of, this works for you. ### Already have the list? Score it instead Sometimes you do not need more companies. You need to know which of the ones you already have are worth your time. Put your list in `candidateDomains`, or point `candidateDomainsDataset` at an Apify dataset holding it, and this actor stops searching entirely. It reads each company you named, scores it against your seed companies, and hands the list back ranked, with the same evidence and the same filters as any other run. What it is good for: - A trade show or conference exhibitor list, ranked before you work it - A Companies House or registry pull, narrowed to the ones in your business - Your own CRM, sorted by how much each account looks like your best ones - Anything Lead List Cleaner just cleaned up, since its output plugs straight in Two things worth knowing. Your seed companies are still required, because the score is a comparison and there has to be something to compare against. And every filter still applies: a company you supplied that scores below `minSimilarity` is withheld and is not charged, exactly like any other row. Supplying a list is not a way to be billed for it. One run scores up to 5,000 companies; split a longer list across runs rather than having one stop partway down it. In preview mode the first 25 companies you supplied are scored, so you can check the shape of the result before spending on the whole list. A list where none of the entries is a usable domain is refused up front, with the count, rather than being quietly treated as no list at all. Rows from this mode come back with `discoveredVia: ["your_list"]`, and their evidence carries no search query and no source URL, because there was no search. Everything else on the row is read from the company's own site the same way it always is. ### What a run does We read your seed companies' own websites to learn what they sell, in their own words. We then look across the web for companies described the same way, read each one's homepage, and score it against your seeds. The strongest matches widen the search further, still scored against your seeds, so the list grows without drifting into a different market. Duplicates, directories, dead sites and anything your filters exclude are dropped before you are charged. What reaches you is ranked, deduplicated, and carries the page each row was found on. Set `expandFromResults` to `false` to skip the widening step; a preview run skips it automatically. ### What makes it different **1. Evidence on every row.** Source URL included. Every other tool hands you a list and asks you to trust it. **2. Nothing to sign up for.** No subscription, no seat licence, no credit bundle to buy up front, no minimum commitment, no sales call. You run it, you pay for the rows you got, you stop whenever you want. The established tools in this category are annual contracts with per-seat pricing and credit packs that expire. That is the comparison that matters, and it is the reason this exists as an actor instead of a SaaS product. **3. It tells you when it is unsure.** Fields we cannot establish from a company's own website come back empty rather than guessed. A wrong country on a list you are about to contact is worse than a blank one. ### Pricing **$8 per 1,000 results.** You pay for companies returned, plus a start fee of $0.00005 per run, which is a two-hundredth of a cent. Nothing else. - Companies filtered out by your `countries`, `excludeDomains` or `minSimilarity` settings are **not returned and not charged** - Dead sites and parked domains are dropped before scoring and are **never charged**. Directories and listing pages are dropped by the same check, and it is good but not perfect: one that gets past it can score in the fifties or sixties. The default floor of 70 keeps those out of the billed rows; if you lower it for reach, expect to sort a few of them out by hand - Your own seed domains never appear in the output and are never charged - If you set a maximum charge on the run, you get exactly as many results as it covers, and the run summary says so. Nothing is returned unbilled and nothing is billed beyond your limit - **Try it first:** turn on `preview` to cap a run at 25 results. A trial costs about $0.20 and uses the identical engine, so what you see is what you get - If your seeds do not look like one industry, the run cuts itself to that same preview rather than billing you for a full search we can already tell will be poor. It says so in the run summary, so a short list is never a mystery Larger runs are cheaper per company, because the search work is shared across the whole run rather than repeated per row. ### Why isn't company X in my results? Every run scores more companies than it returns. Anything below your `minSimilarity` is withheld, and you are not charged for it. The ones that came close are not thrown away. They are written to an output called `nearMisses`, next to the run summary, with the score each one got and the terms that did match. **You are not charged for these.** They are not results, they are the explanation for the results you did get. So when a company you expected is missing, look there first. If it scored 59 against your floor of 60, that is a one-word fix: run it again at 55. If it is not listed, there are three possible reasons, and the run tells you which applies. It scored well below your floor. It could not be read at all. Or the list was full: only the closest 25 are kept, and when more than that came close the run says how many were left off, so a company that missed by more than the 25th did can still be brought back by lowering the floor. Two things it deliberately does not do. It does not list companies your `countries` or term filters removed, because you stated those rather than guessed at them. And it never lists a company that scored 0, because a 0 means we found a page that is not a company at all, not a company that nearly matched. ### Every row shows its working Alongside the score and the matched terms, most rows carry `evidenceQuote`: one sentence from that company's own page, word for word, containing the term the row matched on. ``` domain score evidenceQuote alpha-pay.com 84 "We help merchants accept card payments online, in store and on mobile, with a single payment gateway." ``` It is copied, never written. You can paste it into a search box and find it on their site. We do not summarise it, shorten it into a claim, or assemble it from pieces, because the entire value of this field is that it is not something we made up. Sometimes it is missing, and that is deliberate rather than a gap. A company that scored 0 gets no quote, because the quote is evidence for a score and there is no score to support. A company whose page could not be read gets no quote, because there is no sentence to copy. In both cases the field is simply absent. An empty quote, or a vague one, would be worse than nothing. ### Limitations, in plain language Read this before you buy. It is here so you do not need a refund. **Your seed set decides your results.** Three companies from one clear industry produce a clean list. Three companies from three different industries produce a mixed list, because there is no single thing they have in common to search for. This is the single biggest driver of quality, and it is in your hands, not ours. **This finds companies, not people.** No names, no emails, no phone numbers, no job titles. If you need contacts, chain this actor's output into a contact finder. We deliberately do not touch personal data. **No employee counts, revenue figures or funding data.** Those come from licensed databases we do not resell. You get the company, its domain, and why it matched. **Country filtering is best effort, and it will shorten your list a lot.** We place a company from a postal address it publishes, a country-code domain like `.co.uk`, or an explicit "headquartered in" claim. Measured on 19 real company homepages, we could place 4. Global software and payments companies list every country they sell into and rarely state where they are, and treating those as a location is how a Dutch company gets labelled German, so we leave it blank instead. A company we cannot place is dropped when you set `countries`, and the run tells you how many were dropped for that reason. If you want coverage rather than precision, leave `countries` empty and filter the output yourself. **Some sites refuse to be read, and we will not guess at them.** A minority of company sites answer an automated reader with an anti-bot challenge instead of their homepage. We cannot see what that company says about itself, so we do not score it and it is not in your results. The run tells you how many sites did this. Giving it a low score would be inventing a verdict from a page we were never shown, and you are not charged for a company we could not read. **We do not scrape LinkedIn.** Not as a source, not as a fallback. This keeps the actor stable and keeps you clear of the takedown risk that follows tools which do. **Websites that are offline cannot be scored.** They are skipped and reported in the run log, not silently included with a made-up score. A site that renders under JavaScript is still scored, from its title, description and headings rather than its body text, and those rows carry fewer matched terms and a lower score than a page we could read in full. **A company that does not say what it does will score low.** This is the honest limit of reading one homepage. Scoring compares the phrases a company uses about itself against the phrases your seeds use, so a company whose homepage is consumer brand copy can share almost nothing with a seed set written in industry language, even when it is an obvious competitor. Measured example from the run above: Airwallex scores 72 and Square scores 30, and both are real payment companies. Square's homepage is built in the browser and gives us very little to read. If a company you expected is missing, that is usually why. Look below your filter before concluding it was not found. **Coverage varies by industry.** A very obscure or very new niche has less published about it, and results thin out accordingly. ### Run data CloudAstra, the maker of this actor, keeps the inputs and outputs of runs and uses them to enhance the offering. Set `shareOutcomes` to `false` to opt out. This happens after your results are delivered and never slows or fails a run. ### Input | Field | Required | Description | |---|---|---| | `seedDomains` | **yes** | 1 to 10 company domains. Three to five is where it works best | | `candidateDomains` | no | Your own list to rank. Setting it turns the search off | | `candidateDomainsDataset` | no | The same thing from an Apify dataset, for a list too long to paste | | `maxResults` | no | 1 to 1000, default 100. Also your spend cap | | `countries` | no | ISO codes such as `GB`, `US`, `DE`. Empty means worldwide | | `excludeDomains` | no | Companies you already have. Never returned, never charged | | `excludeDomainsDataset` | no | An Apify dataset ID holding your whole customer list, so none of it comes back | | `requiredTerms` | no | The company must mention all of these on its site, or it is not returned | | `excludeTerms` | no | The company must mention none of these | | `minSimilarity` | no | 0 to 100, default 70. Drop anything scoring below it; 60 to 69 is listed unbilled in `nearMisses` | | `preview` | no | Cap the run at 25 results for a cheap trial | | `expandFromResults` | no | Default true. Search again from the strongest companies found. Off in preview | Three more exist under **Run limits (advanced)**: `maxSearches`, `maxPageFetches` and `maxRunSeconds`. You can tighten them, never raise them. Whichever is reached first, the run stops, returns everything it found and finishes normally. Most people never touch these. #### Filtering by what a company actually does `requiredTerms` and `excludeTerms` are the honest version of an industry filter. Say the company must mention `payment` and must not mention `consulting`, and you can see exactly why each row passed: the words that matched are already published on every row in `matchedTerms`. There is no industry label, and that is deliberate. Giving one would mean guessing a category from a marketing page and printing it in a field you would reasonably treat as authoritative. Real industry codes exist for registry data, not for websites. #### Excluding a customer list Typing four hundred domains into `excludeDomains` is not realistic, so run your customer list through **Lead List Cleaner** and paste that run's dataset ID into `excludeDomainsDataset`. It turns a messy export into clean domains, which is exactly what this needs. Any dataset works as long as its rows carry a domain, website or url field. Excluded companies are dropped before anything is fetched, so you are never charged for them. ### Output One dataset row per company: `domain`, `companyName`, `similarityScore`, `rank`, `country`, `discoveredVia`, `evidence[]`, `matchedTerms`, `homepageUrl`, `homepageTitle`, `scoredAt`. Rows are pushed as they are scored and arrive already ranked, so if you stop a run early you keep everything found so far. Export to CSV, JSON or Excel, or pipe it straight into another actor. ### FAQ **How many seeds should I give it?** Three to five is the sweet spot. One works: we measured it, and a single seed still ranks every real competitor above every unrelated company. It is just weaker, with lower scores and a narrower gap between a good match and a bad one, and the run log says so when you use one. Above ten you start blending industries, which dilutes the list. Seeds that belong on the same shortlist beat seeds you merely like. If the ones you gave do not look like a single industry, we do not charge you for a full search we can already tell will be poor: the run cuts itself to a small preview, says so plainly, and you fix the seeds and run it again for the full list. **Do I need an API key for anything?** No. Everything is self contained. Run it and go. **Can I use this for an industry that is not English speaking?** Yes, though results are strongest where the industry publishes in English. Non-English company sites are scored, but coverage will be lower. **Why did I get fewer results than I asked for?** `maxResults` is a ceiling, not a promise. Narrow niches, tight country filters and a high `minSimilarity` all reduce the count. You are only charged for what you actually receive. **Can I schedule it?** You can, but this is a snapshot tool. The set of companies similar to yours does not change much week to week. Run it when your seed list changes. **What if the results are bad?** Tell us what seeds you used and what came back. Contact details are on the listing, and the response targets are below. Bad results on a coherent seed set are a bug we want to know about. ### Use it from an agent or an automation This actor is reachable through the Apify MCP server, so an AI agent such as Claude can call it by name: ask for companies like your seeds, and the agent runs this actor and reads the rows back, evidence included. It is also available in the Apify apps for Make, Zapier and n8n, where a run can be started from a form or a CRM record and the finished dataset passed on to the next step. The input is the same in every case: seed domains in, ranked rows out. ### Support Issues and questions through the Apify listing. We aim to acknowledge within 24 hours and to fix genuine breakage within 72 hours. The search landscape this actor depends on changes without notice. It runs an automated health check every day, so breakage is usually found and fixed before you would notice it. # Actor input Schema ## `seedDomains` (type: `array`): The companies you want more of. One is enough to run, but three to five is where this works best: with a single seed the scores run lower and the gap between a real match and an unrelated company narrows, and the run log says so when it happens. Pick companies you would put on the same shortlist, not just companies you like. ## `candidateDomains` (type: `array`): Optional. Paste the companies you want ranked, and this actor will not search at all. Every domain here is read and scored against your seed companies, and you get them back ranked, with the same evidence and the same filters. Use it when you already have the list: a trade show export, a conference attendee list, a pull from Registry Lead Finder, or your own CRM. Leave it empty and the actor goes looking for candidates itself, which is the normal mode. Setting this turns the search off, so you are only ever charged for companies you named. Up to 5,000 domains per run; split a longer list across runs. In preview mode the first 25 are scored. ## `candidateDomainsDataset` (type: `string`): Optional. The same thing as the field above, for a list too long to paste. Give the ID of an Apify dataset whose items carry a domain, website or url field, and every company in it is scored against your seeds. Run a messy export through Lead List Cleaner first and paste that run's dataset ID here. Use this field or the one above, not both. Up to 5,000 rows per run. In preview mode the first 25 are scored. ## `maxResults` (type: `integer`): How many companies to return, ranked best first. You are charged per result returned, so this is also your spend cap. Larger runs are cheaper per company because the search work is shared across the whole run. ## `countries` (type: `array`): Optional. ISO 3166-1 alpha-2 codes, for example GB, US, DE. Leave empty to search worldwide. A company is kept if its domain is a country domain (.co.uk) or its site states a location in one of your countries. Read the Limitations section of the README before relying on this: a .com with no stated location cannot be placed, and is dropped when you set this filter. ## `excludeDomains` (type: `array`): Optional. Companies you already know about, such as existing customers or a list you have already worked. These never appear in the output and you are never charged for them. Your seed domains are excluded automatically. ## `excludeDomainsDataset` (type: `string`): Optional. The ID of an Apify dataset holding companies you already have, so none of them come back as a result. Run your customer list through Lead List Cleaner and paste that run's dataset ID here: it turns a messy export into clean domains, which is exactly what this needs. Any dataset works as long as its items carry a domain, website or url field. Excluded companies are dropped before anything is fetched, so you are never charged for them. ## `requiredTerms` (type: `array`): Optional. Only return companies whose own website mentions all of these. Write them the way a company would: payment, direct debit, invoicing. This is a plain text match against the page we read, so you can click the homepage on any row and check it yourself. Companies dropped this way are counted in the run log so you can tell a strict filter from a bad seed set. ## `excludeTerms` (type: `array`): Optional. Drop companies whose website mentions any of these. Useful for cutting a neighbouring industry out of the results: an agency that resells what your seeds build will read as similar until you exclude consulting. ## `minSimilarity` (type: `integer`): Optional. Drop any company scoring below this, from 0 to 100. Default 70. Above 70 roughly eight rows in ten are genuinely in your seeds' business; between 50 and 69 it is mixed, and those rows are listed unbilled in the nearMisses output so you can see what the cut removed. Lower it to 50 for reach in industries where close competitors score in the fifties, to 1 to see everything we scored, and to 0 to also see parked domains and directories. Companies dropped by this filter are never charged, and the run tells you how many it removed. ## `preview` (type: `boolean`): Judge the quality on your own seed companies before committing. Caps the run at 25 results, so a trial costs about $0.20 instead of a full run. Same engine, same evidence, just fewer rows. Turn it off for a full run. ## `expandFromResults` (type: `boolean`): Widens the search from the strongest matches found, still scored against your original seeds. Roughly doubles the companies considered and adds a few minutes to the run. Off in preview mode. ## `shareOutcomes` (type: `boolean`): When on, the inputs and outputs of this run are kept by CloudAstra, the maker of this actor, and used to enhance the offering. Turn it off to opt out. ## `maxSearches` (type: `integer`): Optional. Stop searching after this many searches. The default shown is the most this actor will ever run, and you can only lower it. Reaching the limit is not an error: you get the companies found up to that point, and you are charged only for those. ## `maxPageFetches` (type: `integer`): Optional. Stop after reading this many web pages. The actual limit for your run is also scaled to the number of results you asked for, so a small run stops well below this number. Reaching it returns what was found so far. ## `maxRunSeconds` (type: `integer`): Optional. Stop after this many seconds and return what has been found. Preview runs stop after 600 seconds regardless, so a trial always finishes quickly. ## Actor input object example ```json { "seedDomains": [ "stripe.com", "adyen.com", "checkout.com" ], "candidateDomains": [], "maxResults": 100, "countries": [], "excludeDomains": [], "requiredTerms": [], "excludeTerms": [], "minSimilarity": 70, "preview": false, "expandFromResults": true, "shareOutcomes": true, "maxSearches": 120, "maxPageFetches": 15000, "maxRunSeconds": 3300 } ``` # Actor output Schema ## `results` (type: `string`): One row per company found, ranked by similarity score. Every row carries the page it was found on, the matched terms, and a quote from the company's own site. This is the only output that is billed. ## `runSummary` (type: `string`): What the run did: results returned, rows withheld by each of your filters, seed coverage, and the run limit hit, if any. Not billed. ## `nearMisses` (type: `string`): Companies that scored just below your minSimilarity, with their scores and matched terms, so a short list explains itself. Written only when there are any. Not billed. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "seedDomains": [ "stripe.com", "adyen.com", "checkout.com" ], "candidateDomains": [], "countries": [], "excludeDomains": [], "requiredTerms": [], "excludeTerms": [] }; // Run the Actor and wait for it to finish const run = await client.actor("cloudastra-technologies/company-lookalike-finder").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "seedDomains": [ "stripe.com", "adyen.com", "checkout.com", ], "candidateDomains": [], "countries": [], "excludeDomains": [], "requiredTerms": [], "excludeTerms": [], } # Run the Actor and wait for it to finish run = client.actor("cloudastra-technologies/company-lookalike-finder").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}") for item in client.dataset(run.default_dataset_id).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "seedDomains": [ "stripe.com", "adyen.com", "checkout.com" ], "candidateDomains": [], "countries": [], "excludeDomains": [], "requiredTerms": [], "excludeTerms": [] }' | apify call cloudastra-technologies/company-lookalike-finder --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,cloudastra-technologies/company-lookalike-finder" } } } ``` The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer ` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations). ## OpenAPI specification Download the OpenAPI definition: https://api.apify.com/v2/actors/T9tXyx9P3UxsyOaqM/builds/OdGEhmxygOkbdZApB/openapi.json