vntd 1.0.0__py3-none-any.whl

vntd/__init__.py

@@ -0,0 +1,14 @@
+__version__ = "1.0.0"
+
+from .client import Client
+from .model import Proxy, Search, Ad, User, Sort, SellerType
+
+__all__ = [
+    "Client",
+    "Proxy",
+    "Search",
+    "Ad",
+    "User",
+    "Sort",
+    "SellerType",
+]

vntd/client.py

@@ -0,0 +1,124 @@
+from curl_cffi import BrowserTypeLiteral
+import curl_cffi
+
+from .mixin import SessionMixin, SearchMixin, UserMixin, AdMixin
+from .model import Proxy
+from .exceptions import AccessDeniedError, RequestError, NotFoundError
+
+
+class Client(SessionMixin, SearchMixin, UserMixin, AdMixin):
+    def __init__(
+        self,
+        base_url: str = "https://www.vinted.fr",
+        proxy: Proxy | None = None,
+        impersonate: BrowserTypeLiteral = None,
+        user_agent: str | None = None,
+        user_agents: list[str] | None = None,
+        request_verify: bool = True,
+        timeout: float = 30.0,
+        max_retries: int = 3,
+    ):
+        """
+        Initializes a Vinted Client instance with optional proxy, browser impersonation,
+        and SSL verification settings.
+
+        Args:
+            base_url (str, optional): Base Vinted domain to target (e.g., "https://www.vinted.fr"). Defaults to "https://www.vinted.fr".
+            proxy (Proxy | None, optional): Proxy configuration to use for the client. If provided, it will be applied to all requests. Defaults to None.
+            impersonate (BrowserTypeLiteral, optional): Browser type to impersonate for requests (e.g., "firefox", "chrome", "edge", "safari"). If None, a random browser type will be chosen.
+            user_agent (str | None, optional): Explicit User-Agent string to use for requests.
+            user_agents (list[str] | None, optional): List of User-Agent strings to rotate from.
+            request_verify (bool, optional): Whether to verify SSL certificates when sending requests. Defaults to True.
+            timeout (float, optional): Maximum time in seconds to wait for a request before timing out. Defaults to 30.
+            max_retries (int, optional): Maximum number of times to retry a request in case of anti-bot failures. Defaults to 3.
+        """
+        self.base_url = base_url.rstrip("/")
+
+        super().__init__(
+            base_url=self.base_url,
+            proxy=proxy,
+            impersonate=impersonate,
+            user_agent=user_agent,
+            user_agents=user_agents,
+            request_verify=request_verify,
+        )
+
+        self.request_verify = request_verify
+        self.timeout = timeout
+        self.max_retries = max_retries
+
+    def _fetch(
+        self,
+        method: str,
+        url: str,
+        payload: dict | None = None,
+        params: dict | None = None,
+        max_retries: int = -1,
+        expect_json: bool = True,
+    ):
+        """
+        Internal method to send an HTTP request using the configured session.
+
+        Args:
+            method (str): HTTP method to use (e.g., "GET", "POST").
+            url (str): Full URL of the API endpoint.
+            payload (dict | None, optional): JSON payload to send with the request. Used for POST/PUT methods. Defaults to None.
+            params (dict | None, optional): Query string parameters. Defaults to None.
+            max_retries (int, optional): Number of times to retry the request in case of failure. Defaults to 3.
+            expect_json (bool, optional): Whether to parse the response as JSON. Defaults to True.
+
+        Raises:
+            AccessDeniedError: Raised when the request is blocked by anti-bot protection (HTTP 403/429).
+            RequestError: Raised for any other non-successful HTTP response.
+
+        Returns:
+            dict | str: Parsed JSON response from the server, or raw text if expect_json is False.
+        """
+        if max_retries == -1:
+            max_retries = self.max_retries
+
+        response: curl_cffi.Response = self.session.request(
+            method=method,
+            url=url,
+            params=params,
+            json=payload,
+            verify=self.request_verify,
+            timeout=self.timeout,
+        )
+        if response.ok:
+            return response.json() if expect_json else response.text
+        elif response.status_code in (403, 429):
+            if max_retries > 0:
+                self.session = self._init_session(
+                    base_url=self.base_url,
+                    proxy=self._proxy,
+                    impersonate=self._impersonate,
+                    user_agent=self._user_agent,
+                    user_agents=self._user_agents,
+                    request_verify=self.request_verify,
+                )  # Re-init session
+                return self._fetch(
+                    method=method,
+                    url=url,
+                    payload=payload,
+                    params=params,
+                    max_retries=max_retries - 1,
+                    expect_json=expect_json,
+                )
+            raise AccessDeniedError(
+                "Access blocked by anti-bot protection. Try reducing request frequency or changing proxy."
+            )
+        elif response.status_code in (404, 410):
+            raise NotFoundError("Unable to find the requested resource.")
+        else:
+            raise RequestError(
+                f"Request failed with status code {response.status_code}."
+            )
+
+    def _fetch_text(self, url: str, max_retries: int = -1) -> str:
+        return self._fetch(
+            method="GET",
+            url=url,
+            max_retries=max_retries,
+            expect_json=False,
+        )

