How to Get a Company's Social Profiles

You need to automatically collect a company’s official social profiles (Facebook, X, Instagram, YouTube, LinkedIn, GitHub, Pinterest, Medium) and plug them into your enrichment or brand-safety pipeline. By the end of this guide you’ll call a single endpoint that returns those profile URLs for any domain, handle nulls for missing networks, cache results, and ship production-ready code that scales.

Why Klazify is ideal for extracting and operationalizing company social profiles

If your goal is to populate CRM records, product signups, or ad-review queues with verified social URLs, Klazify combines social detection with full domain intelligence in one API call pattern. That matters for correct attribution, deduplication, and downstream decisions.

• Accurate Website Categorization Using AI: Klazify analyzes website content (not just metadata), so you can pair social URLs with IAB-mapped categories. This helps you decide whether to ingest, blocklist, or prioritize a domain once you’ve captured its social footprint.
• Global Coverage: Many companies maintain localized social profiles. Klazify’s analysis supports multilingual sites, helping you capture the right primary social handles for non-English domains.
• Real-Time Classification: Social links change without notice. Klazify refreshes based on current page signals rather than relying on stale lookups.
• Industry-Level Categories (IAB): Enrich each domain’s social set with IAB taxonomy to feed audience modeling, brand safety, and content filtering alongside social profile detection.
• Simple API Integration: A clean REST interface with a Bearer token and a small JSON body keeps the implementation tight for both enrichment workers and analytics services.
• Compliance and Filtering: Use detected social profiles to confirm brand ownership and flag impersonation attempts, while IAB categories help you set policy thresholds per vertical.

What you’ll build: social profile enrichment for your pipeline

We’ll fetch a company’s social URLs from a domain once, then store, cache, and reuse them across your systems. Common scenarios:

• Lead enrichment: Given a signup email domain, fetch the official social links and attach them to the company record for your sales and marketing tools.
• Brand safety and ad verification: Validate where advertisers link out to from their websites and ensure their social destinations are legitimate before approving campaigns.
• Content filtering and monitoring: Track changes in a publisher’s social properties as part of continuous review workflows.

You’ll call a single endpoint to get the profiles. Missing profiles return null so you can branch cleanly.

The endpoint to use

Use this endpoint to retrieve a company’s social profiles from a domain:

• HTTP method: POST
• URL: https://www.klazify.com/api/domain_social_media
• Authentication: Bearer token in the Authorization header
• Request body (JSON): {"url":"https://example.com"}
• Profiles covered: Facebook, X, Instagram, YouTube, LinkedIn, GitHub, Pinterest, Medium
• Missing profiles: null

Production notes:

• Normalize input to a canonical domain (e.g., lowercase, strip protocol, collapse www) to maximize cache hits and avoid duplicate requests.
• Expect nulls for networks a company doesn’t use. Branch your logic accordingly.
• Use standard HTTP semantics. For backoffs and retries, apply your usual transient-failure strategy (e.g., exponential backoff on network errors).

cURL: fetch social profiles for a domain

curl -X POST "https://www.klazify.com/api/domain_social_media" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url":"https://cbsnews.com"}'

Notes:

• Replace YOUR_API_KEY with your actual key.
• Expect each platform URL or null. Store null explicitly to avoid repeatedly querying the same domain for that network.

Python example: parse the returned social URLs

This script shows how to call the endpoint, capture all supported networks, handle nulls, and cache results by domain.

import os
import json
import time
import hashlib
import requests

API_KEY = os.getenv("KLAZIFY_API_KEY", "YOUR_API_KEY")
API_URL = "https://www.klazify.com/api/domain_social_media"

def canonical_domain(url_or_domain: str) -> str:
    d = url_or_domain.strip().lower()
    d = d.replace("http://", "").replace("https://", "")
    if d.startswith("www."):
        d = d[4:]
    # trim path if present
    d = d.split("/")[0]
    return d

def cache_key(domain: str) -> str:
    return hashlib.sha256(domain.encode("utf-8")).hexdigest()

def get_cached(domain: str):
    fn = f"/tmp/klazify-social-{cache_key(domain)}.json"
    if os.path.exists(fn):
        with open(fn, "r") as f:
            return json.load(f)
    return None

def set_cached(domain: str, data: dict):
    fn = f"/tmp/klazify-social-{cache_key(domain)}.json"
    with open(fn, "w") as f:
        json.dump({"fetched_at": int(time.time()), "domain": domain, "data": data}, f)

