Pricing

Pay per usage

Superclean Company Names

Transform messy company names into clean formats for outreach. Removes legal suffixes (Inc, LLC, Ltd), fixes ALL CAPS, preserves brand identity. Perfect for cold email personalization, CRM cleanup, and lead enrichment. Supports casual, formal, and legal output styles. LLM-powered normalizer.

Pricing

Pay per usage

Rating

0.0

(0)

Developer

Superlative

Actor stats

Bookmarked

Total users

Monthly active users

a minute ago

Last modified

Superclean Person Names

superlativetech/superclean-person-names

Clean messy person names for cold email and CRM. Extracts first names for personalization, fixes ALL CAPS, handles McDonald/O'Brien/van der Berg correctly, strips titles (Dr.) and credentials (PhD). Three styles: first name only, casual, or formal.

Superlative

Superclean Job Titles

superlativetech/superclean-job-titles

Clean messy job titles instantly. AI fixes abbreviations (Sr. → Senior), removes junk (Ninja, Rockstar), strips department tags, and standardizes formats. 3 output styles for CRM, spreadsheets, or analytics. Better data means better lead scoring and personalization.

Superlative

Superclean Product Names

superlativetech/superclean-product-names

Clean messy product names from e-commerce exports and web scraping. AI removes promo text, prices, SKUs, and formatting noise. Three styles: Clean (core name only), Full (with attributes), Searchable (lowercase for dedup). Works with Shopify, Amazon, and any catalog data.

Superlative

Superclean URLs

superlativetech/superclean-urls

Clean messy URLs from lead exports. Remove 60+ tracking parameters (utm_*, fbclid, gclid), normalize format, extract domains, and optionally verify URLs are reachable. Perfect for cold email personalization and CRM data hygiene.

Superlative

Company Name Normalizer

zentrafoundry/company-name-normalizer

Transform company name normalizer inputs into structured rows, clear errors, confidence signals, and automation-ready output.

Zentra

AI Cold Outreach Personalization

happitap/ai-cold-outreach-personalization

Transform cold outreach with AI-powered personalization. This Actor scrapes lead data from websites and generates highly personalized cold emails, LinkedIn DMs, and WhatsApp messages at scale. Stop sending generic messages—let AI research each lead and craft personalized outreach for you.

HappiTap

Company Website Lead Enricher

peroxo/company-website-lead-enricher

Extract public company names, contact details, legal identifiers, and social links from company websites.

Michael Beetz

Legal Services Industry Email Scraper

contacts-api/legal-services-industry-email-scraper

Legal services industry email scraper to extract verified emails from law firms, attorneys, and legal service providers 📧⚖️ Perfect for B2B outreach, partnerships, and legal industry lead generation.

Lead Heaven

Lead List Deduplicator & Normalizer

webdata_labs/lead-list-deduplicator

[💵 $0.05 / 1K] Clean messy B2B lead lists into CRM-ready company/contact records with duplicate clusters, confidence scores, match reasons, normalized domains, emails, and phones.

WebData Labs

Impressum & EU Legal Notice Extractor — Company & VAT Data

haketa/impressum-legal-notice-extractor

Turn a list of domains into structured company data from Impressum, Mentions légales, Aviso legal and other EU legal-notice pages: legal company name, VAT / USt-IdNr, managing director, registration number, court, address, email and phone. Fast, keyless B2B lead & KYB enrichment.

Haketa

{ "name": "superclean-company-names", "version": "0.1.0", "type": "module", "description": "Transform messy company names into clean, professional formats for cold email, sales outreach, and CRM cleanup.", "engines": { "node": ">=18.0.0" }, "dependencies": { "apify": "^3.5.2", "openai": "^4.0.0" }, "scripts": { "start": "node ./src/main.js", "test": "node --test tests/*.test.js" }, "author": "Superlative", "license": "ISC" }

{ "actorSpecification": 1, "fields": { "type": "object", "properties": { "id": { "type": "integer", "description": "Row number (1-based)" }, "input": { "type": "string", "description": "The original input value" }, "output": { "type": "string", "description": "The cleaned output value" }, "confidence": { "type": "number", "description": "Confidence score from 0 to 1" } } }, "views": { "overview": { "title": "All Results", "transformation": { "fields": ["id", "input", "output", "confidence"] }, "display": { "component": "table", "properties": { "id": { "label": "ID", "format": "number" }, "input": { "label": "Input", "format": "text" }, "output": { "label": "Output", "format": "text" }, "confidence": { "label": "Confidence", "format": "number" } } } } } }

{ "actorOutputSchemaVersion": 1, "title": "Superclean Company Names Output", "description": "Normalized results with original values, cleaned values, and confidence scores.", "properties": { "allResults": { "type": "string", "title": "All Results", "description": "All normalized items with before/after values and confidence scores", "template": "{{links.apiDefaultDatasetUrl}}/items" } } }

{ "openapi": "3.0.3", "info": { "title": "Superclean Company Names — Standby API", "description": "Instant AI-powered company name normalization via HTTP GET. Clean messy company names for cold email, CRM, and sales outreach. Supports casual, formal, and legal styles.", "version": "0.2.0" }, "paths": { "/": { "get": { "summary": "Clean a company name", "description": "Normalize a single company name using AI. Strips legal suffixes, fixes casing, handles brand formatting. Supports BYOK via X-OpenRouter-Key header.", "operationId": "cleanCompanyName", "parameters": [ { "name": "input", "in": "query", "description": "Company name to clean (e.g. `ACME CORPORATION, INC.`).", "required": true, "schema": { "type": "string", "example": "ACME CORPORATION, INC." } }, { "name": "style", "in": "query", "description": "Output style. `casual` for cold email, `formal` for CRM, `legal` for contracts.", "required": false, "schema": { "type": "string", "enum": ["casual", "formal", "legal"], "default": "casual" } }, { "name": "model", "in": "query", "description": "LLM model to use.", "required": false, "schema": { "type": "string", "default": "openrouter/auto" } } ], "responses": { "200": { "description": "Cleaned company name with confidence score.", "content": { "application/json": { "schema": { "$ref": "#/components/schemas/CleanedName" }, "examples": { "casual": { "summary": "Casual style", "value": { "id": 1, "input": "ACME CORPORATION, INC.", "output": "Acme", "confidence": 0.95 } }, "formal": { "summary": "Formal style", "value": { "id": 1, "input": "ACME CORPORATION, INC.", "output": "Acme Corporation", "confidence": 0.95 } } } } } }, "400": { "description": "Invalid request — missing input or invalid style.", "content": { "application/json": { "schema": { "$ref": "#/components/schemas/Error" }, "example": { "error": "Provide an 'input' query parameter with the company name to clean." } } } }, "405": { "description": "Method not allowed — only GET is supported.", "content": { "application/json": { "schema": { "$ref": "#/components/schemas/Error" }, "example": { "error": "Method not allowed. Use GET." } } } } } } } }, "components": { "schemas": { "CleanedName": { "type": "object", "required": ["id", "input", "output", "confidence"], "properties": { "id": { "type": "integer", "description": "Row number (always 1 for single-item Standby requests)." }, "input": { "type": "string", "description": "Original company name before cleaning." }, "output": { "type": "string", "description": "Cleaned company name." }, "confidence": { "type": "number", "description": "Confidence score from 0 to 1." } } }, "Error": { "type": "object", "required": ["error"], "properties": { "error": { "type": "string", "description": "Human-readable error message." } } } } } }

{ "title": "Superclean Company Names", "description": "Paste your company names below and click Start. Results will appear in the Output tab.", "type": "object", "schemaVersion": 1, "properties": { "items": { "title": "Company names", "type": "array", "description": "Enter company names to clean, one per line.", "editor": "stringList", "prefill": ["ACME CORPORATION, INC."], "minItems": 1 }, "style": { "title": "Output style", "type": "string", "description": "Choose how company names should be formatted in the output.", "enum": ["casual", "formal", "legal"], "enumTitles": [ "Casual - shortest form for cold emails (Samsung)", "Formal - full name without legal suffix (Samsung Electronics)", "Legal - complete legal name (Samsung Electronics Co., Ltd.)" ], "default": "casual", "editor": "select" }, "model": { "sectionCaption": "Advanced", "title": "AI model", "type": "string", "description": "AI model for normalization. Default auto-routes for best price/performance. Set a specific model like google/gemini-2.0-flash-001 for higher-quality confidence scores. Browse models at openrouter.ai/models.", "default": "openrouter/auto", "editor": "textfield" }, "openRouterApiKey": { "title": "OpenRouter API key (bring your own)", "type": "string", "description": "Optional. Provide your own OpenRouter API key to use the direct OpenRouter API instead of the built-in Apify integration. Get your key at openrouter.ai.", "editor": "textfield", "isSecret": true }, "item": { "title": "Item (single)", "type": "string", "description": "Single company name to clean — shorthand for API/integration callers. If both 'item' and 'items' are provided, 'item' is prepended to the list.", "editor": "textfield", "sectionCaption": "API shorthand", "sectionDescription": "For API and integration callers (Clay, Make, n8n) who want to pass a single item without wrapping it in an array." } }, "required": [] }