vntd/exceptions.py

@@ -0,0 +1,18 @@
+class VintedError(Exception):
+    """Base exception for all errors raised by the Vinted client."""
+
+
+class InvalidValue(VintedError):
+    """Raised when a provided value is invalid or improperly formatted."""
+
+
+class RequestError(VintedError):
+    """Raised when an HTTP request fails with a non-success status code."""
+
+
+class AccessDeniedError(RequestError):
+    """Raised when access is blocked by anti-bot protection."""
+
+
+class NotFoundError(VintedError):
+    """Raised when a user or item is not found."""

vntd/mixin/__init__.py

@@ -0,0 +1,6 @@
+from .session import SessionMixin
+from .search import SearchMixin
+from .user import UserMixin
+from .ad import AdMixin
+
+__all__ = ["SessionMixin", "SearchMixin", "UserMixin", "AdMixin"]

vntd/mixin/ad.py

@@ -0,0 +1,54 @@
+from html import unescape
+import json
+import re
+
+from ..model import Ad
+from ..exceptions import InvalidValue, NotFoundError
+
+
+class AdMixin:
+    def get_ad(self, ad_id: str | int) -> Ad:
+        """
+        Retrieve detailed information about a Vinted item using its ID or URL.
+        """
+        item_id = self._extract_item_id(ad_id)
+        url = f"{self.base_url}/items/{item_id}"
+
+        html = self._fetch_text(url)
+        ld_data = self._extract_json_ld(html)
+        if not ld_data:
+            raise NotFoundError("Unable to find item details.")
+
+        seller_id = self._extract_seller_id(html)
+        return Ad._build_from_item_page(
+            raw=ld_data, item_id=item_id, url=url, seller_id=seller_id, client=self
+        )
+
+    def _extract_item_id(self, ad_id: str | int) -> int:
+        if isinstance(ad_id, int):
+            return ad_id
+
+        if isinstance(ad_id, str):
+            match = re.search(r"/items/(\d+)", ad_id)
+            if match:
+                return int(match.group(1))
+            match = re.search(r"^(\d+)", ad_id)
+            if match:
+                return int(match.group(1))
+
+        raise InvalidValue("ad_id must be a Vinted item ID or item URL.")
+
+    def _extract_json_ld(self, html: str) -> dict | None:
+        match = re.search(
+            r'<script type="application/ld\+json">(.*?)</script>',
+            html,
+            re.DOTALL,
+        )
+        if not match:
+            return None
+        raw_json = unescape(match.group(1)).strip()
+        return json.loads(raw_json)
+
+    def _extract_seller_id(self, html: str) -> int | None:
+        match = re.search(r'\\"seller_id\\":(\d+)', html)
+        return int(match.group(1)) if match else None

vntd/mixin/search.py

