cookielessaudiences 1.0.0__tar.gz

cookielessaudiences-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alpha Quantum
+
+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.

cookielessaudiences-1.0.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include LICENSE
+include README.md

cookielessaudiences-1.0.0/PKG-INFO

@@ -0,0 +1,155 @@
+Metadata-Version: 2.1
+Name: cookielessaudiences
+Version: 1.0.0
+Summary: Python client for the Cookieless Audiences API: page-level audience segmentation (demographics, interests, purchase intent, B2B firmographics, personas) and IAB content categorization for any URL, with no cookies and no PII.
+Home-page: https://www.cookielessaudiences.com
+Author: Alpha Quantum
+Author-email: info@alpha-quantum.com
+License: MIT
+Project-URL: Homepage, https://www.cookielessaudiences.com
+Project-URL: Documentation, https://www.cookielessaudiences.com/api.php
+Project-URL: Source, https://github.com/explainableaixai/cookielessaudiences
+Project-URL: Mirror, https://gitlab.com/url-classifications/cookielessaudiences
+Project-URL: Tracker, https://www.cookielessaudiences.com/contact.php
+Project-URL: Pricing, https://www.cookielessaudiences.com/pricing.php
+Description: # cookielessaudiences (Python)
+        
+        Cookieless audience data for a URL, as a Python call. You pass a page and receive demographics, interests, purchase intent, B2B firmographics and personas, with no cookies and no personal data involved.
+        
+        Built on `requests`, works on Python 3.7 and later.
+        
+        ## Setup
+        
+        ```bash
+        pip install cookielessaudiences
+        ```
+        
+        An API key comes with any plan. If you are still comparing options, read how [cookieless audience segmentation](https://www.cookielessaudiences.com/features/cookieless-audience-segmentation.php) works before you buy.
+        
+        ## Quick start
+        
+        ```python
+        from cookielessaudiences import CookielessAudiences, labels_for
+        
+        client = CookielessAudiences("YOUR_API_KEY")
+        result = client.segment("https://example.com/blog")
+        
+        print(result["audience_type"])
+        print(result["demographics"]["income_level"])
+        print(labels_for(result))
+        ```
+        
+        ## Reading the response
+        
+        Think of the structured result as five questions about the reader of a page:
+        
+        1. Who are they? `demographics` and `b2b`
+        2. What do they like? `interests`, two tiers of `INT.*` codes
+        3. What might they buy? `purchase_intent`, `PI.*` codes
+        4. Which named audiences fit? `personas`
+        5. What kind of page is it? `content_context`
+        
+        `labels_for(result)` turns the codes in questions 2 and 3 into names you can show to a person.
+        
+        ## API surface
+        
+        ```python
+        client.segment(url, structured=True)
+        client.categorize(url, confidence=True, root_fallback=False)
+        client.categorize_text(text, confidence=True)
+        client.segment_many(urls, workers=8)
+        CookielessAudiences.vocabularies()
+        ```
+        
+        `segment_many` returns a dict of url to result. A URL that failed holds its exception instead, so one bad page never stops a batch.
+        
+        ## Errors
+        
+        ```python
+        from cookielessaudiences import CookielessAudiencesError
+        
+        try:
+            client.segment(url)
+        except CookielessAudiencesError as exc:
+            print(exc.status, exc.body)
+        ```
+        
+        The HTTP layer is plain; the signal lives in `status` inside the JSON. 401 is a bad key, 403 means the key is inactive or credits are gone, 410 and 411 mean the page could not be read.
+        
+        ## Example: audience report for a media plan
+        
+        ```python
+        import csv
+        from cookielessaudiences import CookielessAudiences, labels_for
+        
+        client = CookielessAudiences("YOUR_API_KEY")
+        sites = [line.strip() for line in open("sites.txt") if line.strip()]
+        results = client.segment_many(sites, workers=10)
+        
+        with open("plan.csv", "w", newline="") as fh:
+            out = csv.writer(fh)
+            out.writerow(["site", "type", "age", "income", "top_interest", "top_intent"])
+            for site, res in results.items():
+                if isinstance(res, Exception):
+                    out.writerow([site, "error", "", "", "", ""])
+                    continue
+                names = labels_for(res)
+                out.writerow([
+                    site,
+                    res.get("audience_type"),
+                    "|".join(res["demographics"].get("age_bracket", [])),
+                    res["demographics"].get("income_level"),
+                    (names["interests"] or [""])[0],
+                    (names["purchase_intent"] or [""])[0],
+                ])
+        ```
+        
+        This is the shape most [website audience demographics](https://www.cookielessaudiences.com/features/website-audience-demographics.php) work takes: many sites in, one row per site out.
+        
+        ## Example: pandas enrichment
+        
+        ```python
+        import pandas as pd
+        
+        df = pd.read_csv("accounts.csv")           # column: url
+        found = client.segment_many(df["url"].tolist())
+        df["audience_type"] = [r.get("audience_type") if isinstance(r, dict) else None for r in found.values()]
+        df["seniority"] = [
+            ",".join(r.get("b2b", {}).get("seniority", [])) if isinstance(r, dict) else None
+            for r in found.values()
+        ]
+        ```
+        
+        ## Example: IAB categories for a text snippet
+        
+        ```python
+        snippet = "Best budget laptops for students heading to university"
+        cats = client.categorize_text(snippet)
+        for name, score in cats["iab_classification"]:
+            print(name, score)
+        ```
+        
+        ## Frequently asked
+        
+        **Can I get the full word list for a field?** Yes. `CookielessAudiences.vocabularies()` returns every enumerated value and needs no key.
+        
+        **What about scale?** The service accepts up to 50 parallel threads by default, about 270 URLs a minute.
+        
+        **Which fields are free text?** None in the structured shape. Small fields are closed lists; open-ended signals are mapped to canonical codes or dropped.
+        
+        ## Package notes
+        
+        MIT licensed. Questions go to info@alpha-quantum.com. Version 1.0.0.
+        
+Keywords: cookieless,audience segmentation,iab audience taxonomy,iab categorization,contextual targeting,seller defined audiences,purchase intent,adtech,media planning,inventory curation,audience data,privacy-safe advertising,domain audience data
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown

cookielessaudiences-1.0.0/README.md

@@ -0,0 +1,128 @@
+# cookielessaudiences (Python)
+
+Cookieless audience data for a URL, as a Python call. You pass a page and receive demographics, interests, purchase intent, B2B firmographics and personas, with no cookies and no personal data involved.
+
+Built on `requests`, works on Python 3.7 and later.
+
+## Setup
+
+```bash
+pip install cookielessaudiences
+```
+
+An API key comes with any plan. If you are still comparing options, read how [cookieless audience segmentation](https://www.cookielessaudiences.com/features/cookieless-audience-segmentation.php) works before you buy.
+
+## Quick start
+
+```python
+from cookielessaudiences import CookielessAudiences, labels_for
+
+client = CookielessAudiences("YOUR_API_KEY")
+result = client.segment("https://example.com/blog")
+
+print(result["audience_type"])
+print(result["demographics"]["income_level"])
+print(labels_for(result))
+```
+
+## Reading the response
+
+Think of the structured result as five questions about the reader of a page:
+
+1. Who are they? `demographics` and `b2b`
+2. What do they like? `interests`, two tiers of `INT.*` codes
+3. What might they buy? `purchase_intent`, `PI.*` codes
+4. Which named audiences fit? `personas`
+5. What kind of page is it? `content_context`
+
+`labels_for(result)` turns the codes in questions 2 and 3 into names you can show to a person.
+
+## API surface
+
+```python
+client.segment(url, structured=True)
+client.categorize(url, confidence=True, root_fallback=False)
+client.categorize_text(text, confidence=True)
+client.segment_many(urls, workers=8)
+CookielessAudiences.vocabularies()
+```
+
+`segment_many` returns a dict of url to result. A URL that failed holds its exception instead, so one bad page never stops a batch.
+
+## Errors
+
+```python
+from cookielessaudiences import CookielessAudiencesError
+
+try:
+    client.segment(url)
+except CookielessAudiencesError as exc:
+    print(exc.status, exc.body)
+```
+
+The HTTP layer is plain; the signal lives in `status` inside the JSON. 401 is a bad key, 403 means the key is inactive or credits are gone, 410 and 411 mean the page could not be read.
+
+## Example: audience report for a media plan
+
+```python
+import csv
+from cookielessaudiences import CookielessAudiences, labels_for
+
+client = CookielessAudiences("YOUR_API_KEY")
+sites = [line.strip() for line in open("sites.txt") if line.strip()]
+results = client.segment_many(sites, workers=10)
+
+with open("plan.csv", "w", newline="") as fh:
+    out = csv.writer(fh)
+    out.writerow(["site", "type", "age", "income", "top_interest", "top_intent"])
+    for site, res in results.items():
+        if isinstance(res, Exception):
+            out.writerow([site, "error", "", "", "", ""])
+            continue
+        names = labels_for(res)
+        out.writerow([
+            site,
+            res.get("audience_type"),
+            "|".join(res["demographics"].get("age_bracket", [])),
+            res["demographics"].get("income_level"),
+            (names["interests"] or [""])[0],
+            (names["purchase_intent"] or [""])[0],
+        ])
+```
+
+This is the shape most [website audience demographics](https://www.cookielessaudiences.com/features/website-audience-demographics.php) work takes: many sites in, one row per site out.
+
+## Example: pandas enrichment
+
+```python
+import pandas as pd
+
+df = pd.read_csv("accounts.csv")           # column: url
+found = client.segment_many(df["url"].tolist())
+df["audience_type"] = [r.get("audience_type") if isinstance(r, dict) else None for r in found.values()]
+df["seniority"] = [
+    ",".join(r.get("b2b", {}).get("seniority", [])) if isinstance(r, dict) else None
+    for r in found.values()
+]
+```
+
+## Example: IAB categories for a text snippet
+
+```python
+snippet = "Best budget laptops for students heading to university"
+cats = client.categorize_text(snippet)
+for name, score in cats["iab_classification"]:
+    print(name, score)
+```
+
+## Frequently asked
+
+**Can I get the full word list for a field?** Yes. `CookielessAudiences.vocabularies()` returns every enumerated value and needs no key.
+
+**What about scale?** The service accepts up to 50 parallel threads by default, about 270 URLs a minute.
+
+**Which fields are free text?** None in the structured shape. Small fields are closed lists; open-ended signals are mapped to canonical codes or dropped.
+
+## Package notes
+
+MIT licensed. Questions go to info@alpha-quantum.com. Version 1.0.0.

cookielessaudiences-1.0.0/cookielessaudiences/__init__.py

@@ -0,0 +1,4 @@
+from .client import CookielessAudiences, CookielessAudiencesError, labels_for
+
+__all__ = ["CookielessAudiences", "CookielessAudiencesError", "labels_for"]
+__version__ = "1.0.0"

cookielessaudiences-1.0.0/cookielessaudiences/client.py

@@ -0,0 +1,103 @@
+"""Client for the Cookieless Audiences API (https://www.cookielessaudiences.com)."""
+from typing import Any, Dict, Iterable, List, Optional
+
+import requests
+
+__version__ = "1.0.0"
+BASE = "https://www.cookielessaudiences.com"
+
+STATUS_TEXT = {
+    400: "Bad request, check the parameters",
+    401: "Invalid API key",
+    403: "Key not active or monthly credits used up",
+    407: "Missing data_type, must be 'url' or 'text'",
+    410: "Not enough content in the page or text",
+    411: "The URL content could not be fetched",
+    500: "General error, check the request or contact support",
+}
+
+
+class CookielessAudiencesError(Exception):
+    """Raised when the JSON body carries a status other than 200."""
+
+    def __init__(self, status: int, message: str, body: Optional[dict] = None):
+        super().__init__("[%s] %s" % (status, message))
+        self.status = status
+        self.body = body or {}
+
+
+class CookielessAudiences:
+    def __init__(self, api_key: str, timeout: float = 120.0, session: Optional[requests.Session] = None):
+        if not api_key:
+            raise ValueError("An API key is required")
+        self.api_key = api_key
+        self.timeout = timeout
+        self.session = session or requests.Session()
+        self.session.headers["User-Agent"] = "cookielessaudiences-python/%s (+https://www.cookielessaudiences.com)" % __version__
+
+    def _post(self, path: str, form: Dict[str, str]) -> Dict[str, Any]:
+        resp = self.session.post(BASE + path, data=form, timeout=self.timeout)
+        try:
+            body = resp.json()
+        except ValueError:
+            raise CookielessAudiencesError(resp.status_code, "Response was not JSON")
+        status = body.get("status", 200) if isinstance(body, dict) else 200
+        if status != 200:
+            raise CookielessAudiencesError(status, STATUS_TEXT.get(status, "API error"), body)
+        return body
+
+    def segment(self, url: str, structured: bool = True) -> Dict[str, Any]:
+        """Page-level audience segmentation. structured=False returns the legacy free-text shape."""
+        form = {"query": url, "api_key": self.api_key}
+        if structured:
+            form["format"] = "structured"
+        return self._post("/api/audience/segment.php", form)
+
+    def categorize(self, url: str, confidence: bool = True, root_fallback: bool = False) -> Dict[str, Any]:
+        """IAB content categorization (v3 and v2) of a URL."""
+        form = {"query": url, "api_key": self.api_key, "data_type": "url"}
+        if confidence:
+            form["confidence"] = "1"
+        if root_fallback:
+            form["use_domain_as_basis_of_categorization_for_insufficient_subdomain_content"] = "1"
+        return self._post("/api/iab/iab_web_content_filtering.php", form)
+
+    def categorize_text(self, text: str, confidence: bool = True) -> Dict[str, Any]:
+        """IAB content categorization of plain text."""
+        form = {"query": text, "api_key": self.api_key, "data_type": "text"}
+        if confidence:
+            form["confidence"] = "1"
+        return self._post("/api/iab/iab_content_filtering.php", form)
+
+    def segment_many(self, urls: Iterable[str], workers: int = 8, structured: bool = True) -> Dict[str, Any]:
+        """Segment several URLs in parallel. Returns {url: result or CookielessAudiencesError}."""
+        from concurrent.futures import ThreadPoolExecutor
+
+        urls = list(urls)
+
+        def one(u: str):
+            try:
+                return self.segment(u, structured=structured)
+            except Exception as exc:  # keep the batch going
+                return exc
+
+        with ThreadPoolExecutor(max_workers=max(1, workers)) as pool:
+            return dict(zip(urls, pool.map(one, urls)))
+
+    @staticmethod
+    def vocabularies(timeout: float = 60.0) -> Dict[str, Any]:
+        """Controlled vocabularies, public, no key required."""
+        resp = requests.get(BASE + "/api/audience/filters.php", timeout=timeout)
+        resp.raise_for_status()
+        return resp.json()
+
+
+def labels_for(result: Dict[str, Any]) -> Dict[str, List[str]]:
+    """Readable labels for the INT.* and PI.* codes of a structured response."""
+    names = result.get("labels", {})
+    out = {}
+    for group in ("interests", "purchase_intent"):
+        block = result.get(group) or {}
+        codes = list(block.get("tier1", [])) + list(block.get("tier2", [])) + list(block.get("codes", []))
+        out[group] = [names.get(c, c) for c in codes]
+    return out

cookielessaudiences-1.0.0/cookielessaudiences.egg-info/PKG-INFO

@@ -0,0 +1,155 @@
+Metadata-Version: 2.1
+Name: cookielessaudiences
+Version: 1.0.0
+Summary: Python client for the Cookieless Audiences API: page-level audience segmentation (demographics, interests, purchase intent, B2B firmographics, personas) and IAB content categorization for any URL, with no cookies and no PII.
+Home-page: https://www.cookielessaudiences.com
+Author: Alpha Quantum
+Author-email: info@alpha-quantum.com
+License: MIT
+Project-URL: Homepage, https://www.cookielessaudiences.com
+Project-URL: Documentation, https://www.cookielessaudiences.com/api.php
+Project-URL: Source, https://github.com/explainableaixai/cookielessaudiences
+Project-URL: Mirror, https://gitlab.com/url-classifications/cookielessaudiences
+Project-URL: Tracker, https://www.cookielessaudiences.com/contact.php
+Project-URL: Pricing, https://www.cookielessaudiences.com/pricing.php
+Description: # cookielessaudiences (Python)
+        
+        Cookieless audience data for a URL, as a Python call. You pass a page and receive demographics, interests, purchase intent, B2B firmographics and personas, with no cookies and no personal data involved.
+        
+        Built on `requests`, works on Python 3.7 and later.
+        
+        ## Setup
+        
+        ```bash
+        pip install cookielessaudiences
+        ```
+        
+        An API key comes with any plan. If you are still comparing options, read how [cookieless audience segmentation](https://www.cookielessaudiences.com/features/cookieless-audience-segmentation.php) works before you buy.
+        
+        ## Quick start
+        
+        ```python
+        from cookielessaudiences import CookielessAudiences, labels_for
+        
+        client = CookielessAudiences("YOUR_API_KEY")
+        result = client.segment("https://example.com/blog")
+        
+        print(result["audience_type"])
+        print(result["demographics"]["income_level"])
+        print(labels_for(result))
+        ```
+        
+        ## Reading the response
+        
+        Think of the structured result as five questions about the reader of a page:
+        
+        1. Who are they? `demographics` and `b2b`
+        2. What do they like? `interests`, two tiers of `INT.*` codes
+        3. What might they buy? `purchase_intent`, `PI.*` codes
+        4. Which named audiences fit? `personas`
+        5. What kind of page is it? `content_context`
+        
+        `labels_for(result)` turns the codes in questions 2 and 3 into names you can show to a person.
+        
+        ## API surface
+        
+        ```python
+        client.segment(url, structured=True)
+        client.categorize(url, confidence=True, root_fallback=False)
+        client.categorize_text(text, confidence=True)
+        client.segment_many(urls, workers=8)
+        CookielessAudiences.vocabularies()
+        ```
+        
+        `segment_many` returns a dict of url to result. A URL that failed holds its exception instead, so one bad page never stops a batch.
+        
+        ## Errors
+        
+        ```python
+        from cookielessaudiences import CookielessAudiencesError
+        
+        try:
+            client.segment(url)
+        except CookielessAudiencesError as exc:
+            print(exc.status, exc.body)
+        ```
+        
+        The HTTP layer is plain; the signal lives in `status` inside the JSON. 401 is a bad key, 403 means the key is inactive or credits are gone, 410 and 411 mean the page could not be read.
+        
+        ## Example: audience report for a media plan
+        
+        ```python
+        import csv
+        from cookielessaudiences import CookielessAudiences, labels_for
+        
+        client = CookielessAudiences("YOUR_API_KEY")
+        sites = [line.strip() for line in open("sites.txt") if line.strip()]
+        results = client.segment_many(sites, workers=10)
+        
+        with open("plan.csv", "w", newline="") as fh:
+            out = csv.writer(fh)
+            out.writerow(["site", "type", "age", "income", "top_interest", "top_intent"])
+            for site, res in results.items():
+                if isinstance(res, Exception):
+                    out.writerow([site, "error", "", "", "", ""])
+                    continue
+                names = labels_for(res)
+                out.writerow([
+                    site,
+                    res.get("audience_type"),
+                    "|".join(res["demographics"].get("age_bracket", [])),
+                    res["demographics"].get("income_level"),
+                    (names["interests"] or [""])[0],
+                    (names["purchase_intent"] or [""])[0],
+                ])
+        ```
+        
+        This is the shape most [website audience demographics](https://www.cookielessaudiences.com/features/website-audience-demographics.php) work takes: many sites in, one row per site out.
+        
+        ## Example: pandas enrichment
+        
+        ```python
+        import pandas as pd
+        
+        df = pd.read_csv("accounts.csv")           # column: url
+        found = client.segment_many(df["url"].tolist())
+        df["audience_type"] = [r.get("audience_type") if isinstance(r, dict) else None for r in found.values()]
+        df["seniority"] = [
+            ",".join(r.get("b2b", {}).get("seniority", [])) if isinstance(r, dict) else None
+            for r in found.values()
+        ]
+        ```
+        
+        ## Example: IAB categories for a text snippet
+        
+        ```python
+        snippet = "Best budget laptops for students heading to university"
+        cats = client.categorize_text(snippet)
+        for name, score in cats["iab_classification"]:
+            print(name, score)
+        ```
+        
+        ## Frequently asked
+        
+        **Can I get the full word list for a field?** Yes. `CookielessAudiences.vocabularies()` returns every enumerated value and needs no key.
+        
+        **What about scale?** The service accepts up to 50 parallel threads by default, about 270 URLs a minute.
+        
+        **Which fields are free text?** None in the structured shape. Small fields are closed lists; open-ended signals are mapped to canonical codes or dropped.
+        
+        ## Package notes
+        
+        MIT licensed. Questions go to info@alpha-quantum.com. Version 1.0.0.
+        
+Keywords: cookieless,audience segmentation,iab audience taxonomy,iab categorization,contextual targeting,seller defined audiences,purchase intent,adtech,media planning,inventory curation,audience data,privacy-safe advertising,domain audience data
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown

cookielessaudiences-1.0.0/cookielessaudiences.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+MANIFEST.in
+README.md
+setup.py
+cookielessaudiences/__init__.py
+cookielessaudiences/client.py
+cookielessaudiences.egg-info/PKG-INFO
+cookielessaudiences.egg-info/SOURCES.txt
+cookielessaudiences.egg-info/dependency_links.txt
+cookielessaudiences.egg-info/requires.txt
+cookielessaudiences.egg-info/top_level.txt

cookielessaudiences-1.0.0/cookielessaudiences.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cookielessaudiences-1.0.0/cookielessaudiences.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.20.0

cookielessaudiences-1.0.0/cookielessaudiences.egg-info/top_level.txt

@@ -0,0 +1 @@
+cookielessaudiences

cookielessaudiences-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

cookielessaudiences-1.0.0/setup.py

@@ -0,0 +1,40 @@
+import pathlib
+from setuptools import setup, find_packages
+
+README = (pathlib.Path(__file__).parent / "README.md").read_text(encoding="utf-8")
+
+setup(
+    name="cookielessaudiences",
+    version="1.0.0",
+    description="Python client for the Cookieless Audiences API: page-level audience segmentation (demographics, interests, purchase intent, B2B firmographics, personas) and IAB content categorization for any URL, with no cookies and no PII.",
+    long_description=README,
+    long_description_content_type="text/markdown",
+    author="Alpha Quantum",
+    author_email="info@alpha-quantum.com",
+    url="https://www.cookielessaudiences.com",
+    project_urls={
+        "Homepage": "https://www.cookielessaudiences.com",
+        "Documentation": "https://www.cookielessaudiences.com/api.php",
+        "Source": "https://github.com/explainableaixai/cookielessaudiences",
+        "Mirror": "https://gitlab.com/url-classifications/cookielessaudiences",
+        "Tracker": "https://www.cookielessaudiences.com/contact.php",
+        "Pricing": "https://www.cookielessaudiences.com/pricing.php",
+    },
+    license="MIT",
+    packages=find_packages(exclude=("tests", "test")),
+    python_requires=">=3.7",
+    install_requires=["requests>=2.20.0"],
+    keywords=["cookieless", "audience segmentation", "iab audience taxonomy", "iab categorization", "contextual targeting",
+              "seller defined audiences", "purchase intent", "adtech", "media planning", "inventory curation",
+              "audience data", "privacy-safe advertising", "domain audience data"],
+    classifiers=[
+        "Development Status :: 5 - Production/Stable",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.12",
+        "Topic :: Internet :: WWW/HTTP",
+        "Topic :: Scientific/Engineering :: Information Analysis",
+    ],
+)