LinkedIn Boolean operators in action The original results for our "content marketer" search query Over 22 million results Down to 6 million results 228,000 detailed results What are Boolean operators?

Operator	Function	Example Usage
AND	Results must include all specified terms	"developer AND manager"
OR	Results may include any of the specified terms	"sales OR marketing"
NOT	Excludes results containing the specified term (Google uses "-" for NOT)	"engineer NOT civil"

Quick heads up How to use search operators on LinkedIn

Operator	Function	Example
" "	Search for an exact phrase	"product manager"
( )	Group terms in complex queries	(senior OR junior) AND engineer
first:	Search by first name	first:John
last:	Search by last name	last:Doe

"AND" operators

Results returned on LinkedIn for our search query The prospect fits our Javascript requirementThe prospect also fits our Linux requirement

"NOT" operators

Kotlin listed as a skill on their LinkedIn profile Results displayed after filtering profiles with Kotlin as a skill

Filtering with location and putting everything together

Results displayed with multiple filtering operators Searching on LinkedIn vs. Google Google's search operators

Operator	Function	Example
" "	Searches for an exact phrase	"climate change"
-	As mentioned above, Google uses "-" for NOT	jaguar -car
site:	Limits the search to a specific website or domain	site:nytimes.com
related:	Finds websites similar to a specified site	related:time.com
filetype:	Searches for a specific file type	filetype:pdf "renewable energy"
intitle:	Finds pages with a specific term in the title	intitle:conservation
inurl:	Searches for a specific term within the URL	inurl:nutrition
intext:	Searches for a specific term within the text of a page	intext:"global warming"
*	Acts as a wildcard	world * champion
AROUND(X)	Finds terms that are within a certain number of words apart	solar AROUND(3) energy
cache:	Shows the most recent cached version of a web page	cache:google.com

How to do LinkedIn X-ray searches

LinkedIn X-ray searches by job role

LinkedIn X-ray search results returned for "full stack developer"An example profile returned for "full stack developer"

LinkedIn X-ray searches by job role and skill

LinkedIn X-ray with job role and skill filtering applied Fits our search criteria

Excluding skills, roles, or anything from your LinkedIn X-ray search

Results returned with an excluding operator All of those skills, and not one is PHP

Location-based filtering with LinkedIn X-ray searches

Results returned with location filtering A New York City full-stack programmer without any skill in PHPResults returned with ultra-specific location filteringA full-stack developer in Frankfurt Extracting your LinkedIn X-ray search results What Value Serp's homepage looks like Value Serp's API Value Serp's process of exporting to .CSV Our brand new .CSV How to enrich LinkedIn profiles Proxycurl's Person Profile Endpoint Using Proxycurl's API for enrichment

import requests

api_key = 'Your_API_Key_Here'
headers = {'Authorization': 'Bearer ' + api_key}
api_endpoint = 'https://nubela.co/proxycurl/api/v2/linkedin'
params = {
    'linkedin_profile_url': 'https://www.linkedin.com/in/russellbrunson/',
    'extra': 'include',
    'github_profile_id': 'include',
    'facebook_profile_id': 'include',
    'twitter_profile_id': 'include',
    'personal_contact_number': 'include',
    'personal_email': 'include',
    'inferred_salary': 'include',
    'skills': 'include',
    'use_cache': 'if-present',
    'fallback_to_cache': 'on-error',
}
try:
    response = requests.get(api_endpoint, params=params, headers=headers)
    response.raise_for_status()  # Raise an exception for HTTP errors (e.g., 404, 500)
    
    # Print the response content and status code
    print("Response Content:")
    print(response.text)
    print("\nResponse Status Code:", response.status_code)
except requests.exceptions.RequestException as e:
    print("An error occurred during the HTTP request:", e)
except Exception as ex:
    print("An unexpected error occurred:", ex)

An enriched LinkedIn profile