@@ -0,0 +1,44 @@
+from ..model import Sort, SellerType, Search
+from ..utils import build_search_params_with_args, build_search_params_with_url
+
+
+class SearchMixin:
+    def search(
+        self,
+        url: str | None = None,
+        text: str | None = None,
+        sort: Sort = Sort.RELEVANCE,
+        page: int = 1,
+        limit: int = 24,
+        seller_type: SellerType = SellerType.ALL,
+        user_id: int | None = None,
+        price: tuple[int | None, int | None] | list[int | None] | None = None,
+        **filters,
+    ) -> Search:
+        """
+        Perform an item search on Vinted with the specified criteria.
+
+        You can either:
+        - Provide a full `url` from a Vinted search to replicate the search directly.
+        - Or use the individual parameters (`text`, `sort`, `price`, etc.) to construct a custom search.
+        """
+        if url:
+            params = build_search_params_with_url(url=url, limit=limit, page=page)
+        else:
+            params = build_search_params_with_args(
+                text=text,
+                sort=sort,
+                page=page,
+                limit=limit,
+                seller_type=seller_type,
+                user_id=user_id,
+                price=price,
+                **filters,
+            )
+
+        body = self._fetch(
+            method="GET",
+            url=f"{self.base_url}/api/v2/catalog/items",
+            params=params,
+        )
+        return Search._build(raw=body, client=self)

vntd/mixin/session.py

@@ -0,0 +1,124 @@
+from curl_cffi import requests, BrowserTypeLiteral
+import random
+
+from fake_useragent import UserAgent
+
+from ..model import Proxy
+from ..exceptions import InvalidValue
+
+
+DEFAULT_USER_AGENTS = [
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 13_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Safari/605.1.15",
+    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
+]
+
+_UA = UserAgent(platforms=["desktop"])
+
+_BROWSER_MAP: dict[str | None, list[str]] = {
+    "chrome": ["Chrome"],
+    "firefox": ["Firefox"],
+    "safari": ["Safari"],
+    "edge": ["Edge"],
+}
+
+
+class SessionMixin:
+    def __init__(
+        self,
+        base_url: str,
+        proxy: Proxy | None = None,
+        impersonate: BrowserTypeLiteral = None,
+        user_agent: str | None = None,
+        user_agents: list[str] | None = None,
+        request_verify: bool = True,
+        **kwargs,
+    ):
+        self.base_url = base_url.rstrip("/")
+        self._user_agent = user_agent
+        self._user_agents = user_agents
+        self.session = self._init_session(
+            base_url=self.base_url,
+            proxy=proxy,
+            impersonate=impersonate,
+            user_agent=user_agent,
+            user_agents=user_agents,
+            request_verify=request_verify,
+        )
+        self._proxy = proxy
+        self._impersonate = impersonate
+        super().__init__(**kwargs)
+
+    def _select_user_agent(
+        self,
+        user_agent: str | None,
+        user_agents: list[str] | None,
+        impersonate: BrowserTypeLiteral = None,
+    ) -> str:
+        if user_agent and user_agents:
+            raise InvalidValue("Provide either user_agent or user_agents, not both.")
+        if user_agent:
+            return user_agent
+        if user_agents:
+            if not all(isinstance(value, str) for value in user_agents):
+                raise InvalidValue("user_agents must be a list of strings.")
+            return random.choice(user_agents)
+
+        # Try fake-useragent with browser-coherent selection
+        try:
+            browsers = _BROWSER_MAP.get(impersonate, list(_BROWSER_MAP.values())[0])
+            browser = random.choice(browsers)
+            return getattr(_UA, browser.lower(), _UA.random)
+        except Exception:
+            pass
+
+        return random.choice(DEFAULT_USER_AGENTS)
+
+    def _init_session(
+        self,
+        base_url: str,
+        proxy: Proxy | None = None,
+        impersonate: BrowserTypeLiteral = None,
+        user_agent: str | None = None,
+        user_agents: list[str] | None = None,
+        request_verify: bool = True,
+    ) -> requests.Session:
+        """
+        Initializes an HTTP session with optional proxy configuration and browser impersonation.
+        """
+        if impersonate is None:  # Pick a random browser client
+            impersonate = random.choice(["safari", "chrome", "firefox"])
+
+        session = requests.Session(impersonate=impersonate)
+
+        session.headers.update(
+            {
+                "User-Agent": self._select_user_agent(
+                    user_agent, user_agents, impersonate
+                ),
+                "Accept": "application/json, text/plain, */*",
+                "Accept-Language": "fr-FR,fr;q=0.9,en;q=0.8",
+                "Origin": base_url,
+                "Referer": f"{base_url}/",
+            }
+        )
+        if proxy:
+            session.proxies = {"http": proxy.url, "https": proxy.url}
+
+        session.get(f"{base_url}/", verify=request_verify)  # Init cookies
+        return session
+
+    @property
+    def proxy(self) -> Proxy:
+        return self._proxy
+
+    @proxy.setter
+    def proxy(self, value: Proxy):
+        if value:
+            if isinstance(value, Proxy):
+                self.session.proxies = {"http": value.url, "https": value.url}
+            else:
+                raise TypeError("Proxy must be an instance of the vntd.Proxy")
+        else:
+            self.session.proxies = {}
+        self._proxy = value

