Social Profiles API: Get a Company's Social Profiles

You need to enrich a signup, lead, or domain list with verified social media profiles so your CRM, ad ops, or analytics pipeline can resolve where a company is active. By the end of this guide, you’ll call a single endpoint to fetch a company’s Facebook, X, Instagram, YouTube, LinkedIn, GitHub, Pinterest, and Medium profiles, handle nulls for missing accounts, and wire the data into your caching and batching strategy.

Why Klazify is the right API for company social profiles

When you’re vetting a domain, social presence is a high-signal enrichment that drives routing, scoring, and safety checks. Klazify’s stack is built to surface these profiles quickly and consistently from a domain, and it complements that with categorization and company data you can use for downstream decisions.

• Accurate Website Categorization Using AI: Alongside social profiles, Klazify categorizes a company’s site content (IAB mapped) so you can align social signals with content topics for better segmentation or filtering.
• Global Coverage: Domains across multiple languages resolve to the same normalized social profile set, keeping your logic consistent when you’re enriching global leads or auditing placements.
• Real-Time Classification: You get fresh detection rather than relying on stale datasets; this matters when social handles change or are added.
• Industry-Level Categories (IAB): The same call set that powers categorization can help you pair social reach with compliant categories for contextual advertising and brand safety.
• Simple API Integration: A single JSON payload with explicit nulls for missing networks makes result handling predictable inside ingestion jobs and data pipelines.
• Compliance and Filtering: Social profiles can be used to evaluate brand suitability or identity consistency, especially when combined with the site’s IAB categories and company data.

In short, Klazify provides consistent social detection tied to strong content classification. That pairing is useful whether you’re enriching CRM records, routing inbound signups, building discovery features, or auditing publisher inventory.

The endpoint you’ll use: Company Social Profiles

The Social Profiles API resolves major social URLs from a given domain. You send a URL or domain, and you get up to eight networks: Facebook, X, Instagram, YouTube, LinkedIn, GitHub, Pinterest, and Medium. If a profile isn’t found, it’s returned as null so you can write straightforward handling logic.

• Endpoint: POST https://www.klazify.com/api/domain_social_media
• Auth: Bearer token (Authorization: Bearer YOUR_API_KEY)
• Payload: {"url": "https://your-domain-here"}
• Profiles returned: Facebook, X, Instagram, YouTube, LinkedIn, GitHub, Pinterest, Medium (missing profiles are null)

Pricing note: Starter is $39.99/mo with a 7-day trial. Failed or unreachable calls are not billed.

For endpoint and schema details, see the Documentation.

Quick start: cURL request you can copy

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"}'

Replace YOUR_API_KEY with your token. The response will include the eight supported networks; any that don’t exist for the domain will be null. This makes it easy to write null-safe logic.

Python example: Normalize, validate, and cache profiles

This example shows how to call the Social Profiles API, read the eight standard networks, treat nulls as missing, and store a normalized record you can attach to a CRM account or user profile.

import os
import time
import json
import requests

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

SOCIAL_KEYS = [
"facebook",
"x",
"instagram",
"youtube",
"linkedin",
"github",
"pinterest",
"medium",
]

def fetch_social_profiles(domain_url: str) -> dict:
headers = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json",
}
payload = {"url": domain_url}
resp = requests.post(API_URL, headers=headers, data=json.dumps(payload), timeout=20)

# 4xx/5xx handling: you can choose to backoff or mark as retriable
resp.raise_for_status()

data = resp.json()

# Normalize: ensure the eight keys exist, and keep nulls where missing
profiles = {}
for key in SOCIAL_KEYS:
profiles[key] = data.get(key) # missing will be None in Python

# Add a retrieval timestamp (UTC seconds) for caching/TTL
profiles["_fetched_at"] = int(time.time())
profiles["_source"] = "klazify:domain_social_media"
profiles["_domain"] = domain_url

return profiles

def should_refresh(cache_entry: dict, ttl_seconds: int = 7 * 24 * 3600) -> bool:
fetched_at = cache_entry.get("_fetched_at", 0)
return time.time() - fetched_at >= ttl_seconds

# Example usage
if __name__ == "__main__":
domain = "https://example.com"
profiles = fetch_social_profiles(domain)