"public_identifier": "russellbrunson", "profile_pic_url": "normal_url.com", "background_cover_image_url": null, "first_name": "Russell", "last_name": "Brunson", "full_name": "Russell Brunson", "follower_count": 81644, "occupation": "Owner at ClickFunnels", "headline": "New York Times Bestselling Author, Co-Founder of ClickFunnels", "summary": "Over the past 14 years, Russell has built a following of over 2 million entrepreneurs, sold over 450,000 copies of his books, popularized the concept of sales funnels, and co-founded ClickFunnels, a software company that helps 90,000 entrepreneurs quickly get their message out to the marketplace. \n\nRussell has been featured on major publications and websites such as Forbes, Entrepreneur Magazine, and The Huffington Post. He is also the host of the #1 rated business podcast, Marketing Secrets. In 2018, he was awarded \u2018Entrepreneur of the Year\u2019 in the Utah region by ey.com. Russell also regularly works with non-profits like Operation Underground Railroad and Village Impact.", "country": "US", "country_full_name": "United States of America", "city": null, "state": null, "experiences"...(continues on with more data)...

How to easily enrich LinkedIn profiles at scale

import json
import requests
import csv

# Your API key
API_KEY = 'Your_API_Key_Here'

# API endpoint for Person Profile
api_endpoint = 'https://nubela.co/proxycurl/api/v2/linkedin'

# Headers for the API request
headers = {'Authorization': 'Bearer ' + API_KEY}

# Input and output CSV file names
input_file = 'input_linkedin_profiles.csv'
output_file = 'enriched_data.csv'

# Function to extract experiences as a string
def extract_experiences(profile):
    experiences = profile.get('experiences', [])
    return '; '.join([f"{exp.get('title', '')} at {exp.get('company', '')}" for exp in experiences])

# Read LinkedIn profile URLs from the input CSV file
with open(input_file, 'r') as csvfile:
    reader = csv.reader(csvfile)
    linkedin_urls = [row[0] for row in reader]

# Open the output CSV file for writing
with open(output_file, 'w', newline='') as csvfile:
    fieldnames = [
        'linkedin_url', 'full_name', 'profile_picture', 'current_occupation',
        'country', 'city', 'state', 'experiences', 'skills', 'personal_emails', 'inferred_salary'
    ]
    writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
    writer.writeheader()

    # Loop through each LinkedIn profile URL
    for linkedin_url in linkedin_urls:
        params = {
            'linkedin_profile_url': linkedin_url,
            'extra': 'include',
            'github_profile_id': 'include',
            'facebook_profile_id': 'include',
            'twitter_profile_id': 'include',
            'personal_contact_number': 'include',
            'personal_email': 'include',
            'inferred_salary': 'include',
            'skills': 'include',
            'use_cache': 'if-recent',
            'fallback_to_cache': 'on-error',
        }

        response = requests.get(api_endpoint, params=params, headers=headers)
        if response.status_code == 200:
            profile = response.json()

            # Extracting skills and experiences
            skills = ", ".join(profile.get('skills', []))
            experiences_str = extract_experiences(profile)

            writer.writerow({
                'linkedin_url': linkedin_url,
                'full_name': profile.get('full_name', ''),
                'profile_picture': profile.get('profile_pic_url', ''),
                'current_occupation': profile.get('occupation', ''),
                'country': profile.get('country_full_name', ''),
                'city': profile.get('city', ''),
                'state': profile.get('state', ''),
                'experiences': experiences_str,
                'skills': skills,
                'personal_emails': "; ".join(profile.get('personal_emails', [])),
                'inferred_salary': profile.get('inferred_salary', {}).get('min', '')  # Example of handling nested data
            })
        else:
            print(f"Failed to fetch data for {linkedin_url}, Status Code: {response.status_code}")

print(f"Data exported to {output_file}")

Example of the data returned into the new .CSV Proxycurl's Person Search Endpoint

Searching based on job role and company

import json, requests

headers = {'Authorization': 'Bearer ' + 'Your_API_Key_Here'}
api_endpoint = 'https://nubela.co/proxycurl/api/search/person/'
params = {
    'country': 'US',
    'current_role_title': '(?i)Project Manager',
    'current_company_linkedin_profile_url': 'https://www.linkedin.com/company/microsoft',
    'page_size': '10',
    'enrich_profiles': 'enrich',
}
try:
    response = requests.get(api_endpoint, params=params, headers=headers)
    response.raise_for_status()  # Raise an exception for HTTP errors (e.g., 404, 500)
    
    # Print the response content and status code
    print("Response Content:")
    print(response.text)
    print("\nResponse Status Code:", response.status_code)
except requests.exceptions.RequestException as e:
    print("An error occurred during the HTTP request:", e)
except Exception as ex:
    print("An unexpected error occurred:", ex)

Microsoft project manager

Extracting all search results