vntd/mixin/user.py

@@ -0,0 +1,13 @@
+from ..model import User
+
+
+class UserMixin:
+    def get_user(self, user_id: str | int) -> User:
+        """
+        Retrieve information about a Vinted user based on their user ID.
+        """
+        user_data = self._fetch(
+            method="GET",
+            url=f"{self.base_url}/api/v2/users/{user_id}",
+        )
+        return User._build(raw=user_data.get("user", {}))

vntd/model/__init__.py

@@ -0,0 +1,14 @@
+from .proxy import Proxy
+from .search import Search
+from .ad import Ad
+from .user import User
+from .enums import Sort, SellerType
+
+__all__ = [
+    "Proxy",
+    "Search",
+    "Ad",
+    "User",
+    "Sort",
+    "SellerType",
+]

vntd/model/ad.py

@@ -0,0 +1,109 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+from .user import User
+
+
+@dataclass
+class Ad:
+    id: int
+    title: str
+    description: str | None
+    price: float | None
+    currency: str | None
+    brand: str | None
+    size: str | None
+    status: str | None
+    url: str
+    images: list[str]
+    favorite_count: int | None
+    view_count: int | None
+    category: str | None
+    color: str | None
+
+    _client: Any = field(repr=False)
+    _user_id: int | None = field(repr=False)
+    _user: User | None = field(default=None, repr=False)
+
+    @staticmethod
+    def _build_from_search(raw: dict, client: Any) -> "Ad":
+        raw_price = raw.get("price", {})
+        price_amount = raw_price.get("amount")
+        price = float(price_amount) if price_amount is not None else None
+
+        photos = raw.get("photos", [])
+        images = [photo.get("url") for photo in photos if photo.get("url")]
+        if not images and raw.get("photo", {}).get("url"):
+            images = [raw.get("photo", {}).get("url")]
+
+        raw_user = raw.get("user", {})
+        return Ad(
+            id=raw.get("id"),
+            title=raw.get("title"),
+            description=None,
+            price=price,
+            currency=raw_price.get("currency_code"),
+            brand=raw.get("brand_title"),
+            size=raw.get("size_title"),
+            status=raw.get("status"),
+            url=raw.get("url"),
+            images=images,
+            favorite_count=raw.get("favourite_count"),
+            view_count=raw.get("view_count"),
+            category=None,
+            color=None,
+            _client=client,
+            _user_id=raw_user.get("id"),
+            _user=None,
+        )
+
+    @staticmethod
+    def _build_from_item_page(
+        raw: dict, item_id: int, url: str, seller_id: int | None, client: Any
+    ) -> "Ad":
+        images = raw.get("image") or []
+        if isinstance(images, str):
+            images = [images]
+
+        offers = raw.get("offers", {})
+        if isinstance(offers, list):
+            offers = offers[0] if offers else {}
+
+        price_value = offers.get("price")
+        price = float(price_value) if price_value is not None else None
+
+        brand = raw.get("brand", {})
+        if isinstance(brand, dict):
+            brand = brand.get("name")
+        elif isinstance(brand, list):
+            brand = brand[0].get("name") if brand else None
+
+        return Ad(
+            id=item_id,
+            title=raw.get("name"),
+            description=raw.get("description"),
+            price=price,
+            currency=offers.get("priceCurrency"),
+            brand=brand,
+            size=None,
+            status=offers.get("itemCondition"),
+            url=url,
+            images=images,
+            favorite_count=None,
+            view_count=None,
+            category=raw.get("category"),
+            color=raw.get("color"),
+            _client=client,
+            _user_id=seller_id,
+            _user=None,
+        )
+
+    @property
+    def subject(self) -> str:
+        return self.title
+
+    @property
+    def user(self) -> User | None:
+        if self._user is None and self._user_id is not None:
+            self._user = self._client.get_user(user_id=self._user_id)
+        return self._user