def fetch_social(url_or_domain: str) -> dict:
    domain = canonical_domain(url_or_domain)
    cached = get_cached(domain)
    if cached:
        return cached["data"]
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json",
    }
    payload = {"url": f"https://{domain}"}
    resp = requests.post(API_URL, headers=headers, json=payload, timeout=30)
    resp.raise_for_status()
    data = resp.json()
    set_cached(domain, data)
    return data

def extract_profiles(payload: dict) -> dict:
    # The endpoint returns social URLs for:
    # Facebook, X, Instagram, YouTube, LinkedIn, GitHub, Pinterest, Medium
    # When a profile is missing, its value is null.
    social = payload.get("social_media") or payload.get("domain_social_media") or payload
    # Be defensive: map across expected networks
    networks = ["facebook", "x", "instagram", "youtube", "linkedin", "github", "pinterest", "medium"]
    out = {}
    for n in networks:
        # accept variations like "facebook_url" or "facebook"
        v = social.get(n) if isinstance(social, dict) else None
        if not v and isinstance(social, dict):
            v = social.get(f"{n}_url")
        out[n] = v  # may be a URL string or None
    return out

if __name__ == "__main__":
    data = fetch_social("example.com")
    profiles = extract_profiles(data)
    print(json.dumps(profiles, indent=2))

How to use this in a pipeline:

• If profiles["linkedin"] is not null, append it to your CRM’s company profile. Repeat for the other networks you rely on.
• If all profiles are null, enqueue the domain for a later refresh and store a timestamp to avoid unnecessary recrawls.
• Log domains with partial coverage (e.g., X present but Facebook missing) to improve your enrichment completeness metrics.

Sample JSON from the categorization endpoint and how it complements social URLs

Many teams pair social profiles with categories, logos, and company data. Here’s the official example response from the website categorization endpoint. Keep it alongside your social-profile output to drive downstream policy and enrichment.

{
    "domain": {
        "categories": [
            {
                "confidence": 0.92,
                "name": "/Computers & Electronics/Consumer Electronics",
                "IAB-632-596": "Consumer Electronics/Technology & Computing/Consumer Electronics"
            },
            {
                "confidence": 0.89,
                "name": "/Internet & Telecom/Mobile & Wireless/Mobile Phones"
            }
        ],
        "social_media": null,
        "logo_url": "https://klazify.s3.amazonaws.com/2110787991611585019600ed5fb1d1300.04730104.png"
    },
    "success": true,
    "objects": {
        "company": {
            "url": "https://www.apple.com/",
            "name": "Apple",
            "city": "Cupertino",
            "stateCode": "CA",
            "countryCode": "US",
            "employeesRange": "100K+",
            "revenue": 274515000000,
            "raised": null,
            "tags": [
                "E-commerce",
                "Consumer Electronics",
                "Mobile",
                "B2C"
            ],
            "tech": [
                "omniture_adobe_analytics",
                "atlassian_confluence",
                "successfactors",
                "apache_apex",
                "talend",
                "oracle_peoplesoft",
                "salesforce",
                "stripe",
                "dell_boomi_atomsphere",
                "gigya",
                "sage_50cloud",
                "quickbooks",
                "webmethods",
                "apache_tomcat",
                "alteryx",
                "tibco_rendezvous",
                "atlassian_jira",
                "..."
            ]
        }
    },
    "domain_registration_data": {
        "domain_age_date": "1987-02-19",
        "domain_age_days_ago": "13026",
        "domain_expiration_date": "2030-02-20",
        "domain_expiration_days_left": "123"
    },
    "similar_domains": [
        "bestbuy.com",
        "icloud.com",
        "microsoft.com",
        "macrumors.com",
        "google.com",
        "samsung.com",
        "twitter.com",
        "hp.com",
        "bhphotovideo.com",
        "dell.com"
    ]
}

How to use these fields with your social-profile output:

• domain.categories and IAB mapping: Use these to route domains to the right policy bucket (e.g., content filtering or brand safety tiers) while storing their social links.
• domain.social_media: This field in the categorization response may be null here; you should rely on the dedicated social endpoint for profiles, then join by domain.
• logo_url: Attach the logo next to the social icons in your UI or CRM record.
• objects.company: Helpful for display name, location, and company-level attributes that pair naturally with social URLs.
• domain_registration_data: Cache policy timers or recheck intervals based on domain age signals if relevant to your workflow.
• similar_domains: Consider augmenting your prospecting by fetching social profiles for lookalike domains.