import requests

api_key = 'Your_API_Key_Here'
headers = {'Authorization': 'Bearer ' + api_key}
api_endpoint = 'https://nubela.co/proxycurl/api/search/person/'
params = {
    'country': 'US',
    'current_role_title': '(?i)Project Manager',
    'current_company_linkedin_profile_url': 'https://www.linkedin.com/company/microsoft',
    'page_size': '10',
    'enrich_profiles': 'enrich',
}
def fetch_page(url, params):
    response = requests.get(url, params=params, headers=headers)
    if response.status_code == 200:
        return response.json()
    else:
        print("Error:", response.status_code, response.text)
        return None

# Fetch the initial page
response_data = fetch_page(api_endpoint, params)

# Loop through pages
while response_data and response_data.get('next_page'):
    # Process the results here
    for result in response_data['results']:
        print(result)  # or any other processing

    # Fetch the next page
    next_page_url = response_data['next_page']
    if 'country' not in next_page_url:
        next_page_url += '&country=US'  # Append 'country' parameter
    response_data = fetch_page(next_page_url, {})

# End of pagination
print("Completed fetching all pages.")

Exporting search results to a .CSV

import requests
import csv
from urllib.parse import urlparse, parse_qs, urlencode, urlunparse

# API credentials and endpoint configuration
api_key = 'Your_API_Key_Here'
headers = {'Authorization': 'Bearer ' + api_key}
api_endpoint = 'https://nubela.co/proxycurl/api/search/person/'

# Parameters for the initial request
initial_params = {
    'country': 'US',
    'current_role_title': '(?i)Project Manager',
    'current_company_linkedin_profile_url': 'https://www.linkedin.com/company/microsoft',
    'page_size': '10',
    'enrich_profiles': 'enrich',
}

# Define the output CSV file and headers
output_file = 'enriched_profiles.csv'
fieldnames = [
    'linkedin_profile_url', 'full_name', 'profile_picture', 'background_cover_image_url',
    'current_occupation', 'location'
]

def fetch_profiles(url, headers, params=None):
    """Fetch profiles from the given URL with specified parameters."""
    response = requests.get(url, headers=headers, params=params)
    if response.status_code == 200:
        return response.json()
    else:
        print(f"Error: {response.status_code}, {response.text}")
        return None

def add_country_to_url(url, country):
    """Add the 'country' parameter to the given URL."""
    parsed_url = urlparse(url)
    query_params = parse_qs(parsed_url.query, keep_blank_values=True)
    query_params['country'] = [country]  # Ensure 'country' parameter is included
    new_query = urlencode(query_params, doseq=True)
    new_url = urlunparse(parsed_url._replace(query=new_query))
    return new_url

def process_profile_data(profile):
    """Process and return the profile data in a dict format."""
    return {
        'linkedin_profile_url': profile.get('linkedin_profile_url', ''),
        'full_name': profile.get('profile', {}).get('full_name', ''),
        'profile_picture': profile.get('profile', {}).get('profile_pic_url', ''),
        'background_cover_image_url': profile.get('profile', {}).get('background_cover_image_url', ''),
        'current_occupation': profile.get('profile', {}).get('occupation', ''),
        'location': f"{profile.get('profile', {}).get('city', '')}, {profile.get('profile', {}).get('country_full_name', '')}"
    }

# Open the output CSV file for writing
with open(output_file, mode='w', newline='') as file:
    writer = csv.DictWriter(file, fieldnames=fieldnames)
    writer.writeheader()

    # Fetch the initial page of profiles
    profiles_data = fetch_profiles(api_endpoint, headers, initial_params)

    if profiles_data and 'results' in profiles_data:
        # Iterate through each profile and write to CSV
        for profile in profiles_data['results']:
            profile_data = process_profile_data(profile)
            writer.writerow(profile_data)

        # Handle pagination
        while 'next_page' in profiles_data:
            next_page_url = add_country_to_url(profiles_data['next_page'], initial_params['country'])
            profiles_data = fetch_profiles(next_page_url, headers)

            if profiles_data and 'results' in profiles_data:
                for profile in profiles_data['results']:
                    profile_data = process_profile_data(profile)
                    writer.writerow(profile_data)
            else:
                break

print("Completed fetching and storing all profile data.")

.CSV file exported, all Microsoft project managers

Exporting phone numbers and emails with our Search API