{ "actorSpecification": 1, "name": "superclean-company-names", "title": "Superclean Company Names", "description": "Normalize messy company names. AI cleans 'ACME CORPORATION, INC.' to 'Acme'. Casual/formal/legal styles. Input: string array. Output: {input, output, confidence}. Batch or instant API.", "version": "0.2", "buildTag": "latest", "usesStandbyMode": true, "webServerSchema": "./web_server_openapi.json", "dockerfile": "../Dockerfile", "input": "./input_schema.json", "output": "./output_schema.json", "storages": { "dataset": "./dataset_schema.json" }, "defaultRunOptions": { "build": "latest", "memoryMbytes": 256, "timeoutSecs": 360 }, "minMemoryMbytes": 256, "maxMemoryMbytes": 1024 }

1/** 2 * Rule-based pre-processing for company name normalization. 3 * Applies deterministic transformations before LLM processing. 4 */ 5 6import { COMPANY_SUFFIXES, NORMALIZE_CHARS } from './constants.js'; 7 8/** 9 * Check if a string contains non-Latin script characters (CJK, Arabic, Cyrillic, etc.) 10 * Allows accented Latin characters (é, ñ, ü, etc.) which are common in English contexts. 11 * @param {string} str - String to check 12 * @returns {boolean} True if contains non-Latin scripts 13 */ 14function containsNonLatinScript(str) { 15 // Match CJK (Chinese, Japanese, Korean), Arabic, Hebrew, Cyrillic, Thai, etc. 16 // This regex matches characters outside the Latin Extended range 17 // Latin + Latin Extended covers most European languages with accents 18 const nonLatinPattern = /[\u3000-\u9FFF\uAC00-\uD7AF\u0600-\u06FF\u0590-\u05FF\u0400-\u04FF\u0E00-\u0E7F\u1100-\u11FF\uFF00-\uFFEF]/; 19 return nonLatinPattern.test(str); 20} 21 22/** 23 * Extract the English (Latin script) portion from a mixed-language string. 24 * Examples: 25 * "Violet连锁酒店" -> "Violet" 26 * "OrderPally 舉手電商股份有限公司" -> "OrderPally" 27 * "知識衛星SAT.KNOWLEDGE" -> "SAT.KNOWLEDGE" 28 * "株式会社WFS" -> "WFS" 29 * "Noritake Kougado Co., Ltd. 株式会社則武好雅堂" -> "Noritake Kougado Co., Ltd." 30 * @param {string} str - Mixed-language string 31 * @returns {string|null} English portion, or null if no substantial English found 32 */ 33function extractEnglishPortion(str) { 34 if (!str) return null; 35 36 // Pattern to match Latin characters, numbers, common punctuation, and spaces 37 // This captures English words, abbreviations, and company suffixes 38 const latinPattern = /[A-Za-z0-9][A-Za-z0-9\s.,&'"-]*/g; 39 40 const matches = str.match(latinPattern); 41 if (!matches) return null; 42 43 // Join all Latin portions and clean up 44 let english = matches.join(' ').trim(); 45 46 // Remove trailing/leading punctuation and extra spaces 47 english = english.replace(/^[.,\s-]+|[.,\s-]+$/g, '').replace(/\s+/g, ' ').trim(); 48 49 // Only return if we have at least 2 characters of English content 50 if (english.length >= 2) { 51 return english; 52 } 53 54 return null; 55} 56 57/** 58 * Pre-process a company name value. 59 * @param {string} value - The raw input value 60 * @param {string} style - Output style ('casual', 'formal', or 'legal') 61 * @returns {Object} Object with preProcessed value, metadata, and extracted English portion 62 */ 63export function preprocess(value, style = 'casual') { 64 if (!value || typeof value !== 'string') { 65 return { value: '', isNonEnglish: false, extractedEnglish: null }; 66 } 67 68 let result = value; 69 70 // Check for non-Latin scripts before processing 71 const isNonEnglish = containsNonLatinScript(result); 72 73 // For non-English strings, try to extract the English portion 74 let extractedEnglish = null; 75 if (isNonEnglish) { 76 extractedEnglish = extractEnglishPortion(result); 77 } 78 79 // Step 1: Remove trademark/registered symbols 80 result = result.replace(/[®™©]/g, '').trim(); 81 82 // Step 2: Normalize special characters to ASCII (smart quotes, dashes, etc.) 83 for (const [from, to] of Object.entries(NORMALIZE_CHARS)) { 84 result = result.split(from).join(to); 85 } 86 87 // Step 3: Trim and collapse whitespace 88 result = result.trim().replace(/\s+/g, ' '); 89 90 // Step 4: Company-specific processing (only if English) 91 if (!isNonEnglish) { 92 result = preprocessCompany(result, style); 93 } 94 95 return { value: result, isNonEnglish, extractedEnglish }; 96} 97 98/** 99 * Pre-process company names by removing legal suffixes and normalizing case. 100 * @param {string} value - Company name 101 * @param {string} style - Output style ('casual', 'formal', or 'legal') 102 * @returns {string} Cleaned company name 103 */ 104function preprocessCompany(value, style = 'casual') { 105 let result = value; 106 107 // Only strip legal suffixes for casual/formal styles 108 // Legal style preserves suffixes for the LLM to standardize capitalization 109 if (style !== 'legal') { 110 // Sort suffixes by length (longest first) to avoid partial matches 111 const sortedSuffixes = [...COMPANY_SUFFIXES].sort((a, b) => b.length - a.length); 112 113 for (const suffix of sortedSuffixes) { 114 // Match suffix at end of string, with optional comma/space before 115 // and optional period/comma after 116 const escapedSuffix = escapeRegex(suffix); 117 const pattern = new RegExp(`[,\\s]*\\b${escapedSuffix}\\b[.,]*$`, 'i'); 118 const newResult = result.replace(pattern, '').trim(); 119 120 if (newResult !== result) { 121 result = newResult; 122 // Continue to catch multiple suffixes (e.g., "Company, Inc.") 123 } 124 } 125 } 126 127 // Note: We keep "The" prefix - it's often part of the brand identity 128 // (e.g., "The Home Depot", "The New York Times") and sounds natural in cold email. 129 // The LLM will decide whether to keep or remove it based on context. 130 131 // Note: We do NOT apply title case normalization here - the LLM handles capitalization 132 // decisions based on brand recognition (e.g., GLOBO, TBC, ICE should stay uppercase). 133 134 return result; 135} 136 137/** 138 * Escape special regex characters in a string. 139 * @param {string} string - String to escape 140 * @returns {string} Escaped string safe for use in RegExp 141 */ 142function escapeRegex(string) { 143 return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); 144}

1/** 2 * Constants for company name normalization patterns. 3 */ 4 5// Company legal suffixes to remove (sorted by length for proper matching) 6export const COMPANY_SUFFIXES = [ 7 // English - Long forms first 8 'Limited Liability Company', 9 'Incorporated', 10 'Corporation', 11 'Limited Partnership', 12 'Limited', 13 'Company', 14 // English - Abbreviations (including & combinations) 15 '& Company', 16 '& Co.', 17 '& Co', 18 'L.L.C.', 19 'P.L.C.', 20 'p.l.c.', 21 'L.L.P.', 22 'Inc.', 23 'Ltd.', 24 'Corp.', 25 'Corp', 26 'LLC', 27 'PLC', 28 'PLLC', 29 'LLP', 30 'P.C.', 31 'PC', 32 'P.A.', 33 'PA', 34 'Inc', 35 'Ltd', 36 'Co.', 37 'LP', 38 'Co', 39 // German 40 'GmbH', 41 'AG', 42 'KG', 43 'OHG', 44 'e.V.', 45 // Dutch/Belgian 46 'B.V.', 47 'N.V.', 48 'BV', 49 'NV', 50 // French 51 'SARL', 52 'SAS', 53 'S.A.', 54 'SA', 55 // Italian 56 'S.r.l.', 57 'S.p.A.', 58 'SRL', 59 'SpA', 60 // Spanish/Portuguese 61 'S.L.', 62 'SL', 63 // Nordic 64 'A/S', 65 'AS', 66 'AB', 67 'OY', 68 'Oy', 69 // Australian 70 'Pty Ltd', 71 'Pty. Ltd.', 72 'Pty', 73 // European 74 'SE', 75]; 76 77// Special characters to normalize to ASCII equivalents 78export const NORMALIZE_CHARS = { 79 '\u2018': "'", // Left single quote 80 '\u2019': "'", // Right single quote 81 '\u201C': '"', // Left double quote 82 '\u201D': '"', // Right double quote 83 '\u2013': '-', // En dash 84 '\u2014': '-', // Em dash 85 '\u00A0': ' ', // Non-breaking space 86 '\u2026': '...', // Ellipsis 87 '\u00B7': '.', // Middle dot 88};

1/** 2 * LLM-based semantic normalization for company names using Apify's OpenRouter standby actor. 3 * @see https://apify.com/apify/openrouter 4 */ 5 6import { log } from 'apify'; 7import OpenAI from 'openai'; 8 9const BATCH_SIZE = 10; // Process items in batches (kept small to avoid truncated LLM responses) 10const MAX_RETRIES = 3; // Maximum retry attempts for API calls 11const INITIAL_RETRY_DELAY_MS = 1000; // Start with 1 second delay 12const DEFAULT_CONCURRENCY = 5; // Default parallel batch limit 13const LARGE_REQUEST_THRESHOLD = 100; // Items threshold for increased concurrency 14const LARGE_REQUEST_CONCURRENCY = 10; // Concurrency for large requests 15const MAX_TOKENS = 2048; // Ensure sufficient output tokens for complete JSON responses 16 17// Apify's OpenRouter standby actor endpoint 18const OPENROUTER_BASE_URL = 'https://openrouter.apify.actor/api/v1'; 19// Direct OpenRouter API endpoint (bring your own key) 20const OPENROUTER_DIRECT_URL = 'https://openrouter.ai/api/v1'; 21 22/** 23 * Style-specific prompt modifiers for casual, formal, and legal output. 24 */ 25const STYLE_MODIFIERS = { 26 casual: `Simplify to the shortest RECOGNIZABLE form - the name must still be identifiable: 27 - "Farquhar & Gill Insurance Group" -> "Farquhar & Gill" (distinctive name, drop generic descriptor) 28 - "Samsung Electronics Co., Ltd." -> "Samsung" (globally known brand) 29 - For globally recognized brands, use common abbreviations: 30 * "Johnson & Johnson" -> "J&J" 31 * "Procter & Gamble" -> "P&G" 32 * "Hewlett-Packard" -> "HP" 33 * "International Business Machines" -> "IBM" 34 - When input contains a parenthetical abbreviation, USE IT: 35 * "U.S. Department of Energy (DOE)" -> "DOE" 36 * "Federal Bureau of Investigation (FBI)" -> "FBI" 37 * "World Health Organization (WHO)" -> "WHO" 38 - Strip country prefixes from government agencies: 39 * "U.S. Department of Energy" -> "DOE" (if known) or "Department of Energy" 40 - Remove industry descriptors ONLY when the core name is distinctive: Insurance, Solutions, Technologies, Industries, Group, Holdings 41 * "Decision Resources Group" -> "Decision Resources" 42 * "Farquhar & Gill Insurance Group" -> "Farquhar & Gill" 43 * "Acme Holdings Group" -> "Acme" (strip ALL generic descriptors) 44 * "Smith Industries Group" -> "Smith" (strip Industries AND Group) 45 * "CRC Group" -> "CRC" (strip Group even from acronyms) 46 - Strip parent company annotations like "part of X", "a X company", "an X brand": 47 * "Decision Resources Group, part of Clarivate" -> "Decision Resources" 48 - Strip divisions and subsidiaries to the recognizable PARENT brand: 49 * "J.P. Morgan Asset Management" -> "J.P. Morgan" 50 * "AT&T Cybersecurity" -> "AT&T" 51 * "Berkshire Hathaway HomeServices" -> "Berkshire Hathaway" 52 * "Google Cloud" -> "Google" 53 - BUT keep descriptors if removing them leaves just a person's name, an acronym, or a single vague word: 54 * "Flame Steakhouse" stays "Flame Steakhouse" (just "Flame" is too vague) 55 * "VRCC Veterinary Specialty and Emergency Hospital" -> keep full name (just "VRCC" is meaningless) 56 * "Crystal Dental" stays "Crystal Dental" (just "Crystal" loses the business type) 57 * "Fred's Wrigleyville Garage & Auto Repair" stays as-is (service type is the identity) 58 * "Cory Fein Law Firm" stays "Cory Fein Law Firm" (just "Cory Fein" is a person, not a business) 59 * "Open Hair Miami Salon" stays "Open Hair Miami Salon" 60 * "RKS Photography" stays "RKS Photography" (initials alone are meaningless) 61 - LOCATIONS: Always strip city/neighborhood names and "at/in [Location]" after the business name: 62 * "Publix Super Market at Gateway Village" -> "Publix Super Market" 63 * "exhale Spa Midtown Atlanta" -> "exhale Spa" 64 * "Onelife Fitness - Olney" -> "Onelife Fitness" 65 * "MHC Kenworth - Memphis" -> "MHC Kenworth" 66 - COLON-SEPARATED NAMES: Keep both parts (the subtitle is the identity): 67 * "Replenish: The Spa Co-op" -> "Replenish: The Spa Co-op" 68 - ALWAYS keep "Association", "Foundation", "Trust", "Society" for non-profits (they define the org type) 69 - UNIVERSITIES/COLLEGES: Keep recognizable full names, do NOT use nicknames: 70 * "California State University-Sacramento" -> "CSU Sacramento" or "Cal State Sacramento" (NOT "Sacramento State") 71 * "University of California, Los Angeles" -> "UCLA" 72 * "Massachusetts Institute of Technology" -> "MIT" 73 * Only use widely-known acronyms (UCLA, MIT, USC) - otherwise keep the full name 74 - DOMAIN NAMES: Strip ALL domain TLDs (.com, .io, .ai, .org, .net, etc.): 75 * "acquire.com" -> "Acquire" 76 * "Covidence.org" -> "Covidence" 77 * "scale.ai" -> "Scale" 78 - Remove ALL legal suffixes (Inc., LLC, Ltd., Corp., GmbH, AG, S.A., etc.)`, 79 formal: `Keep the FULL company name but remove legal entity suffixes: 80 - "Farquhar & Gill Insurance Group, LLC" -> "Farquhar & Gill Insurance Group" 81 - "Samsung Electronics Co., Ltd." -> "Samsung Electronics" 82 - "The Coca-Cola Company" -> "The Coca-Cola Company" (keep "The" if part of official name) 83 - "The Walt Disney Company" -> "The Walt Disney Company" 84 - Remove ONLY legal suffixes: Inc., LLC, Ltd., Corp., GmbH, AG, S.A., Co., P.L.C., N.V., etc. 85 - Strip country prefixes from government agencies but keep full name: 86 * "U.S. Department of Energy (DOE)" -> "Department of Energy" 87 * "U.S. Securities and Exchange Commission" -> "Securities and Exchange Commission" 88 - Strip parenthetical abbreviations (they're annotations, not part of the name) 89 - Keep ALL descriptive words: Group, Holdings, Industries, International, etc. 90 - DOMAIN NAMES: Strip ALL domain TLDs (.com, .io, .ai, .org, .net, etc.): 91 * "acquire.com" -> "Acquire" 92 * "Covidence.org" -> "Covidence"`, 93 legal: `Keep the COMPLETE legal company name with EXACT formatting as provided: 94 - "Farquhar & Gill Insurance Group, LLC" -> "Farquhar & Gill Insurance Group, LLC" 95 - "Samsung Electronics Co., Ltd." -> "Samsung Electronics Co., Ltd." 96 - "Apple Inc." -> "Apple Inc." 97 - "ACME CORPORATION, INC." -> "Acme Corporation, Inc." (normalize capitalization only) 98 - "GOOGLE LLC" -> "Google LLC" (keep LLC exactly - do NOT change to Inc.) 99 100 CRITICAL - PRESERVE EXACT FORMATTING: 101 - NEVER add punctuation: "Kforce Inc" stays "Kforce Inc" (do NOT add period to make "Kforce Inc.") 102 - NEVER change abbreviation style: "US Federal Government" stays "US Federal Government" (do NOT change to "U.S.") 103 - NEVER change the legal entity type (LLC, Inc., Corp., Ltd. are NOT interchangeable!) 104 - The ONLY change allowed is normalizing capitalization (all-caps to title case) 105 106 DASH-SEPARATED NAMES (ACRONYM - Full Name): 107 - Keep the FULL form, not the acronym: "IFC - International Finance Corporation" -> "International Finance Corporation" 108 - Be CONSISTENT: always choose the longer descriptive form for legal documents 109 - "NASA - National Aeronautics and Space Administration" -> "National Aeronautics and Space Administration" 110 - "WHO - World Health Organization" -> "World Health Organization" 111 112 PARENTHETICALS: 113 - For government agencies, strip the parenthetical: "U.S. Department of Energy (DOE)" -> "U.S. Department of Energy" 114 - For companies, KEEP the parenthetical: "Amazon Web Services (AWS)" -> "Amazon Web Services (AWS)" 115 116 NEVER ADD anything not in the input: 117 - "Google" -> "Google" (do NOT add "LLC") 118 - "Apple" -> "Apple" (do NOT add "Inc.") 119 - "Microsoft" -> "Microsoft" (do NOT add "Corporation") 120 121 DOMAIN NAMES: Keep TLDs in legal mode (they may be part of the legal name): 122 - "acquire.com" -> "Acquire.com" 123 - "Scale.ai" -> "Scale.ai"`, 124}; 125 126/** 127 * Get the goal description for each style. 128 */ 129const STYLE_GOALS = { 130 casual: 'Short, punchy names that sound natural in "Hi Sarah, I noticed [COMPANY] is hiring..."', 131 formal: 'Complete, professional company names suitable for CRM records and business correspondence.', 132 legal: 'Full legal company names suitable for contracts, invoices, and official documents.', 133}; 134 135/** 136 * Get the test sentence for each style. 137 */ 138const STYLE_TESTS = { 139 casual: 'Hi Sarah, I noticed [your answer] is hiring...', 140 formal: 'Account: [your answer]', 141 legal: 'Invoice to: [your answer]', 142}; 143 144/** 145 * Build the system prompt for company name normalization. 146 * @param {string} style - Output style ('casual', 'formal', or 'legal') 147 * @returns {string} System prompt 148 */ 149function buildSystemPrompt(style) { 150 const effectiveStyle = STYLE_MODIFIERS[style] ? style : 'casual'; 151 const isLegal = effectiveStyle === 'legal'; 152 const isCasual = effectiveStyle === 'casual'; 153 154 // Determine context description based on style 155 let contextDescription; 156 if (isCasual) { 157 contextDescription = 'cold email personalization'; 158 } else if (isLegal) { 159 contextDescription = 'legal documents'; 160 } else { 161 contextDescription = 'CRM and business records'; 162 } 163 164 return `You are normalizing company names for ${contextDescription}. 165 166GOAL: ${STYLE_GOALS[effectiveStyle]} 167 168RULES: 1691. PRESERVE original capitalization pattern for brand names: 170 - All-caps brands stay all-caps: "3CD" stays "3CD", "NVIDIA" stays "NVIDIA", "BMW" stays "BMW", "IBM" stays "IBM" 171 - Alphanumeric codes: "3CD" stays "3CD" (NOT "3cd"), "H&M" stays "H&M" 172 - Mixed case brands: "eBay", "FedEx", "McKinsey", "SoCalGas" 173 - Possessives: "Stone's" (NOT "Stone'S"), "McDonald's", "Lowe's" 174 - ${isLegal ? 'In LEGAL mode, normalize all-caps to title case: "ACME CORPORATION" -> "Acme Corporation"' : 'Unknown all-caps brands should be preserved: "GLOBO" stays "GLOBO", "TBC" stays "TBC"'} 1752. Keep ampersands if part of brand name: "Johnson & Johnson", "AT&T", "H&M" 1763. NEVER expand acronyms or guess full company names - only normalize what's given: 177 - "LSEG" stays "LSEG" (do NOT expand to "London Stock Exchange Group") 178 - "IBM" stays "IBM" (do NOT expand to "International Business Machines") 179 - "BMW" stays "BMW" (do NOT expand to "Bayerische Motoren Werke") 180 - NEVER add legal suffixes (Inc., LLC, plc) that weren't in the original input 1814. ${isLegal ? 'KEEP all legal suffixes EXACTLY as written - do NOT add or change punctuation: "Inc" stays "Inc" (not "Inc."), "LLC" stays "LLC"' : 'Remove legal suffixes (Inc., LLC, Ltd., Corp., GmbH, AG, S.A., etc.)'} 182${isLegal ? `4a. LEGAL MODE - PRESERVE EXACT FORMATTING: 183 - NEVER add periods: "Kforce Inc" -> "Kforce Inc" (NOT "Kforce Inc.") 184 - NEVER change abbreviation style: "US" stays "US" (NOT "U.S."), "UK" stays "UK" (NOT "U.K.") 185 - ONLY normalize capitalization (all-caps to title case), nothing else 186` : ''}5. Handle "The" carefully: 187${isCasual ? ` - Keep "The" ONLY when the brand is commonly known WITH "The": "The Home Depot", "The New York Times" 188 - Remove "The" when it's just a formal prefix and the brand works without it: 189 * "THE COCA-COLA COMPANY" -> "Coca-Cola" (brand is "Coca-Cola", not "The Coca-Cola") 190 * "The Walt Disney Company" -> "Disney" (brand is "Disney") 191 * "The Boeing Company" -> "Boeing" (brand is "Boeing") 192 - Test: Would you say "I work at The X" or just "I work at X"? If the latter, drop "The"` : ` - Keep "The" when it's part of the official company name: "The Coca-Cola Company", "The Walt Disney Company" 193 - Only remove "The" if it's clearly not part of the official name`} 1946. ${STYLE_MODIFIERS[effectiveStyle]} 195 196TEST: Before returning, mentally check: "${STYLE_TESTS[effectiveStyle]}" - does it look right? 197 198CONFIDENCE SCORING (be critical, don't default to high scores): 199- 0.95-1.0: Minimal changes, high certainty (fixed capitalization, removed obvious suffix) 200- 0.8-0.9: Standard normalization with clear result 201- 0.6-0.75: Significant transformation OR institutional names (churches, universities, government) that may have preferred forms 202- 0.4-0.55: Ambiguous input, multiple valid interpretations, or controversial shortening 203- Below 0.4: Very uncertain, likely needs human review 204 205OUTPUT FORMAT (strict JSON, no comments): 206[{"index": 0, "normalized": "Example Corp", "confidence": 0.95}, {"index": 1, "normalized": "Another Inc", "confidence": 0.9}] 207Return ONLY the JSON array with objects containing "index", "normalized", and "confidence" keys.`; 208} 209 210/** 211 * Create a normalizer instance configured with Apify's OpenRouter standby actor. 212 * Uses APIFY_TOKEN for authentication - no separate API key needed. 213 * @param {string} model - OpenRouter model to use 214 * @param {string} style - Output style ('casual', 'formal', or 'legal') 215 * @param {string|null} openRouterApiKey - Optional OpenRouter API key for direct API access (bring your own key) 216 * @returns {Object} Normalizer with normalize() method 217 */ 218export function createNormalizer(model, style = 'casual', openRouterApiKey = null) { 219 let openai; 220 221 if (openRouterApiKey) { 222 log.info('Using direct OpenRouter API (bring your own key)'); 223 openai = new OpenAI({ 224 baseURL: OPENROUTER_DIRECT_URL, 225 apiKey: openRouterApiKey, 226 timeout: 120_000, 227 }); 228 } else { 229 const apifyToken = process.env.APIFY_TOKEN; 230 if (!apifyToken) { 231 throw new Error('APIFY_TOKEN environment variable is required for OpenRouter access'); 232 } 233 openai = new OpenAI({ 234 baseURL: OPENROUTER_BASE_URL, 235 apiKey: 'apify-openrouter', 236 timeout: 120_000, 237 defaultHeaders: { 238 Authorization: `Bearer ${apifyToken}`, 239 }, 240 }); 241 } 242 243 const systemPrompt = buildSystemPrompt(style); 244 245 return { 246 /** 247 * Normalize an array of items using the LLM. 248 * Automatically scales concurrency based on request size. 249 * @param {Array} items - Items with preProcessed values 250 * @returns {Promise<Array>} Items with normalized values, confidence, and reasoning 251 */ 252 async normalize(items) { 253 // Split items into batches 254 const batches = []; 255 for (let i = 0; i < items.length; i += BATCH_SIZE) { 256 batches.push({ 257 items: items.slice(i, i + BATCH_SIZE), 258 startIndex: i, 259 }); 260 } 261 262 const totalBatches = batches.length; 263 264 // Scale concurrency based on total request size 265 const concurrency = items.length >= LARGE_REQUEST_THRESHOLD 266 ? LARGE_REQUEST_CONCURRENCY 267 : DEFAULT_CONCURRENCY; 268 269 log.info(`Processing ${items.length} items in ${totalBatches} batches (concurrency: ${concurrency})`); 270 271 // Process batches in parallel with concurrency limit 272 const results = new Array(items.length); 273 for (let i = 0; i < batches.length; i += concurrency) { 274 const chunk = batches.slice(i, i + concurrency); 275 const chunkStart = i + 1; 276 const chunkEnd = Math.min(i + concurrency, totalBatches); 277 278 log.info(`Processing batches ${chunkStart}-${chunkEnd}/${totalBatches}`); 279 280 const chunkResults = await Promise.allSettled( 281 chunk.map((batch) => normalizeBatch(openai, model, systemPrompt, batch.items)), 282 ); 283 284 // Place results in correct positions 285 chunk.forEach((batch, idx) => { 286 const settled = chunkResults[idx]; 287 if (settled.status === 'fulfilled') { 288 settled.value.forEach((result, resultIdx) => { 289 results[batch.startIndex + resultIdx] = result; 290 }); 291 } else { 292 log.error(`Batch ${i + idx + 1} failed: ${settled.reason?.message}`); 293 batch.items.forEach((item, resultIdx) => { 294 results[batch.startIndex + resultIdx] = { 295 output: item.preProcessed || item.original, 296 confidence: 0, 297 error: settled.reason?.message || 'Batch failed', 298 }; 299 }); 300 } 301 }); 302 } 303 304 return results; 305 }, 306 }; 307} 308 309/** 310 * Sleep for a given number of milliseconds. 311 * @param {number} ms - Milliseconds to sleep 312 * @returns {Promise<void>} 313 */ 314function sleep(ms) { 315 return new Promise((resolve) => { 316 setTimeout(resolve, ms); 317 }); 318} 319 320/** 321 * Check if an error is retryable (network issues, rate limits, server errors). 322 * @param {Error} error - The error to check 323 * @returns {boolean} True if the error is retryable 324 */ 325function isRetryableError(error) { 326 // Network errors 327 if (error.code === 'ECONNRESET' || error.code === 'ETIMEDOUT' || error.code === 'ENOTFOUND') { 328 return true; 329 } 330 // Rate limiting (429) or server errors (5xx) 331 if (error.status === 429 || error.status >= 500) { 332 return true; 333 } 334 // OpenAI/OpenRouter specific errors 335 if (error.message?.includes('timeout') || error.message?.includes('network')) { 336 return true; 337 } 338 return false; 339} 340 341/** 342 * Normalize a batch of items with a single LLM call. 343 * Includes retry logic with exponential backoff. 344 * @param {OpenAI} openai - OpenAI client instance 345 * @param {string} model - Model identifier 346 * @param {string} systemPrompt - Type-specific system prompt 347 * @param {Array} items - Batch of items to normalize 348 * @returns {Promise<Array>} Normalized items 349 */ 350async function normalizeBatch(openai, model, systemPrompt, items) { 351 const prompt = buildPrompt(items); 352 let lastError; 353 354 for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) { 355 try { 356 const completion = await openai.chat.completions.create({ 357 model, 358 messages: [ 359 { role: 'system', content: systemPrompt }, 360 { role: 'user', content: prompt }, 361 ], 362 temperature: 0.3, // Low temperature for consistent results 363 max_tokens: MAX_TOKENS, // Ensure complete JSON responses 364 timeout: 60000, // 60 second timeout 365 }); 366 367 const responseContent = completion.choices[0]?.message?.content; 368 if (!responseContent) { 369 throw new Error('Empty response from LLM'); 370 } 371 372 return parseResponse(responseContent, items); 373 } catch (error) { 374 lastError = error; 375 376 if (attempt < MAX_RETRIES && isRetryableError(error)) { 377 const delayMs = INITIAL_RETRY_DELAY_MS * (2 ** (attempt - 1)); // Exponential backoff 378 log.warning(`LLM request failed (attempt ${attempt}/${MAX_RETRIES}), retrying in ${delayMs}ms...`, { 379 error: error.message, 380 }); 381 await sleep(delayMs); 382 } else if (attempt < MAX_RETRIES) { 383 // Non-retryable error, don't retry 384 log.error('LLM request failed with non-retryable error', { error: error.message }); 385 break; 386 } 387 } 388 } 389 390 // All retries exhausted or non-retryable error - return pass-through results 391 // instead of crashing the entire run. Failed items get low confidence so users can identify them. 392 const errorMessage = lastError?.message || 'Unknown error'; 393 log.error(`LLM request failed after all retries, returning pass-through for ${items.length} items`, { error: errorMessage }); 394 return items.map((item) => ({ 395 output: item.preProcessed || item.original, 396 confidence: 0, 397 error: errorMessage, 398 })); 399} 400 401/** 402 * Build the user prompt for a batch of items. 403 * @param {Array} items - Items to include in prompt 404 * @returns {string} Formatted prompt 405 */ 406function buildPrompt(items) { 407 const itemList = items.map((item, i) => { 408 // Show both original and preprocessed so model can factor preprocessing into confidence 409 if (item.input !== item.preProcessed) { 410 return `${i}. "${item.input}" (preprocessed: "${item.preProcessed}")`; 411 } 412 return `${i}. "${item.preProcessed}"`; 413 }).join('\n'); 414 415 return `Normalize the following ${items.length} company names. 416 417Note: Some items show "(preprocessed: ...)" — normalize from the PREPROCESSED form, not the original. Legal suffixes (LLC, PLLC, P.C., Inc., etc.) have already been stripped per style rules. Do NOT re-add them. The original is shown only for context. 418 419${itemList}`; 420} 421 422/** 423 * Attempt to repair truncated JSON arrays by finding the last complete object. 424 * This handles cases where LLM output is cut off mid-response. 425 * @param {string} jsonStr - Potentially truncated JSON string 426 * @returns {string} Repaired JSON string (or original if repair not needed/possible) 427 */ 428function repairTruncatedJson(jsonStr) { 429 // Quick check: if it parses, no repair needed 430 try { 431 JSON.parse(jsonStr); 432 return jsonStr; 433 } catch { 434 // Continue with repair attempt 435 } 436 437 // Only attempt repair on arrays 438 if (!jsonStr.trimStart().startsWith('[')) { 439 return jsonStr; 440 } 441 442 // Find the last complete object by looking for the last "}," or "}" before truncation 443 // Work backwards to find valid JSON 444 let lastValidEnd = -1; 445 446 // Look for last complete object ending with }, 447 const lastCommaObj = jsonStr.lastIndexOf('},'); 448 if (lastCommaObj > 0) { 449 lastValidEnd = lastCommaObj + 1; // Include the } 450 } 451 452 // Also check for a final object ending with just } 453 const lastBrace = jsonStr.lastIndexOf('}'); 454 if (lastBrace > lastValidEnd) { 455 // Check if this could be a complete object (not truncated mid-value) 456 const afterBrace = jsonStr.slice(lastBrace + 1).trim(); 457 if (afterBrace === '' || afterBrace === ']' || afterBrace.startsWith(',') || afterBrace.startsWith(']')) { 458 lastValidEnd = lastBrace; 459 } 460 } 461 462 if (lastValidEnd > 0) { 463 const repaired = `${jsonStr.slice(0, lastValidEnd + 1)}]`; 464 try { 465 JSON.parse(repaired); 466 log.debug('Repaired truncated JSON response', { 467 originalLength: jsonStr.length, 468 repairedLength: repaired.length, 469 }); 470 return repaired; 471 } catch { 472 // Repair failed, return original 473 } 474 } 475 476 return jsonStr; 477} 478 479/** 480 * Parse the LLM response and map results back to original items. 481 * @param {string} content - Raw LLM response content 482 * @param {Array} originalItems - Original items for fallback 483 * @returns {Array} Items with normalized values 484 */ 485function parseResponse(content, originalItems) { 486 try { 487 // Handle potential markdown code blocks 488 let jsonStr = content.trim(); 489 if (jsonStr.includes('```')) { 490 jsonStr = jsonStr.replace(/```json?\n?/g, '').replace(/```/g, '').trim(); 491 } 492 493 // Strip JavaScript-style comments that LLMs sometimes add 494 jsonStr = jsonStr.replace(/\/\/[^\n]*/g, ''); // Remove // comments 495 jsonStr = jsonStr.replace(/\/\*[\s\S]*?\*\//g, ''); // Remove /* */ comments 496 497 // Fix malformed tuple format: {"0", "name", 0.95} -> {"index": 0, "normalized": "name", "confidence": 0.95} 498 jsonStr = jsonStr.replace( 499 /\{"(\d+)",\s*"([^"]*)",\s*([\d.]+)\}/g, 500 '{"index": $1, "normalized": "$2", "confidence": $3}', 501 ); 502 503 // Handle truncated JSON by attempting to repair incomplete arrays 504 jsonStr = repairTruncatedJson(jsonStr); 505 506 const parsed = JSON.parse(jsonStr); 507 508 if (!Array.isArray(parsed)) { 509 throw new Error('Response is not an array'); 510 } 511 512 // Map response back to original items 513 return originalItems.map((item, i) => { 514 const result = parsed.find((r) => r.index === i); 515 if (result) { 516 return { 517 ...item, 518 normalized: postProcessCapitalization(result.normalized || item.preProcessed, item.original), 519 confidence: clampConfidence(result.confidence), 520 reasoning: result.reasoning || '', 521 }; 522 } 523 // Fallback if item not in response 524 return { 525 ...item, 526 normalized: postProcessCapitalization(item.preProcessed, item.original), 527 confidence: 0.5, 528 reasoning: 'Item not found in LLM response', 529 }; 530 }); 531 } catch (error) { 532 log.warning('Failed to parse LLM response', { error: error.message, content: content.slice(0, 200) }); 533 534 // Return pre-processed values with low confidence 535 return originalItems.map((item) => ({ 536 ...item, 537 normalized: postProcessCapitalization(item.preProcessed, item.original), 538 confidence: 0.4, 539 reasoning: `Failed to parse LLM response: ${error.message}`, 540 })); 541 } 542} 543 544/** 545 * Clamp confidence value to valid range [0, 1]. 546 * @param {number} value - Raw confidence value 547 * @returns {number} Clamped confidence 548 */ 549function clampConfidence(value) { 550 if (typeof value !== 'number' || Number.isNaN(value)) { 551 return 0.5; 552 } 553 return Math.max(0, Math.min(1, value)); 554} 555 556/** 557 * Post-process normalized text to fix common LLM capitalization errors. 558 * @param {string} text - Normalized text from LLM 559 * @param {string} original - Original input for reference 560 * @returns {string} Text with capitalization fixes applied 561 */ 562function postProcessCapitalization(text, original = '') { 563 if (!text || typeof text !== 'string') { 564 return text; 565 } 566 567 let result = text; 568 569 // Fix apostrophe-S capitalization: "Stone'S" -> "Stone's", "McDonald'S" -> "McDonald's" 570 // Pattern: word character followed by apostrophe and uppercase S 571 result = result.replace(/(\w)'S\b/g, "$1's"); 572 573 // Preserve alphanumeric codes that contain digits (like "3CD", "3M", "H2O") 574 // Only restore codes that have at least one digit - this avoids restoring 575 // regular English words like PARK, CLUB, LAND, TRUST that happen to be all-caps 576 if (original) { 577 // Match codes that contain at least one digit and are 2-5 chars 578 const alphanumericCodes = original.match(/\b(?=[A-Z0-9&]*[0-9])[A-Z0-9&]{2,5}\b/g) || []; 579 580 for (const code of alphanumericCodes) { 581 const lowerCode = code.toLowerCase(); 582 const codePattern = new RegExp(`\\b${escapeRegexChars(lowerCode)}\\b`, 'gi'); 583 584 // Restore the original capitalization 585 if (original.includes(code)) { 586 result = result.replace(codePattern, code); 587 } 588 } 589 } 590 591 return result; 592} 593 594/** 595 * Escape special regex characters in a string. 596 * @param {string} str - String to escape 597 * @returns {string} Escaped string 598 */ 599function escapeRegexChars(str) { 600 return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); 601}

1/** 2 * Superclean Company Names 3 * 4 * Transforms messy company names into clean, professional formats 5 * for cold email personalization, sales outreach, and CRM cleanup. 6 */ 7 8import http from 'node:http'; 9import { Actor, log } from 'apify'; 10 11import { createNormalizer } from './normalizer.js'; 12import { preprocess } from './preprocessor.js'; 13 14/** 15 * Normalize flexible input formats for Clay/API compatibility. 16 * Accepts: ["string"] or [{input: "string"}] 17 * Returns: ["string"] 18 */ 19function normalizeItems(items) { 20 return items.map((item) => { 21 if (typeof item === 'string') { 22 return item; 23 } 24 if (item && typeof item === 'object' && 'input' in item) { 25 return String(item.input ?? ''); 26 } 27 return String(item ?? ''); 28 }); 29} 30 31await Actor.init(); 32 33if (Actor.config.get('metaOrigin') === 'STANDBY') { 34 startStandbyServer(); 35} else { 36 await runBatchMode(); 37 await Actor.exit(); 38} 39 40// --------------------------------------------------------------------------- 41// Standby mode — HTTP server for instant single-name cleaning 42// --------------------------------------------------------------------------- 43 44function startStandbyServer() { 45 const port = Actor.config.get('containerPort'); 46 47 const server = http.createServer(async (req, res) => { 48 // Readiness probe 49 if (req.headers['x-apify-container-server-readiness-probe']) { 50 res.writeHead(200, { 'Content-Type': 'application/json' }); 51 res.end(JSON.stringify({ status: 'ready' })); 52 return; 53 } 54 55 // GET only 56 if (req.method !== 'GET') { 57 res.writeHead(405, { 'Content-Type': 'application/json' }); 58 res.end(JSON.stringify({ error: 'Method not allowed. Use GET.' })); 59 return; 60 } 61 62 // No input param → serve landing page 63 const reqUrl = new URL(req.url, `http://${req.headers.host}`); 64 if (!reqUrl.searchParams.get('input')) { 65 res.writeHead(200, { 'Content-Type': 'text/html' }); 66 res.end(getLandingPageHtml()); 67 return; 68 } 69 70 try { 71 const result = await handleStandbyRequest(reqUrl, req); 72 await Actor.pushData(result); 73 74 res.writeHead(200, { 'Content-Type': 'application/json' }); 75 res.end(JSON.stringify(result)); 76 } catch (err) { 77 const statusCode = err.statusCode || 500; 78 res.writeHead(statusCode, { 'Content-Type': 'application/json' }); 79 res.end(JSON.stringify({ error: err.message })); 80 } 81 }); 82 83 server.listen(port, () => { 84 console.log(`Superclean Company Names Standby server listening on port ${port}`); 85 }); 86} 87 88async function handleStandbyRequest(reqUrl, req) { 89 const input = reqUrl.searchParams.get('input'); 90 91 if (!input) { 92 const err = new Error("Provide an 'input' query parameter with the company name to clean."); 93 err.statusCode = 400; 94 throw err; 95 } 96 97 const style = reqUrl.searchParams.get('style') || 'casual'; 98 const model = reqUrl.searchParams.get('model') || 'openrouter/auto'; 99 const openRouterApiKey = req.headers['x-openrouter-key'] || null; 100 101 const validStyles = ['casual', 'formal', 'legal']; 102 if (!validStyles.includes(style)) { 103 const err = new Error(`Invalid style "${style}". Must be one of: ${validStyles.join(', ')}`); 104 err.statusCode = 400; 105 throw err; 106 } 107 108 const trimmed = input.trim(); 109 if (!trimmed) { 110 return { id: 1, input, output: '', confidence: 0 }; 111 } 112 113 // Preprocess 114 const preprocessResult = preprocess(trimmed, style); 115 116 // Non-English → return extracted English or original 117 if (preprocessResult.isNonEnglish) { 118 return { 119 id: 1, 120 input: trimmed, 121 output: preprocessResult.extractedEnglish || trimmed, 122 confidence: 0, 123 }; 124 } 125 126 // LLM normalization 127 const item = { 128 id: 1, 129 input: trimmed, 130 preProcessed: preprocessResult.value, 131 isNonEnglish: false, 132 extractedEnglish: preprocessResult.extractedEnglish, 133 }; 134 135 const normalizer = createNormalizer(model, style, openRouterApiKey); 136 const normalizedItems = await normalizer.normalize([item]); 137 138 if (normalizedItems.length === 0) { 139 return { id: 1, input: trimmed, output: trimmed, confidence: 0 }; 140 } 141 142 return { 143 id: 1, 144 input: trimmed, 145 output: normalizedItems[0].normalized, 146 confidence: Math.round(normalizedItems[0].confidence * 100) / 100, 147 }; 148} 149 150// --------------------------------------------------------------------------- 151// Batch mode — existing pipeline for standard Actor runs 152// --------------------------------------------------------------------------- 153 154async function runBatchMode() { 155 // Get input 156 const input = await Actor.getInput(); 157 let { items: rawItems, item } = input || {}; 158 159 // Support single "item" string field for API/integration callers 160 if (typeof item === 'string' && item.trim()) { 161 if (!Array.isArray(rawItems)) rawItems = []; 162 rawItems = [item.trim(), ...rawItems]; 163 } 164 165 // Coerce bare string to array 166 if (typeof rawItems === 'string') rawItems = [rawItems]; 167 168 // Validate input 169 if (!rawItems || !Array.isArray(rawItems) || rawItems.length === 0) { 170 await Actor.fail('Input required: provide "items" (array) or "item" (single string). Example: {"items": ["Acme Inc"]}'); 171 return; 172 } 173 174 // Extract configuration with defaults 175 const style = input.style ?? 'casual'; 176 const model = input.model ?? 'openrouter/auto'; 177 const openRouterApiKey = input.openRouterApiKey ?? null; 178 179 // Normalize input format (supports both ["string"] and [{input: "string"}]) 180 const items = normalizeItems(rawItems); 181 182 log.info(`Starting normalization of ${items.length} company names`, { 183 style, 184 model, 185 }); 186 187 // Step 1: Run pre-processing on normalized items 188 const processedItems = items.map((item, index) => { 189 // Handle string input 190 const value = typeof item === 'string' ? item : String(item || ''); 191 const id = index + 1; 192 193 // Validate value 194 if (!value.trim()) { 195 log.warning(`Skipping invalid item at index ${index}`, { item }); 196 return null; 197 } 198 199 // Run pre-processing (pass style to preserve suffixes in legal mode) 200 const preprocessResult = preprocess(value, style); 201 202 return { 203 id, 204 input: value, 205 preProcessed: preprocessResult.value, 206 isNonEnglish: preprocessResult.isNonEnglish, 207 extractedEnglish: preprocessResult.extractedEnglish, 208 }; 209 }); 210 211 // Filter out invalid items 212 const validItems = processedItems.filter((item) => item !== null); 213 214 if (validItems.length === 0) { 215 throw new Error('No valid items to process after input validation'); 216 } 217 218 // Separate English and non-English items 219 const englishItems = validItems.filter((item) => !item.isNonEnglish); 220 const nonEnglishItems = validItems.filter((item) => item.isNonEnglish); 221 222 if (nonEnglishItems.length > 0) { 223 log.info(`Flagging ${nonEnglishItems.length} non-English items for review`); 224 } 225 226 log.info(`Pre-processed ${validItems.length} items (${englishItems.length} English, ${nonEnglishItems.length} non-English)`); 227 228 // Step 2: LLM normalization for English items only 229 // Uses Apify's OpenRouter standby actor - authentication via APIFY_TOKEN 230 let normalizedItems = []; 231 if (englishItems.length > 0) { 232 const normalizer = createNormalizer(model, style, openRouterApiKey); 233 normalizedItems = await normalizer.normalize(englishItems); 234 } 235 236 // Step 3: Build output - combine LLM results with non-English items 237 const englishResults = normalizedItems.map((item) => ({ 238 id: item.id, 239 input: item.input, 240 output: item.normalized, 241 confidence: Math.round(item.confidence * 100) / 100, 242 })); 243 244 const nonEnglishResults = nonEnglishItems.map((item) => ({ 245 id: item.id, 246 input: item.input, 247 // Use extracted English portion if available, otherwise keep input 248 output: item.extractedEnglish || item.input, 249 confidence: 0, 250 })); 251 252 const results = [...englishResults, ...nonEnglishResults]; 253 254 // Push results to dataset 255 256 await Actor.pushData(results); 257 258 // Log summary 259 const avgConfidence = results.reduce((sum, r) => sum + r.confidence, 0) / results.length; 260 261 log.info(`Normalization complete`, { 262 totalItems: results.length, 263 averageConfidence: Math.round(avgConfidence * 100) / 100, 264 }); 265} 266 267// --------------------------------------------------------------------------- 268// Landing page HTML for Standby mode 269// --------------------------------------------------------------------------- 270 271function getLandingPageHtml() { 272 return `<!DOCTYPE html> 273<html lang="en"> 274<head> 275<meta charset="utf-8"> 276<meta name="viewport" content="width=device-width, initial-scale=1"> 277<title>Superclean Company Names — Superlative</title> 278<link rel="preconnect" href="https://fonts.googleapis.com"> 279<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin> 280<link href="https://fonts.googleapis.com/css2?family=DM+Sans:wght@400;500;700&family=Space+Mono:wght@400;700&display=swap" rel="stylesheet"> 281<style> 282:root{--color-bg:#0a0e14;--color-surface:#12171f;--color-border:#1e2632;--color-text:#e8eaed;--color-text-muted:#8b95a5;--color-accent:#4ade80;--color-accent-dim:rgba(74,222,128,0.15);--font-display:'Space Mono',monospace;--font-body:'DM Sans',sans-serif} 283*{margin:0;padding:0;box-sizing:border-box} 284body{font-family:var(--font-body);background:var(--color-bg);color:var(--color-text);line-height:1.6;min-height:100vh;overflow-x:hidden} 285a{color:var(--color-accent);text-decoration:none;transition:color .2s ease} 286a:hover{color:#6ee7a0} 287.grid-bg{position:fixed;top:0;left:0;width:100%;height:100%;background-image:linear-gradient(var(--color-border) 1px,transparent 1px),linear-gradient(90deg,var(--color-border) 1px,transparent 1px);background-size:60px 60px;opacity:.3;pointer-events:none;z-index:0} 288.accent-line{position:fixed;top:0;left:0;width:100%;height:2px;background:linear-gradient(90deg,transparent 0%,var(--color-accent) 50%,transparent 100%);animation:shimmer 3s ease-in-out infinite;z-index:10} 289@keyframes shimmer{0%,100%{transform:translateX(-100%)}50%{transform:translateX(100%)}} 290@keyframes fadeUp{from{opacity:0;transform:translateY(20px)}to{opacity:1;transform:translateY(0)}} 291.container{position:relative;z-index:1;max-width:900px;margin:0 auto;padding:0 24px} 292header{padding:32px 0} 293.logo{font-family:var(--font-display);font-size:14px;font-weight:700;letter-spacing:.1em;text-transform:uppercase;color:var(--color-text);display:flex;align-items:center;gap:10px;text-decoration:none} 294.logo:hover{color:var(--color-text)} 295.logo-mark{width:28px;height:28px;background:var(--color-accent);display:flex;align-items:center;justify-content:center} 296.logo-mark svg{width:16px;height:16px} 297.hero{padding:80px 0 60px;animation:fadeUp .8s ease-out} 298.hero-label{font-family:var(--font-display);font-size:12px;font-weight:400;letter-spacing:.15em;text-transform:uppercase;color:var(--color-accent);margin-bottom:24px;display:flex;align-items:center;gap:12px} 299.hero-label::before{content:'';width:24px;height:1px;background:var(--color-accent)} 300h1{font-family:var(--font-display);font-size:clamp(28px,5vw,44px);font-weight:700;line-height:1.15;margin-bottom:20px;letter-spacing:-.02em} 301h1 .highlight{color:var(--color-accent)} 302.hero-desc{font-size:18px;color:var(--color-text-muted);max-width:540px;margin-bottom:28px;line-height:1.7} 303.hero-link{font-family:var(--font-display);font-size:13px;letter-spacing:.05em;color:var(--color-accent);display:inline-flex;align-items:center;gap:6px} 304.section{padding:60px 0;border-top:1px solid var(--color-border);animation:fadeUp .8s ease-out .2s backwards} 305.section-label{font-family:var(--font-display);font-size:11px;font-weight:400;letter-spacing:.2em;text-transform:uppercase;color:var(--color-text-muted);margin-bottom:24px} 306h2{font-family:var(--font-display);font-size:20px;font-weight:700;margin-bottom:16px;letter-spacing:-.01em} 307p,li{font-size:15px;color:var(--color-text-muted);line-height:1.7} 308li{margin-bottom:6px} 309ul{margin:.5rem 0 1rem 1.25rem} 310strong{color:var(--color-text);font-weight:600} 311pre{background:var(--color-surface);color:var(--color-text);padding:16px 20px;overflow-x:auto;margin:12px 0 16px;font-family:var(--font-display);font-size:13px;line-height:1.6;border:1px solid var(--color-border)} 312code{font-family:var(--font-display);font-size:13px} 313p code,li code,td code{background:var(--color-accent-dim);color:var(--color-accent);padding:2px 6px} 314table{width:100%;border-collapse:collapse;margin:12px 0 16px;font-size:14px} 315th,td{border:1px solid var(--color-border);padding:10px 14px;text-align:left} 316th{background:var(--color-surface);color:var(--color-text-muted);font-family:var(--font-display);font-size:12px;font-weight:400;letter-spacing:.05em;text-transform:uppercase} 317td{color:var(--color-text-muted)} 318.badge{display:inline-block;background:var(--color-accent-dim);color:var(--color-accent);padding:3px 8px;font-family:var(--font-display);font-size:11px;font-weight:400;letter-spacing:.05em} 319.note{font-size:13px;color:var(--color-text-muted);margin-top:8px} 320.product-grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(240px,1fr));gap:16px;margin-top:24px} 321.product-card{background:var(--color-surface);border:1px solid var(--color-border);padding:24px;transition:all .3s ease;text-decoration:none;color:inherit;display:block} 322.product-card:hover{border-color:var(--color-accent);transform:translateY(-2px)} 323.product-name{font-family:var(--font-display);font-size:14px;font-weight:700;margin-bottom:8px;color:var(--color-text);display:flex;align-items:center;gap:8px} 324.product-name .status{font-size:9px;font-weight:400;padding:3px 6px;background:var(--color-accent-dim);color:var(--color-accent);letter-spacing:.1em} 325.product-desc{font-size:14px;color:var(--color-text-muted);line-height:1.5} 326footer{padding:48px 0;border-top:1px solid var(--color-border)} 327.footer-content{display:flex;justify-content:space-between;align-items:center;flex-wrap:wrap;gap:24px} 328.footer-text{font-size:13px;color:var(--color-text-muted)} 329.footer-links{display:flex;gap:24px} 330.footer-links a{font-family:var(--font-display);font-size:12px;color:var(--color-text-muted);letter-spacing:.05em} 331.footer-links a:hover{color:var(--color-accent)} 332@media(max-width:600px){.hero{padding:60px 0 40px}.section{padding:40px 0}.footer-content{flex-direction:column;align-items:flex-start}pre{font-size:12px;padding:12px 14px}} 333</style> 334</head> 335<body> 336<div class="grid-bg"></div> 337<div class="accent-line"></div> 338 339<div class="container"> 340 <header> 341 <a href="https://apify.com/superlativetech?fpr=8e9l1" class="logo"> 342 <div class="logo-mark"> 343 <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5"> 344 <polyline points="4 17 10 11 4 5"></polyline> 345 <line x1="12" y1="19" x2="20" y2="19"></line> 346 </svg> 347 </div> 348 Superlative 349 </a> 350 </header> 351 352 <section class="hero"> 353 <div class="hero-label">Superclean</div> 354 <h1>Company <span class="highlight">Names</span></h1> 355 <p class="hero-desc">Instant company name normalization. AI-powered cleaning for cold email, CRM, and sales outreach. Sub-second responses via Standby API.</p> 356 <a href="https://apify.com/superlativetech/superclean-company-names?fpr=8e9l1" class="hero-link">View on Apify Store →</a> 357 </section> 358 359 <section class="section"> 360 <div class="section-label">Features</div> 361 <h2>What this does</h2> 362 <ul> 363 <li><strong>AI-powered cleaning</strong> — LLM normalizes company names with context awareness</li> 364 <li><strong>Three styles</strong> — Casual (cold email), Formal (CRM), Legal (contracts)</li> 365 <li><strong>Strips noise</strong> — Legal suffixes, ALL CAPS, country prefixes, descriptors</li> 366 <li><strong>BYOK support</strong> — Use your own OpenRouter API key via header</li> 367 <li><strong>Batch mode</strong> — Process hundreds of names via the standard Actor run</li> 368 </ul> 369 </section> 370 371 <section class="section"> 372 <div class="section-label">Getting Started</div> 373 <h2>Quick start</h2> 374 <p>Replace <code>YOUR_TOKEN</code> with your Apify API token.</p> 375 376 <p style="margin-top:16px"><strong>Casual style (cold email):</strong></p> 377 <pre>curl "https://superlativetech--superclean-company-names.apify.actor?token=YOUR_TOKEN&input=ACME+CORPORATION,+INC."</pre> 378 379 <p><strong>Formal style (CRM):</strong></p> 380 <pre>curl "https://superlativetech--superclean-company-names.apify.actor?token=YOUR_TOKEN&input=ACME+CORPORATION,+INC.&style=formal"</pre> 381 382 <p><strong>With your own OpenRouter key:</strong></p> 383 <pre>curl -H "X-OpenRouter-Key: sk-or-..." "https://superlativetech--superclean-company-names.apify.actor?token=YOUR_TOKEN&input=ACME+CORPORATION"</pre> 384 </section> 385 386 <section class="section"> 387 <div class="section-label">Reference</div> 388 <h2>Query parameters</h2> 389 <table> 390 <tr><th>Parameter</th><th>Required</th><th>Description</th></tr> 391 <tr><td><code>input</code></td><td>Yes</td><td>Company name to clean</td></tr> 392 <tr><td><code>style</code></td><td>No</td><td>Output style: <code>casual</code> (default), <code>formal</code>, or <code>legal</code></td></tr> 393 <tr><td><code>model</code></td><td>No</td><td>LLM model (default: <code>openrouter/auto</code>)</td></tr> 394 <tr><td><code>token</code></td><td>Yes</td><td>Your Apify API token</td></tr> 395 </table> 396 <h2 style="margin-top:24px">Headers</h2> 397 <table> 398 <tr><th>Header</th><th>Required</th><th>Description</th></tr> 399 <tr><td><code>X-OpenRouter-Key</code></td><td>No</td><td>Your OpenRouter API key for BYOK (keeps secrets out of URL logs)</td></tr> 400 </table> 401 </section> 402 403 <section class="section"> 404 <div class="section-label">Response</div> 405 <h2>Response format</h2> 406 <pre>{ 407 "id": 1, 408 "input": "ACME CORPORATION, INC.", 409 "output": "Acme", 410 "confidence": 0.95 411}</pre> 412 </section> 413 414 <section class="section"> 415 <div class="section-label">Cost</div> 416 <h2>Pricing</h2> 417 <p>Free to use — you only pay standard Apify platform usage.</p> 418 </section> 419 420 <section class="section"> 421 <div class="section-label">Auth</div> 422 <h2>Authentication</h2> 423 <p>Authenticate using either method:</p> 424 <ul> 425 <li>Query parameter: <code>?token=YOUR_APIFY_TOKEN</code></li> 426 <li>Header: <code>Authorization: Bearer YOUR_APIFY_TOKEN</code></li> 427 </ul> 428 <p style="margin-top:8px">Get your token from <a href="https://console.apify.com/settings/integrations">Apify Console → Settings → Integrations</a>.</p> 429 </section> 430 431 <section class="section"> 432 <div class="section-label">Superlative</div> 433 <h2>More from Superlative</h2> 434 <div class="product-grid"> 435 <a href="https://apify.com/superlativetech/superclean-job-titles?fpr=8e9l1" class="product-card"> 436 <div class="product-name">Job Titles <span class="status">Live</span></div> 437 <p class="product-desc">Standardize job titles for outreach sequences.</p> 438 </a> 439 <a href="https://apify.com/superlativetech/superclean-person-names?fpr=8e9l1" class="product-card"> 440 <div class="product-name">Person Names <span class="status">Live</span></div> 441 <p class="product-desc">Clean and format person names for personalization.</p> 442 </a> 443 <a href="https://apify.com/superlativetech/superclean-product-names?fpr=8e9l1" class="product-card"> 444 <div class="product-name">Product Names <span class="status">Live</span></div> 445 <p class="product-desc">Normalize product and brand names from exports.</p> 446 </a> 447 <a href="https://apify.com/superlativetech/superclean-places?fpr=8e9l1" class="product-card"> 448 <div class="product-name">Places <span class="status">Live</span></div> 449 <p class="product-desc">Parse and standardize location strings.</p> 450 </a> 451 <a href="https://apify.com/superlativetech/superclean-urls?fpr=8e9l1" class="product-card"> 452 <div class="product-name">URLs <span class="status">Live</span></div> 453 <p class="product-desc">Clean and normalize URLs from lead data.</p> 454 </a> 455 <a href="https://apify.com/superlativetech/superclean-phone-numbers?fpr=8e9l1" class="product-card"> 456 <div class="product-name">Phone Numbers <span class="status">Live</span></div> 457 <p class="product-desc">Format and validate phone numbers.</p> 458 </a> 459 <a href="https://apify.com/superlativetech/dns-lookup?fpr=8e9l1" class="product-card"> 460 <div class="product-name">Supernet DNS Lookup <span class="status">Live</span></div> 461 <p class="product-desc">Look up DNS records for any domain.</p> 462 </a> 463 <a href="https://apify.com/superlativetech/http-api?fpr=8e9l1" class="product-card"> 464 <div class="product-name">HTTP API <span class="status">Live</span></div> 465 <p class="product-desc">General-purpose HTTP request utility.</p> 466 </a> 467 </div> 468 </section> 469 470 <footer> 471 <div class="footer-content"> 472 <p class="footer-text">© 2026 Superlative</p> 473 <div class="footer-links"> 474 <a href="https://apify.com/superlativetech?fpr=8e9l1">Apify Store</a> 475 </div> 476 </div> 477 </footer> 478</div> 479 480</body> 481</html>`; 482}