# Example null-safe usage
linkedin = profiles.get("linkedin")
if linkedin:
print("LinkedIn:", linkedin)
else:
print("No LinkedIn profile found")

# Store in your cache/DB keyed by domain (or eTLD+1)
# db.upsert("social_profiles", key=domain, value=profiles)

# Later, check TTL before refetching
# if should_refresh(profiles): profiles = fetch_social_profiles(domain)

Notes:

• The API returns null for missing profiles; do not treat null as an error.
• A 7–30 day TTL works well for social links unless you require daily freshness.
• Consider normalizing domains to eTLD+1 (e.g., sub.example.co.uk → example.co.uk) for cache keys.

Working with the returned fields

You’ll receive up to eight URLs: facebook, x, instagram, youtube, linkedin, github, pinterest, and medium. Use null checks to avoid inserting empty strings into your CRM or data warehouse. Typical actions include:

• CRM enrichment: Store available handles to drive outreach or scoring. Keep a separate “last_verified_at” timestamp (as shown above) for sync logic.
• Ad tech and brand safety: Validate that a publisher’s declared social presence matches the profiles resolved from their top-level domain.
• Product onboarding: Prefill fields during signup or partner onboarding flows to reduce friction and mis-typed handles.

How categorization complements social profile enrichment

Many pipelines enrich both social presence and content categories. You can pair the Social Profiles endpoint with the categorization endpoint to get IAB categories, logos, company data, and related domain signals. This makes it easier to route accounts, enforce brand safety rules, and automate QA on inventory.

Official categorization JSON (example)

Below is the official example response format you can expect from the classification endpoint. It is useful when you want to combine social profile enrichment with content categories, logo URL extraction, company information, and similar domains for broader data enrichment and decisioning.

