LinkedIn client: OAuth, profile and posts

Exchanges the callback code for an access token at /oauth/v2/accessToken (form-urlencoded) and returns a TokenBundle.

await li.exchange_code(code: str, *, redirect_uri: str) -> socialift.models.TokenBundle

• ▸LinkedIn rule: the code is valid for 30 minutes, and redirect_uri must match the authorization request.
• ▸Access tokens last 60 days; refresh_token is only returned if programmatic refresh is enabled for your app.
• ▸Raises ApiError if the response has no access_token.

Creates a client from the LINKEDIN_CLIENT_ID, LINKEDIN_CLIENT_SECRET and LINKEDIN_API_VERSION environment variables so keys stay out of code.

LinkedIn.from_env(**kwargs) -> LinkedIn

• ▸Empty values are not validated by the constructor: a missing client_id surfaces as ConfigurationError in login_url.
• ▸Without LINKEDIN_API_VERSION the SDK default version is used — check that it is still active at LinkedIn.

Builds the LinkedIn authorization URL (/oauth/v2/authorization) to send the member to; it sends no request. Scopes are space-separated, defaulting to openid, profile, email, w_member_social.

li.login_url(
    *,
    redirect_uri: str,
    state: Optional[str] = None,
    scopes: Optional[list[str]] = None,
) -> str

• ▸Raises ConfigurationError without client_id.
• ▸state is CSRF protection: reject the callback if it does not match what you sent (LinkedIn recommendation). The SDK does not store it.
• ▸LinkedIn rule: members cannot pick individual scopes, and requesting a scope different from the one previously granted invalidates all previous access tokens.
• ▸redirect_uri must match one of the redirect URLs on the app's Auth tab.

url = li.login_url(redirect_uri="https://siz.uz/cb", state=state)

Checks a token at /oauth/v2/introspectToken and returns LinkedIn's response as a dict: active, status, expires_at, scope, auth_type and more. Use it to see whether a token still works and when it expires.

await li.introspect(token: str) -> dict

• ▸status is active, expired or revoked; scope is only returned for 3-legged OAuth tokens.
• ▸LinkedIn rule: with valid credentials but a token from another app, the response is 200 with active: false — nothing is raised.

info = await li.introspect(token)

Gets a new access token with a refresh token (grant_type=refresh_token) and returns a TokenBundle, so members do not have to sign in again when a token expires.

await li.refresh(refresh_token: str) -> socialift.models.TokenBundle

• ▸LinkedIn issues programmatic refresh tokens only to approved Marketing Developer Platform partners; otherwise the member must authorize again.
• ▸Refresh tokens last 365 days and refreshing does not extend that; the new access token lasts 60 days.
• ▸Raises ApiError if the response has no access_token.

bundle = await li.refresh(refresh_token)

Returns the member's profile from OpenID Connect userinfo (/v2/userinfo) as a Profile: id (= sub), name, picture and email. You need sub to build the post author URN.

await li.me(token: str) -> socialift.models.Profile

• ▸Needs the openid and profile scopes, plus email for the address; per LinkedIn, email is optional and may be missing.
• ▸Profile.username is the email, or sub when absent; Profile.raw includes an extra language derived from the locale.

Required permissions:openidprofileemail

me = await li.me(token)

Turns sub into urn:li:person:{sub} — the author value for posts and create_post. A static method that sends no request.

LinkedIn.person_urn(sub: str) -> str

• ▸create_post and posts wrap any value not starting with urn: this way automatically.

Required permissions:r_member_socialw_member_social

posts = await li.posts(token, author=li.person_urn(sub), count=10)

post = await li.create_post(token, author=li.person_urn(sub), text="Yangiliklar!",
                             article_url="https://siz.uz/blog")

Creates a text post (optionally with a link) on the member's behalf via the Posts API and returns {id, body}; id is the post URN from the x-restli-id header. visibility is PUBLIC or CONNECTIONS.

await li.create_post(
    token: str,
    *,
    author: str,
    text: str,
    visibility: str = 'PUBLIC',
    article_url: Optional[str] = None,
    article_title: Optional[str] = None,
) -> dict

• ▸Requires w_member_social (Share on LinkedIn product).
• ▸For a link the SDK sets content.article with source and title (defaulting to the URL). The Posts API does not scrape URLs, so no thumbnail or description is generated.
• ▸Any other visibility raises ConfigurationError.
• ▸No image, video or document upload in this method.

Required permissions:w_member_social

post = await li.create_post(token, author=li.person_urn(sub), text="Yangiliklar!",
                             article_url="https://siz.uz/blog")

Deletes a post by URN (urn:li:share:... or urn:li:ugcPost:...) and returns {deleted: True, urn}. The URN is fully encoded in the request path.

await li.delete_post(token: str, post_urn: str) -> dict

• ▸LinkedIn rule: deletes are idempotent — an already deleted post also returns 204; batch delete is not supported.
• ▸Requires w_member_social; this cannot be undone.

Required permissions:w_member_social

await li.delete_post(token, post_urn)

Lists an author's posts with the Posts API q=author finder and returns LinkedIn's response (elements, paging). Paginate with start and count.

await li.posts(token: str, *, author: str, start: int = 0, count: int = 10) -> dict

• ▸Member posts require r_member_social, which LinkedIn restricts to approved users; on 403 the SDK raises a PermissionError with an explanation.
• ▸LinkedIn rule: count defaults to 10 with a maximum of 100; results are sorted by last-modified time, newest first.
• ▸A page can hold fewer than count items even when more posts exist — use paging.links to find the next page.

Required permissions:r_member_social

posts = await li.posts(token, author=li.person_urn(sub), count=10)

Sends an arbitrary HTTP request and returns the JSON response — for endpoints the SDK doesn't wrap with a dedicated method yet. You pass the token and signing parameters yourself in params or headers (access_token, and for Meta appsecret_proof via socialift.crypto.appsecret_proof).

await li.request(
    method: str,
    url: str,
    *,
    params: Optional[Mapping[str, Any]] = None,
    data: Optional[Any] = None,
    json: Optional[Any] = None,
    headers: Optional[Mapping[str, str]] = None,
) -> Any

• ▸None values in params are not sent.
• ▸Rate limits (RateLimitError) and transient server errors (HTTP 429, 500, 502, 503, 504) are retried according to RetryPolicy; a Retry-After header is honoured. Network failures are raised as TransportError.

Shorthand for request("GET", ...).

await li.get(url: str, **kw) -> Any

Shorthand for request("POST", ...).

await li.post(url: str, **kw) -> Any

Shorthand for request("DELETE", ...).

await li.delete(url: str, **kw) -> Any

Follows Meta's cursor pagination (paging.next) and returns every data item as a single list.

await li.paginate(
    url: str,
    *,
    params: Optional[Mapping[str, Any]] = None,
    max_items: int = 500,
    page_size: int = 100,
) -> list[dict]

• ▸max_items (default 500) is a safety cap — a large account can have tens of thousands of records. page_size sets the limit of each request.

Closes the HTTP session the SDK created itself (a session you passed in is left open). Called automatically when you use async with Client(...).

await li.close() -> None