extract linkedin handle from url using structured parsing

Table of Contents
- Understanding URL Structures for LinkedIn Profiles
- Standard URL Patterns for LinkedIn Resources
- Breakdown of URL Components for Identifier Extraction
- Comparison of LinkedIn URL Structures Across Platforms
- Methods to Extract LinkedIn Handles from URLs
- Programmatic Extraction Using Python
- Normalize URL: lowercase, remove trailing slashes, query, and fragments
- Non-Programmatic Techniques for Handle Extraction
- Comparison of Client-Side vs. Server-Side Extraction
- Unified Workflow for LinkedIn URL Variations
- Handling Edge Cases in URL Extraction for LinkedIn Handles
- Categorization of Edge Cases in LinkedIn URLs
- Regex Patterns for Edge Case Extraction
- Sanitization and Normalization of Extracted Handles
- Flowchart for URL Fragment Classification
- Filtering Non-Profile URLs and False Positives
- Integrating LinkedIn Handle Extraction into Applications
- Steps to Integrate Extraction into Web Scrapers
- REST API Endpoint Template for Handle Extraction
- Caching Extracted Handles for Performance
- Structured API Response Example for Successful Extraction
- Error Handling and Logging for Extraction Failures
LinkedIn URLs serve as digital identifiers for profiles, companies, and posts, yet extracting the core handle from these links often presents technical challenges due to regional variations, obfuscated redirects, and inconsistent URL structures. Without precise parsing, automated systems risk misinterpreting handles or failing to process malformed links, leading to inefficiencies in web scraping, API integrations, or data validation pipelines. This guide dissects the anatomy of LinkedIn URLs—from domain segmentation to query parameters—while providing actionable methods to programmatically isolate handles, validate edge cases, and integrate extraction logic into applications. Whether optimizing a scraper or designing a REST endpoint, understanding these patterns ensures reliable handle retrieval across LinkedIn’s evolving infrastructure.
The process begins with a breakdown of LinkedIn’s URL taxonomy, where subtle differences between desktop, mobile, and API endpoints can disrupt extraction workflows. For instance, a profile URL on desktop may follow the pattern `linkedin.com/in/username`, while a mobile redirect might append a language code or legacy ID, complicating direct parsing. Additionally, shortened links or third-party redirects obscure the original handle, necessitating robust validation techniques. By combining regex patterns, string manipulation, and client-server trade-off analysis, developers can build resilient systems capable of handling these variations while maintaining accuracy. The discussion further extends to edge cases—such as URL-encoded characters, subdomains, or non-handle fragments—where misclassification can lead to false positives or missed opportunities in data processing.

