getanyapi 0.92.0__tar.gz → 0.93.1__tar.gz

{getanyapi-0.92.0 → getanyapi-0.93.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: getanyapi
-Version: 0.92.0
+Version: 0.93.1
 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.92.0 → getanyapi-0.93.1}/pyproject.toml

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

{getanyapi-0.92.0 → getanyapi-0.93.1}/src/getanyapi/__init__.py

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

{getanyapi-0.92.0 → getanyapi-0.93.1}/src/getanyapi/platforms/google.py

@@ -198,7 +198,7 @@ class GoogleSearchInput(TypedDict, total=False):
     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."""
     limit: NotRequired[int]
-    """Maximum number of organic results to return in this response. Google stopped honoring bulk result counts in September 2025, so one page is about 10 results and a limit above 10 is accepted but will not return more than that. To go deeper, send page (about 10 results per page, each billed as a request) or use google.search_100, which returns up to 100 ranked results in a single call for one flat charge and is cheaper past roughly 20 results. Price is flat per request. Range: 1 to 100. Default: 10."""
+    """Page size to ask for. Google returns about 10 organic results per page and stopped honoring larger counts in September 2025, so a limit above 10 still returns about 10. Some sources return their whole page of about 10 whatever limit says: a page is never trimmed after the call, so nextCursor always continues exactly where this response ended. To go deeper, send page (about 10 results per page, each billed as a request) or use google.search_100, which returns up to 100 ranked results in a single call for one flat charge and is cheaper past roughly 20 results. Price is flat per request. Range: 1 to 100. Default: 10."""
     location: NotRequired[str]
     """Fine-grained location to localize results to, more specific than the country-level gl. Send it as an Active Canonical Name from Google's geo-target list: place, then each parent region, then country, with no space after each comma, e.g. 'New York,New York,United States', 'Austin,Texas,United States', 'London,England,United Kingdom'. Common variations are translated to that name when they point to exactly one place: spaces after commas, missing accents, a US state abbreviation ('Orlando, FL, United States'), or a skipped region ('Sydney, Australia'). A value that names no place, or more than one, is rejected rather than quietly searched from somewhere else."""
     page: NotRequired[int]

{getanyapi-0.92.0 → getanyapi-0.93.1}/src/getanyapi/platforms/linkedin.py

@@ -257,6 +257,8 @@ class LinkedinJobsInput(TypedDict, total=False):
     """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."""
     company: NotRequired[str]
     """Filter to a specific company by name (e.g. Google)."""