{
"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:

• domain.categories: Use name and confidence to map to your taxonomy or to IAB-aligned brand safety policies. The included IAB code sample shows how mappings can be provided.
• domain.social_media: In this sample it’s null; use the dedicated Social Profiles endpoint described above to fetch profiles per domain.
• logo_url: Useful for UI enrichment, CRM account cards, and ad ops dashboards.
• objects.company: Add company attributes (name, location, employeesRange, revenue, tags, tech) to lead or account records for routing and scoring.
• domain_registration_data: Helps segment by domain age or flag extremely new registrations for additional review.
• similar_domains: Expand targeting, deduplicate publishers, or build competitive sets for analysis.

Mapping social profiles into your pipeline

Most teams follow a pattern for ingestion and storage. Here is a simple, robust approach you can reuse:

1. Normalize the input URL to eTLD+1 for consistent cache and dedupe (example: www.brand.co.uk → brand.co.uk).
2. Check your cache. If you have a non-expired entry, use it. If expired or missing, call the Social Profiles endpoint.
3. Store exactly eight keys: facebook, x, instagram, youtube, linkedin, github, pinterest, medium. Missing is null.
4. Persist timestamps: fetched_at and source. This is critical for refresh logic and data lineage.
5. Emit validated handles internally. For example, ensure URLs start with https and domains match expected hosts.
6. Optionally, pair with categorization (via the categorize endpoint) to add IAB categories and company info for routing and safety checks.

Handling unknown or new domains

For newly registered or little-known domains, not all social profiles will exist. Plan for:

• Null-tolerant logic. Do not treat null as an error; it simply means the profile is not detected.
• Backoff and recheck policies. A 30–60 day recheck window is often enough for new domains, with a shorter TTL for active onboarding or partner review flows.
• User-supplied corrections. If a partner provides an explicit handle, you can compare it to the API result and keep both the asserted and verified versions until they converge.

Batching, concurrency, rate limiting, and retries

To enrich at scale:

• Batching: You can call the endpoint per domain concurrently. Group your work in small batches (e.g., 20–100 concurrent requests) to balance throughput and backpressure in your system.
• Rate limits: Respect response headers and any posted limits in the Documentation. If you receive rate-limit responses, implement exponential backoff and jitter.
• Retries: Retry on transient network errors and 5xx responses with capped backoff. Do not retry 4xx client errors unless you fix the request.
• Idempotency: Since the call is a read for enrichment, retries are safe. Use consistent cache keys to avoid duplicate work.

Caching strategy and TTLs

Social profiles do not change frequently, but they can change. Consider:

• Default TTL: 7–30 days depending on how real-time your use case is.
• Event-driven refresh: If a partner updates info or you detect a mismatch in your app, force-refresh.
• Staleness flags: Store fetched_at and mark records older than TTL as stale while continuing to serve them until a refresh succeeds.

Mapping IAB categories to your internal taxonomy

If you also call categorization, map the returned IAB category names to your internal categories via a lookup table. Approach:

• Keep a mapping table keyed by IAB path or name (e.g., /Internet & Telecom/Mobile & Wireless/Mobile Phones) to your internal IDs.
• For multi-label outputs, apply confidence thresholds (e.g., keep categories above a chosen confidence) and store all that pass.
• Log unmapped categories and update your mapping periodically.

For transparency and governance, consider using MCP to manage provenance and policy controls in your stack.

Testing and validation checklist

• Inputs: Test with primary domains, subdomains, and internationalized domains.
• Nulls: Confirm your code safely handles null for any of the eight networks.
• Normalization: Ensure all stored URLs are absolute, HTTPS-formatted where applicable, and deduplicated.
• Latency: Measure end-to-end (request to persisted record). Use concurrency where appropriate to meet SLAs.
• Observability: Log response status, latency, and a hash of the payload for diff-based updates.

Troubleshooting and operational notes

• Unreachable domains: If the site is down or blocked, the call is not billed. You can retry later or mark the record as pending.
• Partial data: Some brands have presence on only two or three networks. That is normal. Keep nulls for others.
• Conflicting handles: If an internal record disagrees with the API, prefer verified URLs from the API and keep the asserted value for comparison until you’ve validated ownership.

How teams use the Social Profiles API

Network	Common Uses	Actions in Pipeline
LinkedIn	Company validation, sales enrichment	Attach to CRM account; score completeness
Facebook	Consumer brand presence	Audience targeting checks; profile link in UI
X	Real-time announcements	Alert routing; monitor verification status
Instagram	Visual product brands	Commerce tagging; brand integrity checks
YouTube	Video content, tutorials	Embed previews; channel QA
GitHub	Developer tools and OSS footprint	Tech affinity; security review of repos
Pinterest	Lifestyle and retail catalogs	Merchandising data; creative QA
Medium	Long-form content	Content syndication matching; SEO eval

Security and compliance considerations

• PII: Social profile URLs for companies are public and non-PII; still, treat enrichment logs with standard access controls.
• Data lineage: Store _source and _fetched_at with each record to enable audits and reprocessing.
• Change management: Use diffing to detect profile changes and trigger downstream updates or reviews.

From prototype to production

• Start with the cURL call to validate connectivity and credentials.
• Implement the Python snippet (or analogous JavaScript) and add error handling, retries, and caching.
• Integrate profile URLs into your CRM, CDP, or data warehouse schema; prefer explicit columns for the eight networks.
• Optionally add a call to the categorize endpoint to store IAB categories, a logo URL, and company attributes for better routing.
• Set up dashboards for call volume, latency, error rates, and cache hit ratio.

FAQ

What happens if a company has no social profiles?
You’ll receive null for the missing networks. Store nulls as-is and set a refresh policy (e.g., 30–60 days) for new or sparse domains.

Can I use this in bulk?
Yes. Run per-domain POSTs concurrently and obey any rate limits documented in the API docs. Use caching to reduce duplicate calls.

Do I get charged for timeouts or unreachable domains?
No. Failed or unreachable calls are not billed. Implement retries with backoff to handle transient issues.

How should I store the results?
Keep a single record per normalized domain with eight columns (facebook, x, instagram, youtube, linkedin, github, pinterest, medium), plus fetched_at and source for lineage.

How do I map categories to my internal taxonomy?
If you also use the categorize endpoint, maintain a lookup from IAB names/paths to your internal IDs, apply a confidence threshold, and log unmapped values for periodic updates.

Ready to enrich your domains with verified social profiles and pair them with strong categorization signals? Create your free account now: Register. For full endpoint details, visit the Documentation and review governance and controls with MCP.