getanyapi 0.81.0__tar.gz → 0.82.0__tar.gz

{getanyapi-0.81.0 → getanyapi-0.82.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: getanyapi
-Version: 0.81.0
+Version: 0.82.0
 Summary: Official typed Python SDK for AnyAPI: any API, one wallet, USD, no subscriptions.
 Project-URL: Homepage, https://getanyapi.com
 Project-URL: Documentation, https://getanyapi.com/docs

{getanyapi-0.81.0 → getanyapi-0.82.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "getanyapi"
-version = "0.81.0"
+version = "0.82.0"
 description = "Official typed Python SDK for AnyAPI: any API, one wallet, USD, no subscriptions."
 readme = "README.md"
 requires-python = ">=3.10"

{getanyapi-0.81.0 → getanyapi-0.82.0}/src/getanyapi/__init__.py

@@ -55,7 +55,7 @@ from .types import (
     unwrap,
 )
 
-__version__ = "0.81.0"
+__version__ = "0.82.0"
 
 __all__ = [
     # clients + top-level functions

{getanyapi-0.81.0 → getanyapi-0.82.0}/src/getanyapi/platforms/linkedin.py

@@ -562,6 +562,178 @@ class LinkedinSearchCompaniesInput(TypedDict, total=False):
     """Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this endpoint is rejected as invalid input with no charge; a listed source that is not serving right now is refused with no charge, so omit `source` to be served by another. On a paginated walk, later pages must include the source that served page one, or omit `source`."""
 
 
+class LinkedinSearchLeadsInput(TypedDict, total=False):
+    """Input for LinkedIn Fast Leads List."""
+
+    allowFallbacks: NotRequired[bool]
+    """Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. Default: true."""
+    companyHeadcount: NotRequired[
+        list[Literal["A", "B", "C", "D", "E", "F", "G", "H", "I"]]
+    ]
+    """Filter by current company size (employee count). Codes: A=Self-Employed, B=1-10, C=11-50, D=51-200, E=201-500, F=501-1,000, G=1,001-5,000, H=5,001-10,000, I=10,001+."""
+    companyHeadquarterLocations: NotRequired[list[str]]
+    """Filter by the location of the person's current company headquarters, by place name (e.g. ['United States']). Commas are not allowed in a value. Up to 70 values."""
+    currentCompanies: NotRequired[list[str]]
+    """Filter to people who currently work at any of these companies, by name (e.g. ['Google','Meta']). Multiple names widen the match (OR). Commas are not allowed in a value. Up to 50 values."""
+    excludeCompanyHeadquarterLocations: NotRequired[list[str]]
+    """Exclude people whose current company is headquartered in any of these locations. Commas are not allowed in a value. Up to 70 values."""
+    excludeCurrentCompanies: NotRequired[list[str]]
+    """Exclude people who currently work at any of these companies, by name. Commas are not allowed in a value. Up to 50 values."""
+    excludeCurrentJobTitles: NotRequired[list[str]]
+    """Exclude people whose current job title matches any of these. Commas are not allowed in a value. Up to 70 values."""
+    excludeFunctionIds: NotRequired[
+        list[
+            Literal[
+                "1",
+                "2",
+                "3",
+                "4",
+                "5",
+                "6",
+                "7",
+                "8",
+                "9",
+                "10",
+                "11",
+                "12",
+                "13",
+                "14",
+                "15",
+                "16",
+                "17",
+                "18",
+                "19",
+                "20",
+                "21",
+                "22",
+                "23",
+                "24",
+                "25",
+                "26",
+            ]
+        ]
+    ]
+    """Exclude these job functions (same codes as functionIds). Up to 30 values."""
+    excludeLocations: NotRequired[list[str]]
+    """Exclude people in any of these locations, by place name. Commas are not allowed in a value. Up to 70 values."""
+    excludePastCompanies: NotRequired[list[str]]
+    """Exclude people who previously worked at any of these companies, by name. Commas are not allowed in a value. Up to 50 values."""
+    excludePastJobTitles: NotRequired[list[str]]
+    """Exclude people who held any of these past job titles. Commas are not allowed in a value. Up to 70 values."""
+    excludeSchools: NotRequired[list[str]]
+    """Exclude people who attended any of these schools, by name. Commas are not allowed in a value. Up to 50 values."""
+    excludeSeniorityLevelIds: NotRequired[
+        list[
+            Literal[
+                "100", "110", "120", "130", "200", "210", "220", "300", "310", "320"
+            ]
+        ]
+    ]
+    """Exclude these seniority levels (same codes as seniorityLevelIds). Up to 20 values."""
+    firstNames: NotRequired[list[str]]
+    """Filter to people whose first name matches any of these. Commas are not allowed in a value. Up to 70 values."""
+    functionIds: NotRequired[
+        list[
+            Literal[
+                "1",
+                "2",
+                "3",
+                "4",
+                "5",
+                "6",
+                "7",
+                "8",
+                "9",
+                "10",
+                "11",
+                "12",
+                "13",
+                "14",
+                "15",
+                "16",
+                "17",
+                "18",
+                "19",
+                "20",
+                "21",
+                "22",
+                "23",
+                "24",
+                "25",
+                "26",
+            ]
+        ]
+    ]
+    """Filter by job function. Codes: 1=Accounting, 2=Administrative, 3=Arts and Design, 4=Business Development, 5=Community and Social Services, 6=Consulting, 7=Education, 8=Engineering, 9=Entrepreneurship, 10=Finance, 11=Healthcare Services, 12=Human Resources, 13=Information Technology, 14=Legal, 15=Marketing, 16=Media and Communication, 17=Military and Protective Services, 18=Operations, 19=Product Management, 20=Program and Project Management, 21=Purchasing, 22=Quality Assurance, 23=Real Estate, 24=Research, 25=Sales, 26=Customer Success and Support."""
+    ignoreSources: NotRequired[list[str]]
+    """Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way."""
+    jobTitle: NotRequired[str]
+    """Optional current job title filter (e.g. 'Software Engineer'). Commas are not allowed in a value."""
+    lastNames: NotRequired[list[str]]
+    """Filter to people whose last name matches any of these. Commas are not allowed in a value. Up to 70 values."""
+    location: NotRequired[str]
+    """Optional location filter (e.g. 'San Francisco'). Commas are not allowed in a value."""
+    page: NotRequired[int]
+    """Which page of up to 25 leads to return, starting at 1 (1-100, default 1). Each page is billed as one request. Range: 1 to 100. Default: 1."""
+    pastCompanies: NotRequired[list[str]]
+    """Filter to people who previously worked at any of these companies, by name. Commas are not allowed in a value. Up to 50 values."""
+    pastJobTitles: NotRequired[list[str]]
+    """Filter by a past job title the person held (e.g. ['Product Manager']). Commas are not allowed in a value. Up to 70 values."""
+    preferLatencyUnderMs: NotRequired[int]
+    """Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the best speed for its price - it is never refused for being slow. Sources we have not timed are tried last. This is a preference, not a guarantee: the median describes past requests and is not a ceiling on this one, and it excludes any wait this request itself asks for. On a paginated walk it applies to the first page only: later pages stay with the source that page chose, at the price it was quoted. Minimum: 1."""
+    profileLanguages: NotRequired[
+        list[
+            Literal[
+                "Arabic",
+                "English",
+                "Spanish",
+                "Portuguese",
+                "Chinese",
+                "French",
+                "Italian",
+                "Russian",
+                "German",
+                "Dutch",
+                "Turkish",
+                "Tagalog",
+                "Polish",
+                "Korean",
+                "Japanese",
+                "Malay",
+                "Norwegian",
+                "Danish",
+                "Romanian",
+                "Swedish",
+                "Bahasa Indonesia",
+                "Czech",
+            ]
+        ]
+    ]
+    """Filter by the profile's primary language."""
+    query: Required[str]
+    """Search query for LinkedIn profiles: a role, name, or keywords (e.g. 'Marketing Manager')."""
+    recentlyChangedJobs: NotRequired[bool]
+    """When true, only return people who recently changed jobs (a strong sales/recruiting signal)."""
+    recentlyPostedOnLinkedIn: NotRequired[bool]
+    """When true, only return people who recently posted on LinkedIn (an activity signal)."""
+    schools: NotRequired[list[str]]
+    """Filter to people who attended any of these schools, by name. Commas are not allowed in a value. Up to 50 values."""
+    seniorityLevelIds: NotRequired[
+        list[
+            Literal[
+                "100", "110", "120", "130", "200", "210", "220", "300", "310", "320"
+            ]
+        ]
+    ]
+    """Filter by seniority level. Codes: 100=In Training, 110=Entry Level, 120=Senior, 130=Strategic, 200=Entry Level Manager, 210=Experienced Manager, 220=Director, 300=Vice President, 310=CXO, 320=Owner/Partner."""
+    source: NotRequired[list[str]]
+    """Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this endpoint is rejected as invalid input with no charge; a listed source that is not serving right now is refused with no charge, so omit `source` to be served by another. On a paginated walk, later pages must include the source that served page one, or omit `source`."""
+    yearsAtCurrentCompanyIds: NotRequired[list[Literal["1", "2", "3", "4", "5"]]]
+    """Filter by tenure at the current company. Codes: 1=Less than 1 year, 2=1 to 2 years, 3=3 to 5 years, 4=6 to 10 years, 5=More than 10 years."""
+    yearsOfExperienceIds: NotRequired[list[Literal["1", "2", "3", "4", "5"]]]
+    """Filter by total years of experience. Codes: 1=Less than 1 year, 2=1 to 2 years, 3=3 to 5 years, 4=6 to 10 years, 5=More than 10 years."""
+
+
 class LinkedinSearchPostsInput(TypedDict, total=False):
     """Input for LinkedIn Post Search."""
 
@@ -3580,6 +3752,117 @@ class LinkedinSearchCompaniesItem(BaseModel):
     )
 
 
+class LinkedinSearchLeadsData(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    items: list[LinkedinSearchLeadsItem] = Field(
+        description="Matching leads, up to 25 per page. Populated whenever the provider has data for the entity."
+    )
+    page: int | None = Field(
+        default=None, description="The page this response holds, starting at 1."
+    )
+    total_pages: int | None = Field(
+        default=None,
+        alias="totalPages",
+        description="How many pages of up to 25 leads the search has.",
+    )
+    total_results: int | None = Field(
+        default=None,
+        alias="totalResults",
+        description="How many leads match the search in total, across every page.",
+    )
+
+
+class LinkedinSearchLeadsItem(BaseModel):
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    about: str | None = Field(
+        default=None, description="Profile summary text, when the member wrote one."
+    )
+    current_positions: list[LinkedinSearchLeadsCurrentPosition] | None = Field(
+        default=None,
+        alias="currentPositions",
+        description="Current roles. Populated whenever the provider has data for the entity. Present whenever the upstream returns this record.",
+    )
+    first_name: str | None = Field(
+        default=None,
+        alias="firstName",
+        description="Member's first name. Populated whenever the provider has data for the entity. Present whenever the upstream returns this record.",
+    )
+    id: str | None = Field(
+        default=None, description="LinkedIn member id, the last segment of `url`."
+    )
+    image: str | None = Field(
+        default=None,
+        description="Profile picture URL. The query string is a signed token, so keep the URL intact. Populated whenever the provider has data for the entity. Present whenever the upstream returns this record.",
+    )
+    last_name: str | None = Field(
+        default=None,
+        alias="lastName",
+        description="Member's last name. Populated whenever the provider has data for the entity. Present whenever the upstream returns this record.",
+    )
+    location: str | None = Field(
+        default=None,
+        description="Member's location as a single string (city, region, country). Populated whenever the provider has data for the entity. Present whenever the upstream returns this record.",
+    )
+    open_profile: bool | None = Field(
+        default=None,
+        alias="openProfile",
+        description="Whether the member accepts messages from people outside their network.",
+    )
+    premium: bool | None = Field(
+        default=None,
+        description="Whether the member has a LinkedIn Premium subscription.",
+    )
+    url: str = Field(
+        description="LinkedIn profile URL in its member-id form (https://www.linkedin.com/in/ACwAAA...). It opens the profile on LinkedIn, and passing it as `url` to linkedin.profile returns the full record. Populated whenever the provider has data for the entity."
+    )
+
+
+class LinkedinSearchLeadsCurrentPosition(BaseModel):
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    company_id: str | None = Field(
+        default=None, alias="companyId", description="LinkedIn company id."
+    )
+    company_linkedin_url: str | None = Field(
+        default=None,
+        alias="companyLinkedinUrl",
+        description="LinkedIn company page URL.",
+    )
+    company_name: str | None = Field(
+        default=None, alias="companyName", description="Company name."
+    )
+    started_on: LinkedinSearchLeadsStartedOn | None = Field(
+        default=None,
+        alias="startedOn",
+        description="When the role started, as `month` (1-12, when shown) and `year`.",
+    )
+    tenure_at_company: LinkedinSearchLeadsTenureAtCompany | None = Field(
+        default=None,
+        alias="tenureAtCompany",
+        description="Time at this company, as `numYears` and `numMonths`.",
+    )
+    tenure_at_position: LinkedinSearchLeadsTenureAtPosition | None = Field(
+        default=None,
+        alias="tenureAtPosition",
+        description="Time in this role, as `numYears` and `numMonths`.",
+    )
+    title: str | None = Field(default=None, description="Job title.")
+
+
+class LinkedinSearchLeadsStartedOn(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+
+class LinkedinSearchLeadsTenureAtCompany(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+
+class LinkedinSearchLeadsTenureAtPosition(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+
 class LinkedinSearchPostsData(BaseModel):
     model_config = ConfigDict(populate_by_name=True)
 
@@ -4592,6 +4875,31 @@ class LinkedinNamespace:
         )
         return RunResult[LinkedinSearchCompaniesData].model_validate(raw)
 
+    def search_leads(
+        self,
+        *,
+        options: RequestOptions | None = None,
+        **input: Unpack[LinkedinSearchLeadsInput],
+    ) -> RunResult[LinkedinSearchLeadsData]:
+        """LinkedIn Fast Leads List
+
+        Fast LinkedIn leads list: one call returns a page of up to 25 people
+        matching a keyword and optional filters (location, job title, company,
+        school, seniority, function, company size, and more), each with name,
+        current positions, location, summary, and photo. Each lead's url opens the
+        profile and can be passed to linkedin.profile for the full record. For full
+        profiles in one call use linkedin.search_profiles.
+
+        Price: $0.07 per request.
+
+        Example:
+            res = client.linkedin.search_leads(currentCompanies=["Google"], query="engineer")
+        """
+        raw = self._client._run_raw(  # pyright: ignore[reportPrivateUsage]
+            "linkedin.search_leads", dict(input), options
+        )
+        return RunResult[LinkedinSearchLeadsData].model_validate(raw)
+
     def search_posts(
         self,
         *,
@@ -4673,7 +4981,7 @@ class LinkedinNamespace:
         linkedin.search_profiles_thin; add emails with
         linkedin.search_profiles_email.
 
-        Price: $0.088 per request plus $0.0044 per result (maximum $0.198).
+        Price: $0.08 per request plus $0.004 per result (maximum $0.18).
 
         Example:
             res = client.linkedin.search_profiles(currentCompanies=["Google"], limit=3, query="engineer")
@@ -5286,6 +5594,31 @@ class AsyncLinkedinNamespace:
         )
         return RunResult[LinkedinSearchCompaniesData].model_validate(raw)
 
+    async def search_leads(
+        self,
+        *,
+        options: RequestOptions | None = None,
+        **input: Unpack[LinkedinSearchLeadsInput],
+    ) -> RunResult[LinkedinSearchLeadsData]:
+        """LinkedIn Fast Leads List
+
+        Fast LinkedIn leads list: one call returns a page of up to 25 people
+        matching a keyword and optional filters (location, job title, company,
+        school, seniority, function, company size, and more), each with name,
+        current positions, location, summary, and photo. Each lead's url opens the
+        profile and can be passed to linkedin.profile for the full record. For full
+        profiles in one call use linkedin.search_profiles.
+
+        Price: $0.07 per request.
+
+        Example:
+            res = client.linkedin.search_leads(currentCompanies=["Google"], query="engineer")
+        """
+        raw = await self._client._arun_raw(  # pyright: ignore[reportPrivateUsage]
+            "linkedin.search_leads", dict(input), options
+        )
+        return RunResult[LinkedinSearchLeadsData].model_validate(raw)
+
     async def search_posts(
         self,
         *,
@@ -5367,7 +5700,7 @@ class AsyncLinkedinNamespace:
         linkedin.search_profiles_thin; add emails with
         linkedin.search_profiles_email.
 
-        Price: $0.088 per request plus $0.0044 per result (maximum $0.198).
+        Price: $0.08 per request plus $0.004 per result (maximum $0.18).
 
         Example:
             res = client.linkedin.search_profiles(currentCompanies=["Google"], limit=3, query="engineer")