+    cursor: NotRequired[str]
+    """Opaque pagination cursor from a previous response's nextCursor. Omit for the first page; pass it to fetch the next page of job listings."""
     easyApply: NotRequired[bool]
     """When true, only return jobs offering LinkedIn Easy Apply."""
     employmentType: NotRequired[
@@ -272,7 +274,7 @@ class LinkedinJobsInput(TypedDict, total=False):
     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."""
     limit: NotRequired[int]
-    """Maximum number of results to return (1-25, default 25). You are billed per result returned, so a lower limit costs less. Range: 1 to 25."""
+    """Accepted for compatibility and ignored: each call returns one full page of up to 25 jobs at one flat price per call; follow nextCursor for more. Range: 1 to 25."""
     location: NotRequired[str]
     """City, region, or country to search within (e.g. United States, San Francisco)."""
     postedLimit: NotRequired[Literal["1h", "24h", "week", "month"]]
@@ -304,6 +306,8 @@ class LinkedinJobsThinInput(TypedDict, total=False):
     """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."""
     companyId: NotRequired[str]
     """Filter to a specific company by its LinkedIn numeric company id."""
+    cursor: NotRequired[str]
+    """Opaque pagination cursor from a previous response's nextCursor. Omit for the first page; pass it to fetch the next page of job listings."""
     employmentType: NotRequired[
         Literal["full-time", "part-time", "contract", "internship", "temporary"]
     ]
@@ -319,7 +323,7 @@ class LinkedinJobsThinInput(TypedDict, total=False):
     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."""
     limit: NotRequired[int]
-    """Maximum number of results to return (1-25, default 25). Range: 1 to 25."""
+    """Accepted for compatibility and ignored: each call returns one full source page (10 or 25 jobs depending on source); follow nextCursor for more. Range: 1 to 25."""
     location: NotRequired[str]
     """City, region, or country to search within."""
     postedLimit: NotRequired[Literal["24h", "week", "month"]]
@@ -2105,9 +2109,16 @@ class LinkedinJobSalary(BaseModel):
 
 
 class LinkedinJobsData(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
     items: list[LinkedinJobsItem] = Field(
         description="Full job listing records for the search. Populated whenever the provider has data for the entity."
     )
+    next_cursor: str | None = Field(
+        default=None,
+        alias="nextCursor",
+        description="Opaque cursor for the next page of job listings, or null when there are no more. Pass it back as cursor to continue.",
+    )
 
 
 class LinkedinJobsItem(BaseModel):
@@ -2248,9 +2259,16 @@ class LinkedinJobsSalary(BaseModel):
 
 
 class LinkedinJobsThinData(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
     items: list[LinkedinJobsThinItem] = Field(
         description="Job listing index records for the search. Populated whenever the provider has data for the entity."
     )
+    next_cursor: str | None = Field(
+        default=None,
+        alias="nextCursor",
+        description="Opaque cursor for the next page of job listings, or null when there are no more. Pass it back as cursor to continue.",
+    )
 
 
 class LinkedinJobsThinItem(BaseModel):
@@ -4630,7 +4648,7 @@ class LinkedinNamespace:
         description, salary, applicant count, seniority, company details, and
         benefits. Up to 25 jobs per request.
 
-        Price: $0.0011 per request plus $0.0011 per result (maximum $0.0286).
+        Price: $0.0286 per request plus $0 per result (maximum $0.0286).
 
         Example:
             res = client.linkedin.jobs(limit=3, location="United States", query="software engineer", workplaceType="remote")
@@ -4640,6 +4658,29 @@ class LinkedinNamespace:
         )
         return RunResult[LinkedinJobsData].model_validate(raw)
 
+    def iter_jobs(
+        self,
+        *,
+        options: RequestOptions | None = None,
+        **input: Unpack[LinkedinJobsInput],
+    ) -> Paginator[LinkedinJobsItem, LinkedinJobsData]:
+        """Iterate LinkedIn Jobs results, following pagination cursors.
+
+        Yields validated `LinkedinJobsItem` items from the `items` field of
+        each page. Use `.pages()` on the returned paginator to walk whole
+        `RunResult` pages.
+        """
+        return paginate(
+            self._client,
+            "linkedin.jobs",
+            dict(input),
+            "items",
+            item_model=LinkedinJobsItem,
+            data_model=LinkedinJobsData,
+            bare=False,
+            options=options,
+        )
+
     def jobs_thin(
         self,
         *,
@@ -4661,6 +4702,29 @@ class LinkedinNamespace:
         )
         return RunResult[LinkedinJobsThinData].model_validate(raw)
 
+    def iter_jobs_thin(
+        self,
+        *,
+        options: RequestOptions | None = None,
+        **input: Unpack[LinkedinJobsThinInput],
+    ) -> Paginator[LinkedinJobsThinItem, LinkedinJobsThinData]:
+        """Iterate LinkedIn Jobs (index) results, following pagination cursors.
+
+        Yields validated `LinkedinJobsThinItem` items from the `items` field of
+        each page. Use `.pages()` on the returned paginator to walk whole
+        `RunResult` pages.
+        """
+        return paginate(
+            self._client,
+            "linkedin.jobs_thin",
+            dict(input),
+            "items",
+            item_model=LinkedinJobsThinItem,
+            data_model=LinkedinJobsThinData,
+            bare=False,
+            options=options,
+        )
+
     def post(
         self,
         *,
@@ -5397,7 +5461,7 @@ class AsyncLinkedinNamespace:
         description, salary, applicant count, seniority, company details, and
         benefits. Up to 25 jobs per request.
 
-        Price: $0.0011 per request plus $0.0011 per result (maximum $0.0286).
+        Price: $0.0286 per request plus $0 per result (maximum $0.0286).
 
         Example:
             res = client.linkedin.jobs(limit=3, location="United States", query="software engineer", workplaceType="remote")
@@ -5407,6 +5471,29 @@ class AsyncLinkedinNamespace:
         )
         return RunResult[LinkedinJobsData].model_validate(raw)
 
+    def iter_jobs(
+        self,
+        *,
+        options: RequestOptions | None = None,
+        **input: Unpack[LinkedinJobsInput],
+    ) -> AsyncPaginator[LinkedinJobsItem, LinkedinJobsData]:
+        """Iterate LinkedIn Jobs results, following pagination cursors.
+
+        Yields validated `LinkedinJobsItem` items from the `items` field of
+        each page. Use `.pages()` on the returned paginator to walk whole
+        `RunResult` pages.
+        """
+        return apaginate(
+            self._client,
+            "linkedin.jobs",
+            dict(input),
+            "items",
+            item_model=LinkedinJobsItem,
+            data_model=LinkedinJobsData,
+            bare=False,
+            options=options,
+        )
+
     async def jobs_thin(
         self,
         *,
@@ -5428,6 +5515,29 @@ class AsyncLinkedinNamespace:
         )
         return RunResult[LinkedinJobsThinData].model_validate(raw)
 
+    def iter_jobs_thin(
+        self,
+        *,
+        options: RequestOptions | None = None,
+        **input: Unpack[LinkedinJobsThinInput],
+    ) -> AsyncPaginator[LinkedinJobsThinItem, LinkedinJobsThinData]:
+        """Iterate LinkedIn Jobs (index) results, following pagination cursors.
+
+        Yields validated `LinkedinJobsThinItem` items from the `items` field of
+        each page. Use `.pages()` on the returned paginator to walk whole
+        `RunResult` pages.
+        """
+        return apaginate(
+            self._client,
+            "linkedin.jobs_thin",
+            dict(input),
+            "items",
+            item_model=LinkedinJobsThinItem,
+            data_model=LinkedinJobsThinData,
+            bare=False,
+            options=options,
+        )
+
     async def post(
         self,
         *,

{getanyapi-0.92.0 → getanyapi-0.93.1}/src/getanyapi/platforms/maps.py

@@ -197,7 +197,7 @@ class MapsSearchNearbyInput(TypedDict, total=False):
     language: NotRequired[str]
     """Two-letter language code for the results (e.g. en). Default: en."""
     limit: NotRequired[int]
-    """Maximum number of places to return in this response (1-20). Google Maps returns one viewport of about 20 places per call; page with cursor for more. Price is flat per request. Range: 1 to 20. Default: 20."""
+    """Accepted but does not change the page: every call returns one full Google Maps viewport of about 20 places, never trimmed, so nextCursor continues exactly where this response ended. Price is flat per request. Range: 1 to 20. Default: 20."""
     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."""
     query: Required[str]

{getanyapi-0.92.0 → getanyapi-0.93.1}/src/getanyapi/platforms/pinterest.py

@@ -31,7 +31,7 @@ class PinterestSearchInput(TypedDict, total=False):
     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."""
     limit: NotRequired[int]
-    """Maximum number of results to return from this page (1-20). Range: 1 to 20."""
+    """Page size to ask for (1-20). Some sources return their whole page of about 20 pins whatever limit says: a page is never trimmed after the call, so nextCursor continues exactly where this response ended. Range: 1 to 20."""
     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."""
     query: Required[str]

{getanyapi-0.92.0 → getanyapi-0.93.1}/src/getanyapi/platforms/reddit.py

@@ -156,7 +156,7 @@ class RedditSubredditPostsInput(TypedDict, total=False):
     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."""
     limit: NotRequired[int]
-    """Requested number of posts. Note: the upstream returns one page (about 25 posts) per call; values larger than a page are not delivered in a single response. To fetch more, pass `nextCursor` back as `cursor`. Range: 1 to 100. Default: 25."""
+    """Page size to ask for (up to 100). Some sources honor it; others always return their whole page of about 25 posts. A page is never trimmed after the call, so pass nextCursor back as cursor to continue exactly where this response ended. Range: 1 to 100. Default: 25."""
     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."""
     requireFields: NotRequired[
@@ -231,7 +231,7 @@ class RedditUserCommentsInput(TypedDict, total=False):
     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."""
     limit: NotRequired[int]
-    """Maximum number of comments to return in this response (a page cap, not a total). Defaults to 25. Range: 1 to 100. Default: 25."""
+    """Page size to ask for (up to 100, default 25). Some sources honor it; others always return their whole page of about 25 comments. A page is never trimmed after the call, so pass nextCursor back as cursor to continue exactly where this response ended. Range: 1 to 100. Default: 25."""
     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."""
     sort: NotRequired[Literal["new", "top", "hot", "controversial"]]

{getanyapi-0.92.0 → getanyapi-0.93.1}/src/getanyapi/platforms/twitter.py

@@ -76,7 +76,7 @@ class TwitterFollowersInput(TypedDict, total=False):
     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."""
     limit: NotRequired[int]
-    """Per-page maximum number of followers to return (default 200). A native page holds up to 200 accounts, so a larger limit still returns at most one native page; follow the response's nextCursor for more. Range: 1 to 100000. Default: 200."""
+    """Accepted but does not change the page: every call returns one full native page of followers (up to 200, depending on the source), never trimmed, so follow nextCursor to continue exactly where this response ended. Range: 1 to 100000. Default: 200."""
     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."""
     requireFields: NotRequired[list[Literal["bio", "following"]]]
@@ -97,7 +97,7 @@ class TwitterFollowingInput(TypedDict, total=False):
     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."""
     limit: NotRequired[int]
-    """Per-page maximum number of followed accounts to return (default 200). A limit larger than the native page still returns at most one native page; follow the response's nextCursor for more. Range: 1 to 100000. Default: 200."""
+    """Accepted but does not change the page: every call returns one full native page of followed accounts (about 50), never trimmed, so follow nextCursor to continue exactly where this response ended. Range: 1 to 100000. Default: 200."""
     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."""
     requireFields: NotRequired[list[Literal["location"]]]
@@ -154,7 +154,7 @@ class TwitterSearchInput(TypedDict, total=False):
     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."""
     limit: NotRequired[int]
-    """Per-page maximum number of results to return (1-50, default 20). A provider may return a smaller native page; follow nextCursor for more. Range: 1 to 50. Default: 20."""
+    """Page size to ask for (1-50, default 20). Some sources honor it; others always return their whole native page of about 20. A page is never trimmed after the call, so follow nextCursor to continue exactly where this response ended. Range: 1 to 50. Default: 20."""
     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."""
     query: Required[str]
@@ -304,7 +304,7 @@ class TwitterUserTweetsInput(TypedDict, total=False):
     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."""
     limit: NotRequired[int]
-    """Maximum number of authored tweets and replies to return in THIS page (1-100). Sources return fewer - most cap at 20 - so read `nextCursor` and pass it back as `cursor` to walk further rather than asking for one large page. Range: 1 to 100. Default: 20."""
+    """Page size to ask for (1-100, default 20). Some sources honor it; others always return their whole native page of about 20 authored tweets and replies. A page is never trimmed after the call, so follow nextCursor and pass it back as cursor to continue exactly where this response ended. Range: 1 to 100. Default: 20."""
     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."""
     requireFields: NotRequired[list[Literal["isPinned"]]]
@@ -1796,7 +1796,7 @@ class TwitterNamespace:
         records with follower, following, and post counts plus cursor pagination.
         Use twitter.search for posts.
 
-        Price: $0.00075 per request.
+        Price: $0.0007 per request.
 
         Example:
             res = client.twitter.search_users(query="ai agents")
@@ -2336,7 +2336,7 @@ class AsyncTwitterNamespace:
         records with follower, following, and post counts plus cursor pagination.
         Use twitter.search for posts.
 
-        Price: $0.00075 per request.
+        Price: $0.0007 per request.
 
         Example:
             res = client.twitter.search_users(query="ai agents")