Understanding URL Structures for LinkedIn Profiles
LinkedIn employs standardized yet regionally and contextually variable URL structures to identify profiles, company pages, posts, and other entities. These URLs serve as unique digital identifiers, enabling direct access to content while adhering to platform-specific conventions. The structure varies based on the type of resource (profile, company, post) and the access method (desktop, mobile, API). Understanding these patterns is critical for parsing, validation, and automation tasks, such as extracting handles from URLs or redirecting users to correct endpoints.The core of LinkedIn’s URL architecture relies on a combination of domain segments, path segments, and query parameters. Each component contributes to the uniqueness of the identifier, whether it is a username, company name slug, or post ID. Variations arise due to regional domains (e.g., `.com`, `.in`, `.ca`), obfuscation techniques (e.g., shortened links, redirect chains), and platform-specific optimizations (e.g., mobile vs. desktop). Below is a breakdown of the structural components and their roles in identifying LinkedIn resources.
Standard URL Patterns for LinkedIn Resources
LinkedIn URLs follow a hierarchical structure where the domain, path segments, and query parameters collectively define the target resource. The primary categories include public profiles, company pages, posts, articles, and API endpoints. Each category adheres to distinct conventions, though inconsistencies exist across regions and access methods.Domain Structure
The domain is the foundational element of a LinkedIn URL, often prefixed with the platform’s base domain (`linkedin.com`) and suffixed with a regional top-level domain (TLD) or subdomain. Common variations include:
Path Segments
Path segments follow the domain and are categorized based on the resource type. Examples include:
Query Parameters
Query parameters are appended after the path and are used to modify the request or include additional metadata. Common parameters include:
Example URLs by Resource Type
| Resource Type | Standard URL Pattern | Example URL |
|---|---|---|
| Public Profile | `https://www.linkedin.com/in/{username}` | `https://www.linkedin.com/in/johndoe` |
| Company Page | `https://www.linkedin.com/company/{slug}` | `https://www.linkedin.com/company/google` |
| Post (Feed Update) | `https://www.linkedin.com/feed/update/{id}` | `https://www.linkedin.com/feed/update/12345` |
| Article (Pulse) | `https://www.linkedin.com/pulse/article/{id}` | `https://www.linkedin.com/pulse/article/67890` |
| Group | `https://www.linkedin.com/g/{slug}` | `https://www.linkedin.com/g/tech-leaders` |
| API Endpoint | `https://api.linkedin.com/v2/{endpoint}` | `https://api.linkedin.com/v2/people/~` |
Breakdown of URL Components for Identifier Extraction
To extract the core identifier (e.g., username, company name, post ID) from a LinkedIn URL, it is essential to dissect the URL into its constituent components. Below is a detailed analysis of each segment and its role in forming the unique identifier.1. Domain and Subdomain Analysis
The domain and subdomain provide contextual information about the URL’s origin and intended audience. For parsing purposes, the primary focus is on the base domain (`linkedin.com`) and regional variations, as these do not directly contribute to the identifier but influence routing and accessibility.
2. Path Segments and Their Roles
Path segments are the most critical for identifier extraction. Each segment corresponds to a specific resource type and contains the unique slug or ID. Common patterns include:
3. Query Parameters and Their Impact
Query parameters are less critical for identifier extraction but may include metadata or tracking information. For example:
4. Obfuscated or Shortened URLs
LinkedIn URLs may appear in malformed or obfuscated formats due to:
Example of Malformed/Obfuscated URLs
| Type | Example URL | Core Identifier Extraction Challenge |
|---|---|---|
| Shortened Link | `https://li.sh/1A2B3C` | Requires resolving the short URL to the original. |
| Redirect Chain | `https://www.linkedin.com/redirect?url=https%3A%2F%2Fwww.linkedin.com%2Fin%2Fjohndoe` | The actual identifier (`johndoe`) is embedded in the encoded `url` parameter. |
| Mobile Web | `https://m.linkedin.com/in/johndoe` | Same identifier as desktop, but domain varies. |
| API Response Redirect | `https://www.linkedin.com/oauth/v2/authorization?response_type=code&...` | Not a direct profile link; requires OAuth handling. |
Comparison of LinkedIn URL Structures Across Platforms
LinkedIn URLs exhibit inconsistencies when accessed via desktop, mobile web, or API endpoints. Below is a comparative table highlighting structural differences, missing fields, or platform-specific optimizations.| Feature | Desktop Web | Mobile Web (`m.linkedin.com`) | API Endpoints (`api.linkedin.com`) |
|---|---|---|---|
| Base Domain | `www.linkedin.com` | `m.linkedin.com` | `api.linkedin.com` |
| Profile Path | `/in/{username}` | `/in/{username}` | `/v2/people/~` (self) or `/v2/people/{id}` |
| Company Path | `/company/{slug}` | `/company/{slug}` | `/v2/companies/{id}` |
| Post Path | `/feed/update/{id}` | `/feed/update/{id}` | `/v2/ugcPosts/{id}` |
| Query Parameters | Often includes `trk=...` | May include mobile-specific params | Uses `oauth` and `access_token` |
| Redirect Handling | Standard redirects to canonical URL | May use `m.` subdomain redirects | No redirects; returns JSON or error |
| Identifier Format | Username, slug, or numeric ID | Same as desktop | Numeric ID or `profile |
Methods to Extract LinkedIn Handles from URLs
LinkedIn URLs encode user, company, or post identifiers in structured paths, enabling programmatic extraction of handles for automation, analytics, or integration tasks. Efficient extraction requires handling URL variations, edge cases (e.g., trailing slashes, missing segments), and cross-platform compatibility. Below are systematic approaches—both programmatic and non-programmatic—to isolate LinkedIn handles from raw URLs, along with comparisons of client-side vs. server-side methods and unified extraction logic for diverse LinkedIn URL formats.Programmatic Extraction Using Python
Python offers robust libraries for parsing and validating LinkedIn URLs, with `re` (regular expressions) and `urllib.parse` as primary tools. The extraction process involves:1. URL Normalization: Standardizing the URL (e.g., removing trailing slashes, converting to lowercase).
2. Pattern Matching: Using regex to identify LinkedIn-specific segments (e.g., `/in/`, `/company/`, `/feed/`).
3. Handle Isolation: Extracting the username, company name, or post identifier based on the URL structure.
4. Edge-Case Handling: Validating incomplete or malformed URLs (e.g., missing slashes, non-LinkedIn domains).
Key Libraries and Functions:
Example Code Snippet for Validation and Extraction:
import re
from urllib.parse import urlparse
def extract_linkedin_handle(url):
Normalize URL: lowercase, remove trailing slashes, query, and fragments
normalized_url = re.sub(r'(https?://)?(www\.)?linkedin\.com(/+)?', '', url.lower()).rstrip('/')# Regex to match LinkedIn profile/company/feed URLs and extract handle
pattern = re.compile(
r'^((?:in|company|feed)/([^/]+))|(?:company/([^/]+))|(?:feed/update/urn:.+?/([^/]+))$'
)
match = pattern.match(normalized_url)
if not match:
return None # Not a valid LinkedIn handle URL
# Prioritize matches (profile > company > feed)
handle = match.group(2) or match.group(3) or match.group(4)
return handle if handle else None
Edge Cases Addressed:
Non-Programmatic Techniques for Handle Extraction
Non-programmatic methods rely on manual inspection, browser tools, or third-party utilities to isolate handles without code. These are useful for one-off tasks or environments where scripting is restricted.Browser-Based Methods:
Regex Testers and Validators:
linkedin\.com/(?:in|company|feed)/([^/]+)
- URL Validators: Services like URL Inspect validate LinkedIn URLs and extract handles via API or manual input.
Limitations:
Comparison of Client-Side vs. Server-Side Extraction
The choice between client-side (JavaScript) and server-side (Node.js/PHP) extraction depends on performance, security, and use case.| Criteria | Client-Side (JavaScript) | Server-Side (Node.js/PHP) |
|---|---|---|
| Performance | Slower due to browser execution overhead. | Faster; leverages server resources for batch processing. |
| Security | Vulnerable to XSS if user input isn’t sanitized. | More secure; runs in isolated environments. |
| Use Case | Real-time extraction (e.g., form validation). | Bulk processing (e.g., scraping, analytics). |
| Dependencies | Requires DOM/API access (e.g., `window.location`). | No browser dependency; uses `url` or `parse_url` libraries. |
| Accuracy | May fail with ad-blockers or dynamic URLs. | Consistent; handles edge cases uniformly. |
| Implementation Complexity | Simpler for frontend tasks. | Requires backend setup (e.g., API endpoints). |
Example JavaScript Snippet (Client-Side):
function extractLinkedInHandle(url) {
const normalized = url.replace(/https?:\/\/www\.(linkedin\.com\/)?/, '').replace(/\/$/, '');
const match = normalized.match(/^(in|company)\/([^/]+)/);
return match ? match[2] : null;
}
Unified Workflow for LinkedIn URL Variations
LinkedIn URLs vary by entity type (profile, company, post) and include legacy or dynamic formats. A unified extraction workflow standardizes handling across these variations.URL Categories and Patterns:
1. Profile URLs:Structured Extraction Logic:
Format: `linkedin.com/in/username` Handle: `username` Regex: `linkedin\.com/in/([^/]+)` 2. Company URLs:
Format: `linkedin.com/company/company-name` Handle: `company-name` (URL-encoded) Regex: `linkedin\.com/company/([^/]+)` 3. Feed/Post URLs:
Format: `linkedin.com/feed/update/urn:li:activity:673...` Handle: Post ID or author handle (requires additional API calls). Regex: `linkedin\.com/feed/update/urn:.+?/([^/]+)` 4. Legacy/Redirect URLs:
Format: `linkedin.com/pub/username` (deprecated) Handle: `username` (requires redirect check).
1. Normalize Input: Convert to lowercase, remove protocol (`http://`), and trailing slashes.
2. Categorize URL: Use regex to classify the URL type (profile/company/feed).
3. Extract Handle:
5. Handle Redirects: For legacy URLs, follow redirects (e.g., `pub/` → `in/`) using `requests` (Python) or `fetch` (JavaScript).
Example Workflow Table:
| URL Type | Pattern | Handle Extraction | Edge Case Handling |
|---|---|---|---|
| Profile | `/in/([^/]+)` | Group 1 (`username`) | Decode URL-encoded handles (e.g., `%20`). |
| Company | `/company/([^/]+)` | Group 1 (`company-name`) | Normalize hyphens/spaces. |
| Feed | `/feed/update/urn:.+?/([^/]+)` | Group 1 (post ID) or API call for author. | Fallback to `None` if no handle found. |
| Redirect | `/pub/([^/]+)` → `/in/([^/]+)` | Follow redirect; extract `in |

Handling Edge Cases in URL Extraction for LinkedIn Handles
LinkedIn URLs exhibit variability due to regional configurations, legacy systems, and dynamic routing, which can complicate the extraction of handles. Edge cases—such as subdomains, language-specific paths, or URL-encoded characters—require systematic handling to ensure robustness. This section categorizes these scenarios, designs regex patterns for extraction, and outlines validation steps to filter invalid or non-profile URLs. Sanitization techniques and decision flowcharts further refine the process, ensuring extracted handles adhere to LinkedIn’s syntactic rules.Categorization of Edge Cases in LinkedIn URLs
LinkedIn URLs may include structural variations that deviate from standard profile formats. These edge cases fall into five primary categories:- Regional and Language-Specific Paths
LinkedIn routes users to language-specific or region-locked URLs, often incorporating country codes (e.g., `es.linkedin.com` for Spanish) or language prefixes (e.g., `/in/fr/` for French). These paths must be accounted for to avoid misclassifying handles.
- Legacy and Deprecated ID Formats
Older LinkedIn profiles used numeric or hybrid IDs (e.g., `/in/12345678/` or `/pub/1/12345678`). While modern profiles rely on alphanumeric handles, legacy formats persist in historical data or redirects.
- URL-Encoded Characters and Special Symbols
Handles may contain encoded characters (e.g., `%20` for spaces, `%2F` for slashes) or Unicode symbols (e.g., `é`, `ñ`). These require decoding and normalization to derive a clean handle.
- Dynamic and Non-Profile Paths
URLs like `/feed/`, `/article/`, or `/jobs/` do not contain handles but may include fragments resembling them. Distinguishing these from valid profiles is critical to prevent false positives.
- Subdomains and Third-Party Integrations
Subdomains such as `blog.linkedin.com` or `learning.linkedin.com` host non-profile content. Additionally, URLs from embedded content (e.g., `linkedin.com/embed/`) must be excluded.
Regex Patterns for Edge Case Extraction
Regex patterns must account for the categorized edge cases while ensuring specificity. Below are refined patterns for extraction, categorized by URL structure:1. Standard Profile Handles (Global)
(?:https?:\/\/)?(?:www\.)?linkedin\.com\/(?:in|pub)\/([a-zA-Z0-9\-_]+)
- Matches: `/in/johndoe`, `/pub/jane_doe123`
2. Language/Region-Specific Handles
(?:https?:\/\/)?(?:[a-z]{2,3}\.)?linkedin\.com\/(?:in|pub)\/([a-zA-Z0-9\-_]+)
- Matches: `es.linkedin.com/in/johndoe`, `linkedin.com/in/fr/jane_doe`
3. Legacy Numeric or Hybrid IDs
(?:https?:\/\/)?linkedin\.com\/(?:in|pub)\/([0-9]{8,}|[a-zA-Z0-9\-_]+)
- Matches: `/in/12345678`, `/pub/abc123-def456`
4. URL-Encoded Handles
(?:https?:\/\/)?linkedin\.com\/(?:in|pub)\/([a-zA-Z0-9\-_%]+)
- Matches: `/in/john%20doe`, `/pub/jane%2Fdoe`
5. Subdomains and Non-Profile Paths
(?:https?:\/\/)?(?:[a-z]+\.)?linkedin\.com\/(?!in\/|pub\/).+
- Matches: `blog.linkedin.com/post/123`, `learning.linkedin.com/course/abc`
Sanitization and Normalization of Extracted Handles
Extracted handles may contain inconsistencies requiring preprocessing. The following steps ensure uniformity:1. URL Decoding
import urllib.parse
handle = urllib.parse.unquote(handle)
2. Lowercase Conversion
3. Special Character Handling
4. Unicode Normalization
import unicodedata
handle = unicodedata.normalize('NFKD', handle).encode('ascii', 'ignore').decode()
5. Length and Format Validation
Flowchart for URL Fragment Classification
Determine whether a URL fragment contains a handle or requires further parsing using the following decision logic:START
│
├─ Check if URL contains `/in/` or `/pub/` → Extract handle (Proceed to Sanitization)
│
├─ Check for language/region prefixes (e.g., `/fr/`, `/es/`) →
│ │
│ ├─ If followed by `/in/` or `/pub/`, extract handle
│ │
│ └─ Else, reject as non-profile
│
├─ Check for numeric IDs (e.g., `/in/12345678`) →
│ │
│ ├─ If legacy, map to handle via API or reject
│ │
│ └─ Else, reject
│
├─ Check for URL-encoded characters → Decode and re-evaluate
│
├─ Check for subdomains (e.g., `blog.`, `learning.`) → Reject
│
├─ Check for dynamic paths (`/feed/`, `/article/`) →
│ │
│ ├─ If handle exists in path (e.g., `/feed/update/ur/12345678/`), extract
│ │
│ └─ Else, reject
│
└─ Default: Reject as non-profile URL
Visualization Notes:
Filtering Non-Profile URLs and False Positives
Some URLs may superficially resemble profile links but lack handles. Examples include:- Login and Authentication Pages
- Search Results and Directories
- Company Pages and Groups
- Embedded Content and Redirects
Validation Checklist for Extracted Handles
Ensure handles meet LinkedIn’s documented criteria before processing:
| Check | Criteria | Action if Failed |
|---|---|---|
| Length | 3–30 characters | Reject |
| Character Set |
Integrating LinkedIn Handle Extraction into Applications
LinkedIn handle extraction from URLs requires seamless integration into applications while ensuring robustness against rate limits, dynamic content, and API restrictions. This section outlines practical implementation strategies for web scrapers, REST APIs, and caching mechanisms, along with structured error handling and logging to maintain reliability.Steps to Integrate Extraction into Web Scrapers
Web scrapers like Scrapy or Puppeteer can automate LinkedIn handle extraction but must account for anti-scraping measures. Below are structured steps to implement extraction with error resilience:Preparation Phase
Scrapers must first validate URL structures and handle LinkedIn’s dynamic rendering (e.g., JavaScript-heavy profiles). Preprocessing includes:
Extraction Logic
For Scrapy (Python) or Puppeteer (Node.js), the extraction pipeline involves:
1. Fetching the Page: Use `requests` (Scrapy) or `puppeteer.launch()` (Puppeteer) with headers mimicking a browser.
2. Dynamic Content Handling: For Puppeteer, wait for `document.readyState === 'complete'` or target specific selectors (e.g., `.profile-top-card__name`).
3. Handle Extraction: Parse the DOM for the handle using regex or CSS selectors. Example (Scrapy):
handle = response.css('a.profile-url::attr(href)').get().split('/')[-1]
4. Error Handling: Catch exceptions for:
Example Scrapy Spider Snippet
import scrapy
from scrapy.http import Request
from urllib.parse import urlparse
class LinkedInSpider(scrapy.Spider):
name = 'linkedin_extractor'
def start_requests(self):
urls = ['https://www.linkedin.com/in/valid-handle']
for url in urls:
yield Request(url, callback=self.parse_profile, meta={'retry_times': 0})
def parse_profile(self, response):
if response.status == 429:
self.logger.warning(f"Rate-limited. Retrying in 5s...")
return
handle = response.css('a.profile-url::attr(href)').get()
if not handle:
self.logger.error(f"No handle found in {response.url}")
return
yield {'handle': handle.split('/')[-1], 'url': response.url}
REST API Endpoint Template for Handle Extraction
A REST API endpoint should accept URLs, process them, and return structured JSON with metadata. Below is a template using Flask (Python) or Express (Node.js), including validation and response formatting.API Design Principles
Flask Endpoint Example
from flask import Flask, request, jsonify
import re
from urllib.parse import urlparse
app = Flask(__name__)
def extract_handle(url):
try:
parsed = urlparse(url)
if parsed.netloc != 'www.linkedin.com' and parsed.netloc != 'linkedin.com':
return None
path_parts = parsed.path.strip('/').split('/')
if len(path_parts) >= 2 and path_parts[0] == 'in':
return {'handle': path_parts[1], 'profile_type': 'personal'}
return None
except Exception as e:
return None
@app.route('/extract', methods=['POST'])
def extract():
data = request.json
url = data.get('url')
if not url or not re.match(r'^https?://(www\.)?linkedin\.com', url):
return jsonify({'error': 'Invalid LinkedIn URL'}), 400
result = extract_handle(url)
if not result:
return jsonify({'error': 'Handle extraction failed'}), 404
return jsonify({
'handle': result['handle'],
'profile_type': result['profile_type'],
'url_status': 'valid',
'timestamp': datetime.utcnow().isoformat()
})
if __name__ == '__main__':
app.run()
Key Fields in API Response
{
"handle": "johndoe",
"profile_type": "personal",
"url_status": "valid",
"confidence_score": 0.98,
"timestamp": "2023-11-15T12:00:00Z"
}
Caching Extracted Handles for Performance
Caching reduces redundant processing and API calls. Below are database schemas for Redis (in-memory) and PostgreSQL (persistent storage), along with cache invalidation strategies.Redis Schema (Key-Value Store)
{
"handle": "johndoe",
"profile_type": "personal",
"last_updated": "2023-11-15T12:00:00Z",
"ttl": 86400 // Cache for 24 hours
}
- Commands:
SET linkedin:handle:sha256(url) "{\"handle\":\"johndoe\",...}" EX 86400
GET linkedin:handle:sha256(url)
PostgreSQL Schema (Relational)
CREATE TABLE linkedin_handles (
id SERIAL PRIMARY KEY,
url_hash VARCHAR(64) UNIQUE NOT NULL,
handle VARCHAR(50) NOT NULL,
profile_type VARCHAR(20) NOT NULL,
last_updated TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
is_active BOOLEAN DEFAULT TRUE
);
CREATE INDEX idx_url_hash ON linkedin_handles(url_hash);
Cache Invalidation Rules
Structured API Response Example for Successful Extraction
A well-structured response includes metadata for debugging and downstream processing. Below is an example with all critical fields:{
"status": "success",
"data": {
"handle": "alexandermarketing",
"profile_type": "personal",
"url_status": "valid",
"confidence_score": 0.99,
"metadata": {
"full_name": "Alex Mark",
"profile_url": "https://www.linkedin.com/in/alexandermarketing",
"last_scraped": "2023-11-15T12:00:00Z",
"source": "web_scraper"
}
},
"timestamp": "2023-11-15T12:00:01Z"
}
Error Handling and Logging for Extraction Failures
Errors in extraction (e.g., invalid URLs, blocked requests) must be logged with standardized codes for debugging. Below is a table of error codes and their meanings, followed by a logging implementation example.Error Code Reference Table
| Code | Description | Example Trigger |
|---|---|---|
| 400 | Invalid URL format | `https://linkedin.com/in/` (missing handle) |
| 403 | Access forbidden (private profile) | Blocked by LinkedIn’s bot detection |
| 404 | Handle not found | `https://linkedin.com/in/nonexistent123` |
| 429 | Rate limit exceeded | Too many requests in short time |
| 500 | Internal server error | Scraper crash or API failure |
| 503 | Service unavailable | LinkedIn maintenance |
import logging
from datetime import datetime
logging.basicConfig(filename='extraction_errors.log', level=logging.ERROR)
def
Mastering LinkedIn URL extraction transforms raw web addresses into actionable data, unlocking applications from profile verification to social media analytics. By implementing the structured workflows outlined—ranging from regex-based parsing to API-integrated validation—developers can future-proof their systems against LinkedIn’s evolving URL conventions. The key lies in balancing precision with adaptability: whether sanitizing handles for consistency, caching results to optimize performance, or logging failures for iterative improvement, each step reinforces the reliability of automated processes. As digital identities on LinkedIn continue to grow in complexity, the ability to extract and validate handles programmatically will remain a cornerstone of efficient data handling, bridging the gap between technical implementation and real-world utility.
Leave a Comment
Comments are moderated before appearing. The data you submit is processed according to the Privacy Policy of www.linuxunplugged.com.