closed-linkedin-api 2.3.2__py3-none-any.whl

closed_linkedin_api-2.3.2.dist-info/METADATA

@@ -0,0 +1,382 @@
+Metadata-Version: 2.4
+Name: closed-linkedin-api
+Version: 2.3.2
+Summary: A Python API to interact with LinkedIn without using official API access.
+License: MIT
+License-File: LICENSE
+Author: J.Antonio Barba
+Author-email: falsigfx@gmail.com
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: beautifulsoup4 (>=4.13.3,<5.0.0)
+Requires-Dist: certifi (>=2025.1.31,<2026.0.0)
+Requires-Dist: charset_normalizer (>=3.4.1,<4.0.0)
+Requires-Dist: idna (>=3.10,<4.0)
+Requires-Dist: lxml (>=5.3.1,<6.0.0)
+Requires-Dist: requests (>=2.32.3,<3.0.0)
+Requires-Dist: urllib3 (>=2.3.0,<3.0.0)
+Project-URL: Repository, https://github.com/omar6995/closed-linkedin-api
+Description-Content-Type: text/markdown
+
+<div align="center">
+
+# LinkedIn API for Python
+
+![Build](https://img.shields.io/github/actions/workflow/status/EseToni/open-linkedin-api/ci.yml?label=Build&logo=github) 
+[![Documentation](https://img.shields.io/readthedocs/open-linkedin-api?label=Docs)](https://github.com/EseToni/open-linkedin-api/tree/main/documentation) 
+[![GitHub Release](https://img.shields.io/github/v/release/EseToni/open-linkedin-api?label=PyPI&logo=python)](https://pypi.org/project/open-linkedin-api/) 
+[![Discord](https://img.shields.io/badge/Discord-5865F2?logo=discord&logoColor=ffffff)](https://discord.gg/yourdiscordlink)
+
+
+Search profiles, send messages, find jobs and more in Python. No official API access required.
+
+<p align="center">
+    <a href="https://github.com/EseToni/open-linkedin-api/tree/main/documentation">Documentation</a>
+    ·
+    <a href="#quick-start">Quick Start</a>
+    ·
+    <a href="#how-it-works">How it works</a>
+</p>
+
+</div>
+
+<br>
+
+## Features
+
+- ✅ No official API access required. Just use a valid LinkedIn user account.
+- ✅ Direct HTTP API interface. No Selenium, Pupeteer, or other browser-based scraping methods.
+- ✅ Get and search people, companies, jobs, posts
+- ✅ Send and retrieve messages
+- ✅ Send and accept connection requests
+- ✅ Get and react to posts
+
+And more! [Read the docs](https://linkedin-api.readthedocs.io/en/latest/api.html) for all API methods.
+
+> [!IMPORTANT]
+> This library is not officially supported by LinkedIn. Using this library might violate LinkedIn's Terms of Service. Use it at your own risk.
+
+## Installation
+
+> [!NOTE]
+> Python >= 3.10 required
+
+###
+
+```bash
+pip install open-linkedin-api
+```
+
+Or, for bleeding edge:
+
+```bash
+pip install git+https://github.com/EseToni/open-linkedin-api
+```
+
+### Quick Start
+
+> [!TIP]
+> See all API methods on the [docs](https://github.com/EseToni/open-linkedin-api/tree/main/documentation).
+
+The following snippet demonstrates a few basic linkedin_api use cases:
+
+```python
+from open_linkedin_api import Linkedin
+
+# Authenticate using any Linkedin user account credentials
+api = Linkedin('reedhoffman@linkedin.com', '*******')
+
+# GET a profile
+profile = api.get_profile('billy-g')
+
+# GET a profiles contact info
+contact_info = api.get_profile_contact_info('billy-g')
+
+# GET 1st degree connections of a given profile
+connections = api.get_profile_connections('1234asc12304')
+```
+
+## Commercial alternatives
+
+> This is a sponsored section
+
+<h3>
+<a href="https://prospeo.io/api/linkedin-email-finder">
+Prospeo
+</a>
+</h3>
+
+Extract data and find verified emails in real-time with [Prospeo LinkedIn Email Finder API](https://prospeo.io/api/linkedin-email-finder).
+
+<details>
+  <summary>Learn more</summary>
+Submit a LinkedIn profile URL to our API and get:
+
+- Profile data extracted in real-time
+- Company data of the profile
+- Verified work email of the profile
+- Exclusive data points (gender, cleaned country code, time zone...)
+- One do-it-all request
+- Stable API, tested under high load
+
+Try it with 75 profiles. [Get your FREE API key now](https://prospeo.io/api/linkedin-email-finder).
+
+</details>
+
+<h3>
+<a href="https://nubela.co/proxycurl/?utm_campaign=influencer%20marketing&utm_source=github&utm_medium=social&utm_term=-&utm_content=tom%20quirk">
+Proxycurl
+</a>
+</h3>
+
+Scrape public LinkedIn profile data at scale with [Proxycurl APIs](https://nubela.co/proxycurl/?utm_campaign=influencer%20marketing&utm_source=github&utm_medium=social&utm_term=-&utm_content=tom%20quirk).
+
+<details>
+  <summary>Learn more</summary>
+  
+- Scraping Public profiles are battle tested in court in HiQ VS LinkedIn case.
+- GDPR, CCPA, SOC2 compliant
+- High rate limit - 300 requests/minute
+- Fast - APIs respond in ~2s
+- Fresh data - 88% of data is scraped real-time, other 12% are not older than 29 days
+- High accuracy
+- Tons of data points returned per profile
+
+Built for developers, by developers.
+
+</details>
+
+<h3>
+<a href="https://www.unipile.com/communication-api/messaging-api/linkedin-api/?utm_campaign=git%20tom%20quirk">
+Unipile
+</a>
+</h3>
+
+Full [LinkedIn API](https://www.unipile.com/communication-api/messaging-api/linkedin-api/?utm_campaign=git%20tom%20quirk): Connect Classic/Sales Navigator/Recruiter, synchronize real-time messaging, enrich data and build outreach sequences…
+
+<details>
+  <summary>Learn more</summary>
+  
+- Easily connect your users in the cloud with our white-label authentication (captcha solving, in-app validation, OTP, 2FA).
+- Real-time webhook for each message received, read status, invitation accepted, and more.
+- Data extraction: get profile, get company, get post, extract search results from Classic + Sales Navigator + Recruiter
+- Outreach sequences: send invitations, InMail, messages, and comment on posts…
+
+Test [all the features](https://www.unipile.com/communication-api/messaging-api/linkedin-api/?utm_campaign=git%20tom%20quirk) with our 7-day free trial.
+
+</details>
+
+<h3>
+<a href="https://bit.ly/4fUyE9J">
+ScrapIn
+</a>
+</h3>
+
+Scrape Any Data from LinkedIn, without limit with [ScrapIn API](https://bit.ly/4fUyE9J).
+
+<details>
+  <summary>Learn more</summary>
+  
+- Real time data (no-cache)
+- Built for SaaS developers
+- GDPR, CCPA, SOC2 compliant
+- Interactive API documentation
+- A highly stable API, backed by over 4 years of experience in data provisioning, with the added reliability of two additional data provider brands owned by the company behind ScrapIn.
+
+Try it for free. [Get your API key now](https://bit.ly/4fUyE9J)
+
+</details>
+
+<h3>
+<a href="https://bit.ly/3AFPGZd">
+iScraper by ProAPIs, Inc.
+</a>
+</h3>
+
+Access high-quality, real-time LinkedIn data at scale with [iScraper API](https://bit.ly/3AFPGZd), offering unlimited scalability and unmatched accuracy.
+
+<details>
+
+<summary>Learn more</summary>
+
+- Real-time LinkedIn data scraping with unmatched accuracy
+- Hosted datasets with powerful Lucene search access
+- Designed for enterprise and corporate-level applications
+- Handles millions of scrapes per day, ensuring unlimited scalability
+- Trusted by top enterprises for mission-critical data needs
+- Interactive API documentation built on OpenAPI 3 specs for seamless integration
+- Backed by over 10 years of experience in real-time data provisioning
+- Lowest price guarantee for high volume use
+
+Get started [here](https://bit.ly/3AFPGZd).
+
+</details>
+
+> End sponsored section
+
+## Development
+
+### Dependencies
+
+- [`poetry`](https://python-poetry.org/docs/)
+- A valid Linkedin user account (don't use your personal account, if possible)
+
+### Development installation
+
+1. Create a `.env` config file (use `.env.example` as a reference)
+2. Install dependencies using `poetry`:
+
+   ```bash
+   poetry install
+   poetry self add poetry-plugin-dotenv
+   ```
+
+### Run tests
+
+Run all tests:
+
+```bash
+poetry run pytest
+```
+
+Run unit tests:
+
+```bash
+poetry run pytest tests/unit
+```
+
+Run E2E tests:
+
+```bash
+poetry run pytest tests/e2e
+```
+
+### Lint
+
+```bash
+poetry run black --check .
+```
+
+Or to fix:
+
+```bash
+poetry run black .
+```
+
+### Troubleshooting
+
+#### I keep getting a `CHALLENGE`
+
+Linkedin will throw you a curve ball in the form of a Challenge URL. We currently don't handle this, and so you're kinda screwed. We think it could be only IP-based (i.e. logging in from different location). Your best chance at resolution is to log out and log back in on your browser.
+
+**Known reasons for Challenge** include:
+
+- 2FA
+- Rate-limit - "It looks like you’re visiting a very high number of pages on LinkedIn.". Note - n=1 experiment where this page was hit after ~900 contiguous requests in a single session (within the hour) (these included random delays between each request), as well as a bunch of testing, so who knows the actual limit.
+
+Please add more as you come across them.
+
+#### Search problems
+
+- Mileage may vary when searching general keywords like "software" using the standard `search` method. They've recently added some smarts around search whereby they group results by people, company, jobs etc. if the query is general enough. Try to use an entity-specific search method (i.e. search_people) where possible.
+
+## How it works
+
+This project attempts to provide a simple Python interface for the LinkedIn API.
+
+> Do you mean the [legit LinkedIn API](https://developer.linkedin.com/)?
+
+NO! To retrieve structured data, the [LinkedIn Website](https://linkedin.com) uses a service they call **Voyager**. Voyager endpoints give us access to pretty much everything we could want from LinkedIn: profiles, companies, connections, messages, etc. - anything that you can see on linkedin.com, we can get from Voyager.
+
+This project aims to provide complete coverage for Voyager.
+
+[How does it work?](#deep-dive)
+
+### Deep dive
+
+Voyager endpoints look like this:
+
+```text
+https://www.linkedin.com/voyager/api/identity/profileView/tom-quirk
+```
+
+Or, more clearly
+
+```text
+ ___________________________________ _______________________________
+|             base path             |            resource           |
+https://www.linkedin.com/voyager/api /identity/profileView/tom-quirk
+```
+
+They are authenticated with a simple cookie, which we send with every request, along with a bunch of headers.
+
+To get a cookie, we POST a given username and password (of a valid LinkedIn user account) to `https://www.linkedin.com/uas/authenticate`.
+
+### Find new endpoints
+
+We're looking at the LinkedIn website and we spot some data we want. What now?
+
+The following describes the most reliable method to find relevant endpoints:
+
+1. `view source`
+1. `command-f`/search the page for some keyword in the data. This will exist inside of a `<code>` tag.
+1. Scroll down to the **next adjacent element** which will be another `<code>` tag, probably with an `id` that looks something like
+
+   ```html
+   <code style="display: none" id="datalet-bpr-guid-3900675">
+   	{"request":"/voyager/api/identity/profiles/tom-quirk/profileView","status":200,"body":"bpr-guid-3900675"}
+   </code>
+   ```
+
+The value of `request` is the url! 🤘
+
+You can also use the `network` tab in you browsers developer tools, but you will encounter mixed results.
+
+### How Clients query Voyager
+
+linkedin.com uses the [Rest-li Protocol](https://linkedin.github.io/rest.li/spec/protocol) for querying data. Rest-li is an internal query language/syntax where clients (like linkedin.com) specify what data they want. It's conceptually similar to the GraphQL.
+
+Here's an example of making a request for an organisation's `name` and `groups` (the Linkedin groups it manages):
+
+```text
+/voyager/api/organization/companies?decoration=(name,groups*~(entityUrn,largeLogo,groupName,memberCount,websiteUrl,url))&q=universalName&universalName=linkedin
+```
+
+The "querying" happens in the `decoration` parameter, which looks like the following:
+
+```text
+(
+    name,
+    groups*~(entityUrn,largeLogo,groupName,memberCount,websiteUrl,url)
+)
+```
+
+Here, we request an organisation name and a list of groups, where for each group we want `largeLogo`, `groupName`, and so on.
+
+Different endpoints use different parameters (and perhaps even different syntaxes) to specify these queries. Notice that the above query had a parameter `q` whose value was `universalName`; the query was then specified with the `decoration` parameter.
+
+In contrast, the `/search/cluster` endpoint uses `q=guided`, and specifies its query with the `guided` parameter, whose value is something like
+
+```text
+List(v->PEOPLE)
+```
+
+It could be possible to document (and implement a nice interface for) this query language - as we add more endpoints to this project, I'm sure it will become more clear if such a thing would be possible (and if it's worth it).
+
+### Release a new version
+
+1. Bump `version` in `pyproject.toml`
+1. `poetry build`
+1. `poetry publish`
+1. Draft release notes in GitHub.
+
+## Disclaimer
+
+This library is not endorsed or supported by LinkedIn. It is an unofficial library intended for educational purposes and personal use only. By using this library, you agree to not hold the author or contributors responsible for any consequences resulting from its usage.
+

closed_linkedin_api-2.3.2.dist-info/RECORD

@@ -0,0 +1,14 @@
+open_linkedin_api/__init__.py,sha256=6uon3-l0pUnCsmMxBZ8Qm2qGmN_vIWjUPDjXkZQZNX4,710
+open_linkedin_api/client.py,sha256=QBaGb9qP58ohnhkDr7o_1HaFPQ-iUrC6b95NLDEUpZU,7024
+open_linkedin_api/cookie_auth.py,sha256=0FbUIEEFru05ygTyfdCmRpTlwqTJezXaFlH1ylbcl9c,8045
+open_linkedin_api/cookie_repository.py,sha256=AGDKt-U1GrItyIbDerDJuCfWxaP5TBv5Qe8-KoY8iiY,2078
+open_linkedin_api/graphql.py,sha256=YxB6FZVlyWoe0080V1aUJwCfT3b5_sH9uLGfUahfMTQ,8342
+open_linkedin_api/linkedin.py,sha256=fdaDAhK4n5TrkYoOByrZu2kMJRvLUeSEsIePteEWL8k,49553
+open_linkedin_api/parsers.py,sha256=Jkj09mLPSD8gEzVBRRtLT6wO784uBOYUufwR2zWpU0Q,26480
+open_linkedin_api/settings.py,sha256=YvzKRqArH2tGW8Ip0Z85mWU4KHCGoxrGgy8oEyx7rls,245
+open_linkedin_api/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+open_linkedin_api/utils/helpers.py,sha256=mdjZGCFZ4EcqSSHcNHcEIXoXbki5yA_eRY5CB4SMUog,7891
+closed_linkedin_api-2.3.2.dist-info/METADATA,sha256=UtomZI712bSMO0sdT2gaGyInBGpaw26NYA8F6au0p8g,13088
+closed_linkedin_api-2.3.2.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
+closed_linkedin_api-2.3.2.dist-info/licenses/LICENSE,sha256=exG1ZBMsxjPvP-3dIBvORTsYoLTGQ7Owo46JnNvxDSI,1086
+closed_linkedin_api-2.3.2.dist-info/RECORD,,

closed_linkedin_api-2.3.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.3.0
+Root-Is-Purelib: true
+Tag: py3-none-any

closed_linkedin_api-2.3.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jose Antonio Barba Rodríguez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

open_linkedin_api/__init__.py

@@ -0,0 +1,31 @@
+"""
+    linkedin-api
+"""
+
+from .linkedin import Linkedin
+from .graphql import QueryRegistry, GraphQLQuery, QueryType, GraphQLClient
+from .parsers import (
+    NormalizedJsonParser,
+    ProfileParser,
+    MessagingParser,
+    FeedParser,
+)
+from .client import Client, ChallengeException, UnauthorizedException
+from .cookie_auth import CookieAuthenticator, CookieAuthenticationError
+
+__all__ = [
+    "Linkedin",
+    "Client",
+    "ChallengeException",
+    "UnauthorizedException",
+    "QueryRegistry",
+    "GraphQLQuery",
+    "QueryType",
+    "GraphQLClient",
+    "NormalizedJsonParser",
+    "ProfileParser",
+    "MessagingParser",
+    "FeedParser",
+    "CookieAuthenticator",
+    "CookieAuthenticationError",
+]

open_linkedin_api/client.py

@@ -0,0 +1,207 @@
+import requests
+import logging
+from typing import Any, Dict, Optional
+from open_linkedin_api.cookie_repository import CookieRepository
+from open_linkedin_api.graphql import GraphQLClient, GraphQLQuery, QueryRegistry
+from bs4 import BeautifulSoup, Tag
+from requests.cookies import RequestsCookieJar
+import json
+
+logger = logging.getLogger(__name__)
+
+
+class ChallengeException(Exception):
+    pass
+
+
+class UnauthorizedException(Exception):
+    pass
+
+
+class Client(object):
+    """
+    Class to act as a client for the Linkedin API.
+    """
+
+    # Settings for general Linkedin API calls
+    LINKEDIN_BASE_URL = "https://www.linkedin.com"
+    API_BASE_URL = f"{LINKEDIN_BASE_URL}/voyager/api"
+    REQUEST_HEADERS = {
+        "user-agent": " ".join(
+            [
+                "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_5)",
+                "AppleWebKit/537.36 (KHTML, like Gecko)",
+                "Chrome/83.0.4103.116 Safari/537.36",
+            ]
+        ),
+        # "accept": "application/vnd.linkedin.normalized+json+2.1",
+        "accept-language": "en-AU,en-GB;q=0.9,en-US;q=0.8,en;q=0.7",
+        "x-li-lang": "en_US",
+        "x-restli-protocol-version": "2.0.0",
+        # "x-li-track": '{"clientVersion":"1.2.6216","osName":"web","timezoneOffset":10,"deviceFormFactor":"DESKTOP","mpName":"voyager-web"}',
+    }
+
+    # Settings for authenticating with Linkedin
+    AUTH_REQUEST_HEADERS = {
+        "X-Li-User-Agent": "LIAuthLibrary:0.0.3 com.linkedin.android:4.1.881 Asus_ASUS_Z01QD:android_9",
+        "User-Agent": "ANDROID OS",
+        "X-User-Language": "en",
+        "X-User-Locale": "en_US",
+        "Accept-Language": "en-us",
+    }
+
+    def __init__(
+        self, *, debug=False, refresh_cookies=False, proxies={}, cookies_dir: str = ""
+    ):
+        self.session = requests.session()
+        self.session.proxies.update(proxies)
+        self.session.headers.update(Client.REQUEST_HEADERS)
+        self.proxies = proxies
+        self.logger = logger
+        self.metadata = {}
+        self._use_cookie_cache = not refresh_cookies
+        self._cookie_repository = CookieRepository(cookies_dir=cookies_dir)
+
+        logging.basicConfig(level=logging.DEBUG if debug else logging.INFO)
+
+    def _request_session_cookies(self):
+        """
+        Return a new set of session cookies as given by Linkedin.
+        """
+        self.logger.debug("Requesting new cookies.")
+
+        res = requests.get(
+            f"{Client.LINKEDIN_BASE_URL}/uas/authenticate",
+            headers=Client.AUTH_REQUEST_HEADERS,
+            proxies=self.proxies,
+        )
+        return res.cookies
+
+    def _set_session_cookies(self, cookies: RequestsCookieJar):
+        """
+        Set cookies of the current session and save them to a file named as the username.
+        """
+        self.session.cookies = cookies
+        self.session.headers["csrf-token"] = self.session.cookies["JSESSIONID"].strip(
+            '"'
+        )
+
+    @property
+    def cookies(self):
+        return self.session.cookies
+
+    def authenticate(self, username: str, password: str):
+        if self._use_cookie_cache:
+            self.logger.debug("Attempting to use cached cookies")
+            cookies = self._cookie_repository.get(username)
+            if cookies:
+                self.logger.debug("Using cached cookies")
+                self._set_session_cookies(cookies)
+                self._fetch_metadata()
+                return
+
+        self._do_authentication_request(username, password)
+        self._fetch_metadata()
+
+    def _fetch_metadata(self):
+        """
+        Get metadata about the "instance" of the LinkedIn application for the signed in user.
+
+        Store this data in self.metadata
+        """
+        res = requests.get(
+            f"{Client.LINKEDIN_BASE_URL}",
+            cookies=self.session.cookies,
+            headers=Client.AUTH_REQUEST_HEADERS,
+            proxies=self.proxies,
+        )
+
+        soup = BeautifulSoup(res.text, "lxml")
+
+        clientApplicationInstanceRaw = soup.find(
+            "meta", attrs={"name": "applicationInstance"}
+        )
+        if clientApplicationInstanceRaw and isinstance(
+            clientApplicationInstanceRaw, Tag
+        ):
+            content = clientApplicationInstanceRaw.attrs.get("content")
+            if content and isinstance(content, str):
+                clientApplicationInstance = json.loads(content)
+                self.metadata["clientApplicationInstance"] = clientApplicationInstance
+
+        clientPageInstanceIdRaw = soup.find(
+            "meta", attrs={"name": "clientPageInstanceId"}
+        )
+        if clientPageInstanceIdRaw and isinstance(clientPageInstanceIdRaw, Tag):
+            clientPageInstanceId = clientPageInstanceIdRaw.attrs.get("content", {})
+            self.metadata["clientPageInstanceId"] = clientPageInstanceId
+
+    def _do_authentication_request(self, username: str, password: str):
+        """
+        Authenticate with Linkedin.
+
+        Return a session object that is authenticated.
+        """
+        self._set_session_cookies(self._request_session_cookies())
+
+        payload = {
+            "session_key": username,
+            "session_password": password,
+            "JSESSIONID": self.session.cookies["JSESSIONID"],
+        }
+
+        res = requests.post(
+            f"{Client.LINKEDIN_BASE_URL}/uas/authenticate",
+            data=payload,
+            cookies=self.session.cookies,
+            headers=Client.AUTH_REQUEST_HEADERS,
+            proxies=self.proxies,
+        )
+
+        data = res.json()
+
+        if data and data["login_result"] != "PASS":
+            raise ChallengeException(data["login_result"])
+
+        if res.status_code == 401:
+            raise UnauthorizedException()
+
+        if res.status_code != 200:
+            raise Exception()
+
+        self._set_session_cookies(res.cookies)
+        self._cookie_repository.save(res.cookies, username)
+
+    def get_graphql_client(self) -> GraphQLClient:
+        """
+        Get a GraphQL client configured with the current session.
+        
+        :return: GraphQL client instance
+        :rtype: GraphQLClient
+        """
+        return GraphQLClient(self.session, Client.API_BASE_URL)
+
+    def graphql_request(
+        self,
+        query: GraphQLQuery,
+        variables: Optional[Dict[str, Any]] = None,
+        include_web_metadata: bool = False,
+        headers: Optional[Dict[str, str]] = None
+    ) -> Dict[str, Any]:
+        """
+        Execute a GraphQL request using the current session.
+        
+        :param query: The GraphQL query to execute
+        :param variables: Variables to pass to the query
+        :param include_web_metadata: Whether to include web metadata
+        :param headers: Additional headers to include in the request
+        :return: JSON response from the API
+        """
+        client = self.get_graphql_client()
+        return client.execute(
+            query=query,
+            variables=variables,
+            include_web_metadata=include_web_metadata,
+            headers=headers
+        )
+