vntd/model/enums.py

@@ -0,0 +1,14 @@
+from enum import Enum
+
+
+class SellerType(Enum):
+    BUSINESS = "business"
+    INDIVIDUAL = "individual"
+    ALL = "all"
+
+
+class Sort(Enum):
+    RELEVANCE = "relevance"
+    NEWEST = "newest_first"
+    PRICE_LOW_TO_HIGH = "price_low_to_high"
+    PRICE_HIGH_TO_LOW = "price_high_to_low"

vntd/model/proxy.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Proxy:
+    host: str
+    port: str | int
+    username: str | None = None
+    password: str | None = None
+    scheme: str = "http"
+
+    @property
+    def url(self):
+        if self.username and self.password:
+            return f"{self.scheme}://{self.username}:{self.password}@{self.host}:{self.port}"
+        else:
+            return f"{self.scheme}://{self.host}:{self.port}"

vntd/model/search.py

@@ -0,0 +1,40 @@
+from dataclasses import dataclass
+from typing import Any
+
+from .ad import Ad
+
+
+@dataclass
+class Pagination:
+    current_page: int
+    total_pages: int
+    total_entries: int
+    per_page: int
+
+
+@dataclass
+class Search:
+    pagination: Pagination
+    ads: list[Ad]
+
+    @property
+    def total(self) -> int:
+        return self.pagination.total_entries
+
+    @staticmethod
+    def _build(raw: dict, client: Any) -> "Search":
+        ads: list[Ad] = [
+            Ad._build_from_search(raw=ad, client=client)
+            for ad in raw.get("items", [])
+        ]
+
+        pagination = raw.get("pagination", {})
+        return Search(
+            pagination=Pagination(
+                current_page=pagination.get("current_page"),
+                total_pages=pagination.get("total_pages"),
+                total_entries=pagination.get("total_entries"),
+                per_page=pagination.get("per_page"),
+            ),
+            ads=ads,
+        )

vntd/model/user.py

@@ -0,0 +1,51 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class User:
+    id: int
+    login: str
+    profile_url: str | None
+    business: bool
+    feedback_count: int | None
+    feedback_reputation: float | None
+    item_count: int | None
+    total_items_count: int | None
+    followers_count: int | None
+    following_count: int | None
+    country_code: str | None
+    city: str | None
+    about: str | None
+    photo_url: str | None
+
+    @staticmethod
+    def _build(raw: dict) -> "User":
+        photo = raw.get("photo", {}) or {}
+        return User(
+            id=raw.get("id"),
+            login=raw.get("login"),
+            profile_url=raw.get("profile_url"),
+            business=bool(raw.get("business")),
+            feedback_count=raw.get("feedback_count"),
+            feedback_reputation=raw.get("feedback_reputation"),
+            item_count=raw.get("item_count"),
+            total_items_count=raw.get("total_items_count"),
+            followers_count=raw.get("followers_count"),
+            following_count=raw.get("following_count"),
+            country_code=raw.get("country_code"),
+            city=raw.get("city"),
+            about=raw.get("about"),
+            photo_url=photo.get("url"),
+        )
+
+    @property
+    def name(self) -> str:
+        return self.login
+
+    @property
+    def is_pro(self) -> bool:
+        return self.business
+
+    @property
+    def feedback_score(self) -> float | None:
+        return self.feedback_reputation * 5 if self.feedback_reputation else None