import requests
import csv
from urllib.parse import urlparse, parse_qs, urlencode, urlunparse

# API credentials and endpoint configuration
api_key = 'Your_API_Key_Here'  # Replace with your actual API key
headers = {'Authorization': 'Bearer ' + api_key}
search_api_endpoint = 'https://nubela.co/proxycurl/api/search/person/'
contact_phone_endpoint = 'https://nubela.co/proxycurl/api/contact-api/personal-contact'
contact_email_endpoint = 'https://nubela.co/proxycurl/api/contact-api/personal-email'

# Parameters for the initial search request
search_params = {
    'country': 'US',
    'current_role_title': '(?i)Project Manager',
    'current_company_linkedin_profile_url': 'https://www.linkedin.com/company/microsoft',
    'page_size': '10',
    'enrich_profiles': 'enrich',
}

# Define the output CSV file and headers
output_file = 'enriched_profiles_with_contacts.csv'
fieldnames = [
    'linkedin_profile_url', 'full_name', 'profile_picture', 'background_cover_image_url',
    'current_occupation', 'location', 'personal_phone_number', 'personal_email'
]


def fetch_contact_info(api_endpoint, linkedin_profile_url):
    """Fetch personal contact info (phone number or email)."""
    params = {'linkedin_profile_url': linkedin_profile_url}
    response = requests.get(api_endpoint, headers=headers, params=params)
    if response.status_code == 200:
        data = response.json()
        if api_endpoint.endswith('personal-contact'):
            return ', '.join(data.get('numbers', []))  # Join all numbers into a single string
        elif api_endpoint.endswith('personal-email'):
            return ', '.join(data.get('emails', []))  # Join all emails into a single string
    else:
        print(f"Error fetching contact info from {api_endpoint}: {response.status_code}, {response.text}")
    return ''  # Return empty string if no data or in case of error


def add_country_to_url(url, country):
    """Add the 'country' parameter to the given URL."""
    parsed_url = urlparse(url)
    query_params = parse_qs(parsed_url.query, keep_blank_values=True)
    query_params['country'] = [country]
    new_query = urlencode(query_params, doseq=True)
    new_url = urlunparse(parsed_url._replace(query=new_query))
    return new_url


def process_and_write_profiles(writer):
    """Fetch profiles and write their details, including contact info, to the CSV file."""
    url = search_api_endpoint
    params = search_params.copy()

    while url:
        response = requests.get(url, headers=headers, params=params)
        if response.status_code != 200:
            print(f"Error fetching profiles: {response.status_code}, {response.text}")
            break

        data = response.json()
        for profile in data.get('results', []):
            # Fetch contact information
            email_info = fetch_contact_info(contact_email_endpoint, profile['linkedin_profile_url'])
            phone_info = fetch_contact_info(contact_phone_endpoint, profile['linkedin_profile_url'])

            # Write profile and contact information to CSV
            writer.writerow({
                'linkedin_profile_url': profile['linkedin_profile_url'],
                'full_name': profile['profile']['full_name'],
                'profile_picture': profile['profile']['profile_pic_url'],
                'background_cover_image_url': profile['profile']['background_cover_image_url'],
                'current_occupation': profile['profile']['occupation'],
                'location': f"{profile['profile']['city']}, {profile['profile']['country_full_name']}",
                'personal_phone_number': phone_info,
                'personal_email': email_info,
            })

        # Prepare for the next page
        next_page_url = data.get('next_page')
        if next_page_url:
            url = add_country_to_url(next_page_url, search_params['country'])
            params = {}  # Since all needed params are in the URL, clear params to avoid duplication
        else:
            break


# Open the output CSV file for writing and process profiles
with open(output_file, mode='w', newline='') as file:
    writer = csv.DictWriter(file, fieldnames=fieldnames)
    writer.writeheader()
    process_and_write_profiles(writer)

print("Completed fetching and storing all profile data with contact information.")

Our new .CSV that includes contact information By the way, if you're entirely uninterested in coding... Same power, but all of the convenience in the world Additional tips You now have three options

1. You can take your newly gained knowledge and do nothing with it.
2. You can take your newly gained knowledge about LinkedIn X-ray searches and implement it.
3. You can take your newly gained knowledge about LinkedIn X-ray searches and our B2B enrichment APIs and fully utilize it to your advantage.

Create your Proxycurl account today Conclusion