Interpreting the social profile output

The social-profile endpoint returns up to eight URLs. Any unavailable network is returned as null so you can short-circuit lookups and prevent duplicates. Common actions:

Operational details that will save you time

Caching and TTLs

• Cache by canonical domain (e.g., example.com). Many companies expose social links on the homepage, so reusing results across URLs within a domain avoids extra calls.
• Persist explicit nulls. If LinkedIn is null today, write that to storage with a timestamp so your worker won’t re-hit the endpoint for the same domain too frequently.

Batching and throughput

• Queue domains and process in parallel according to your job system. Use a single POST per domain request.
• Respect your application’s concurrency to stay within plan limits. If you approach limits, throttle or pause the queue and retry later.

Handling unknown or new domains

• Some new or lightly maintained sites may not expose consistent social links yet. In these cases you’ll mainly see nulls. Record them and schedule a refresh window.
• Pair the social-profile fetch with a categorization call to gather more context that may guide prioritization for rechecks.

Mapping to your taxonomy

• If your organization uses internal verticals, map Klazify’s IAB-based category output from the categorization endpoint to your own labels. Store that mapping centrally and treat it as a join step in your enrichment pipeline.
• Use the category to prioritize which networks matter. For example, visually driven categories may benefit more from Instagram or Pinterest, while B2B categories emphasize LinkedIn.

Error handling, retries, and billing

• Apply standard retry logic on network timeouts or 5xx responses with exponential backoff.
• Failed or unreachable calls are not billed.
• If you receive application-level errors, log the domain and response payload for quick reprocessing.

Cost, signup, and getting your API key

You can start with the Starter plan at $39.99/mo with a 7-day trial. Create a free account to get your API key and test the social-profile endpoint right away.

• Register
• Documentation
• MCP

Putting it all together in your data flow

• Input: Accept a domain from a user signup, referral link, or ad form submission. Normalize it for caching.
• Social fetch: POST to the social-profile endpoint and store each network’s URL or null.
• Join with categorization: Optionally call the categorization endpoint and attach IAB categories, logo_url, and company info.
• Deduplicate: Keep a single record per domain keyed by a canonical domain string.
• Publish: Write selected fields into your CRM, analytics warehouse, or brand review UI.
• Refresh: Use timestamps to schedule rechecks and prevent noisy repeated calls.

Field usage checklist for production

• Facebook/X/Instagram/YouTube/LinkedIn/GitHub/Pinterest/Medium URLs: Store verbatim; validate they’re HTTPS before showing in your UI.
• null handling: Render empty state gracefully; avoid “Not Found” links.
• categories and IAB mapping (from categorization): Drive policies, allow/deny lists, and analytics segments.
• logo_url: Enrich CRM profiles and dashboards.
• company name and URL: Display-friendly fields when joining with social profiles.
• similar_domains: Optional discovery pass to expand your enrichment.

Quality and latency considerations

• Latency: Keep requests close to your worker location and reuse HTTP connections. If you deploy multi-region, route calls to minimize network hops.
• Validation: If user-submitted domains lead to many nulls, consider pre-validating DNS resolution or HTTP reachability before requesting profiles.
• Observability: Track fields-per-domain coverage and null ratios by category to target improvements.

FAQ

• What happens if a company doesn’t have a profile on a given network? The endpoint returns null for that network. Store the null and add a cooldown before rechecking to avoid redundant requests.
• Can I process many domains at once? Yes. Queue domains and process them in parallel. Apply throttling to align with your plan’s throughput and your system’s concurrency limits.
• How do I handle sites that block crawlers or are temporarily down? Use retries with backoff. If the call ultimately fails or is unreachable, it isn’t billed. Write a retry-after timestamp and move on.
• How do I map Klazify categories to my internal taxonomy? Store a lookup table that maps Klazify’s IAB-based category names to your internal labels. Join by category name in your ETL job before publishing to downstream systems.
• Should I use both the social-profile endpoint and the categorization endpoint? Many teams do. Fetch social URLs from the social endpoint and join them with categories, logo, and company fields from the categorization endpoint to power richer decisions.

Ready to enrich your signups and audits with verified social profiles and complete domain context? Create your free account and start testing today: Register. Explore all parameters and examples in the Documentation, and review service controls via MCP.