vntd/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561

vntd/utils.py

@@ -0,0 +1,73 @@
+from urllib.parse import parse_qs, urlparse
+
+from .model import Sort, SellerType
+from .exceptions import InvalidValue
+
+
+def _normalize_list(value) -> str:
+    if isinstance(value, (list, tuple, set)):
+        return ",".join(str(item) for item in value)
+    return str(value)
+
+
+def build_search_params_with_url(url: str, limit: int = 24, page: int = 1) -> dict:
+    parsed = urlparse(url)
+    query = parse_qs(parsed.query)
+
+    params = {}
+    for key, values in query.items():
+        if not values:
+            continue
+        params[key] = ",".join(values) if len(values) > 1 else values[0]
+
+    params["page"] = page
+    params["per_page"] = limit
+    return params
+
+
+def build_search_params_with_args(
+    text: str | None = None,
+    sort: Sort = Sort.RELEVANCE,
+    page: int = 1,
+    limit: int = 24,
+    seller_type: SellerType = SellerType.ALL,
+    user_id: int | None = None,
+    price: tuple[int | None, int | None] | list[int | None] | None = None,
+    **filters,
+) -> dict:
+    params: dict = {
+        "page": page,
+        "per_page": limit,
+    }
+
+    if text:
+        params["search_text"] = text
+
+    if sort:
+        params["order"] = sort.value
+
+    if seller_type == SellerType.BUSINESS:
+        params["is_business"] = 1
+    elif seller_type == SellerType.INDIVIDUAL:
+        params["is_business"] = 0
+
+    if user_id is not None:
+        params["user_id"] = user_id
+
+    if price is not None:
+        if not isinstance(price, (list, tuple)) or len(price) != 2:
+            raise InvalidValue("price must be a (min, max) tuple.")
+        min_price, max_price = price
+        if min_price is not None:
+            params["price_from"] = min_price
+        if max_price is not None:
+            params["price_to"] = max_price
+    if limit*page > 960:
+        print("Warning: max item index exceeds 960, which seems to be the maximum provided by the Vinted API. You may receive an error")
+
+    for key, value in filters.items():
+        if value is None:
+            continue
+        params[key] = _normalize_list(value)
+
+    return params

vntd-1.0.0.dist-info/METADATA

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: vntd
+Version: 1.0.0
+Summary: Unofficial client for Vinted API
+Keywords: vntd,vinted,wrapper,api
+Author: louis.mltp
+Author-email: louis.mltp <107575190+MINLEGO@users.noreply.github.com>
+License-Expression: MIT
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+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: Typing :: Typed
+Requires-Dist: curl-cffi>=0.15.0
+Requires-Dist: fake-useragent>=2.2.0
+Requires-Python: >=3.10
+Project-URL: Homepage, https://github.com/MINLEGO/vntd
+Project-URL: Repository, https://github.com/MINLEGO/vntd
+Project-URL: Changelog, https://github.com/MINLEGO/vntd/blob/main/CHANGELOG.md
+Description-Content-Type: text/markdown
+
+# vntd
+
+**Unofficial client for the Vinted API.**
+**Fork of [lbc](https://pypi.org/project/lbc/) by [etienne-hd](https://pypi.org/user/etienne-hd/)**
+
+```python
+import vntd
+
+client = vntd.Client()
+
+result = client.search(
+    text="robe",
+    page=1,
+    limit=20,
+    sort=vntd.Sort.NEWEST,
+    price=(5, 30),
+)
+
+for ad in result.ads:
+    print(ad.url, ad.title, ad.price, ad.user)
+```
+
+*vntd is not affiliated with, endorsed by, or in any way associated with Vinted or its services. Use at your own risk.*
+
+## Installation
+Required **Python 3.10+**
+```bash
+pip install vntd
+```
+
+## Usage
+
+### Client
+```python
+import vntd
+
+client = vntd.Client()
+```
+
+### Search
+```python
+result = client.search(
+    text="robe",
+    page=1,
+    limit=24,
+    sort=vntd.Sort.RELEVANCE,
+    price=(10, 40),
+    brand_ids=[53, 54],
+)
+```
+
+### Search with URL
+```python
+result = client.search(
+    url="https://www.vinted.fr/catalog?search_text=robe&order=newest_first&price_from=5&price_to=30",
+    page=1,
+    limit=24,
+)
+```
+
+### Get Item
+```python
+ad = client.get_ad("8975084387")
+print(ad.title, ad.price, ad.user)
+```
+
+### Get User
+```python
+user = client.get_user(80325437)
+print(user.login, user.feedback_score, user.item_count)
+```
+
+### Proxy
+```python
+proxy = vntd.Proxy(host="127.0.0.1", port=12345)
+client = vntd.Client(proxy=proxy)
+```
+
+## Notes
+Vinted does not expose Leboncoin-style radius/region filters or professional store data (SIRET). Use Vinted-native filters such as `price`, `brand_ids`, and `seller_type` instead.

vntd-1.0.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+vntd/__init__.py,sha256=yuaI1vh5CS7Byi9f-05W-iAO22UUHxZjz2RQJKOF2CA,233
+vntd/client.py,sha256=JVnMvMo0-cSgeP2_84XgkIr7AmQhJCvSFYa93UdD_eI,5374
+vntd/exceptions.py,sha256=3b9PvQpql4fhwD0L8QJ9EgLdvYZYzOVelyzm_Qy3zGU,530
+vntd/mixin/__init__.py,sha256=Dwt_W5FYQgSdtvuycHky1uTdDKu5hZgWGi6ygaT29ow,191
+vntd/mixin/ad.py,sha256=L0f3fkYY1DBgDXgiUQEzMhvv4mZujgdj6jBJUbu2JIQ,1770
+vntd/mixin/search.py,sha256=rE9NaQ9Cpi1cw7SPtTj2LLl9vADCAZyM2f9r2o9ici4,1501
+vntd/mixin/session.py,sha256=zSmmJE96453Ed98vpvtl7tSKdxUmUeptNl4fyJplRBM,4243
+vntd/mixin/user.py,sha256=6hB1tTYS8FGdz472m8m9KAmFZ2_ZLOGBsEoOCaxtP6g,392
+vntd/model/__init__.py,sha256=dcSlH2oJpYszxV3JdhgoUN1jbDLm8P2hy61JyAIggW8,238
+vntd/model/ad.py,sha256=u9SOtg1O313lHtVCIOE-NjI-O39z-S3FMS5wqZNd74M,3366
+vntd/model/enums.py,sha256=LMjg4E_1vDBnJYuwxD17Tv-PsVeXyRUSAdbRWsWc6c0,298
+vntd/model/proxy.py,sha256=rsSfbY62DTRnXPLO-LZO-GVffFcDql-WfW5b71valcY,448
+vntd/model/search.py,sha256=nSjUiHMNOGGQBW_pnzxgsMgEa4cTDetJWnfLw58IwNA,987
+vntd/model/user.py,sha256=9tlqPvkvsZ3nwSzKErwSLokUC1akLLTX9NodBlfWwPo,1549
+vntd/py.typed,sha256=TBDV9m9vjfnp9vsgTeJmpoNseoJEfHwvZaBLvLMfzz8,27
+vntd/utils.py,sha256=rK4zKyCpl6_E6eBSc5w60Ngkik-9yxFcelXvjDyKmh0,2134
+vntd-1.0.0.dist-info/WHEEL,sha256=wXwAVsgVaOZ_pwDFqQm5Rd6PID-Fc74nkLc8X8gHiDo,81
+vntd-1.0.0.dist-info/METADATA,sha256=OMuoaBf3XFvkMfpN3ny_kYQTHTfHtK3vx8gXNmmw_go,2642
+vntd-1.0.0.dist-info/RECORD,,

vntd-1.0.0.dist-info/WHEEL

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