gcrawl-sdk 0.1.0__tar.gz

gcrawl_sdk-0.1.0/LICENSE

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

gcrawl_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.4
+Name: gcrawl-sdk
+Version: 0.1.0
+Summary: Python SDK for GCrawl — Scrape, crawl, screenshot, links, and search with ease
+Author-email: Ramkumar <ramkumarlpm4@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Gramosoft
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/GramosoftAI/GCrawl
+Keywords: crawl,scraper,screenshot,links,gcrawl,ai
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Dynamic: license-file
+
+# gcrawl-sdk
+
+Official Python SDK for GCrawl — Scrape, crawl, screenshot, fetch links, and search web pages with ease.
+
+## Installation
+
+```bash
+pip install gcrawl-sdk
+```
+
+## Quick Start
+
+```python
+from gcrawl_sdk import GcrawlClient, ScrapeOptions
+
+client = GcrawlClient(api_key="your-api-key")
+
+# Scrape a website (synchronous polling)
+result = client.scrape(
+    url="https://gramosoft.tech",
+    options=ScrapeOptions(markdown_enabled=True, screenshot_enabled=True),
+    wait=True
+)
+print("Scraped Markdown:", result.markdown)
+print("Screenshot URL:", result.screenshot_url)
+
+# Search web synchronously
+search_res = client.search("gramosoft", limit=5, geo="IN")
+for res in search_res.results:
+    print(res.position, res.title, res.url)
+```
+
+## API Key
+
+Set your API key as an environment variable:
+```bash
+export GCRAWL_API_KEY="your-api-key"
+```
+
+Or pass it directly to the client:
+```python
+client = GcrawlClient(api_key="your-api-key")
+```

gcrawl_sdk-0.1.0/README.md

@@ -0,0 +1,43 @@
+# gcrawl-sdk
+
+Official Python SDK for GCrawl — Scrape, crawl, screenshot, fetch links, and search web pages with ease.
+
+## Installation
+
+```bash
+pip install gcrawl-sdk
+```
+
+## Quick Start
+
+```python
+from gcrawl_sdk import GcrawlClient, ScrapeOptions
+
+client = GcrawlClient(api_key="your-api-key")
+
+# Scrape a website (synchronous polling)
+result = client.scrape(
+    url="https://gramosoft.tech",
+    options=ScrapeOptions(markdown_enabled=True, screenshot_enabled=True),
+    wait=True
+)
+print("Scraped Markdown:", result.markdown)
+print("Screenshot URL:", result.screenshot_url)
+
+# Search web synchronously
+search_res = client.search("gramosoft", limit=5, geo="IN")
+for res in search_res.results:
+    print(res.position, res.title, res.url)
+```
+
+## API Key
+
+Set your API key as an environment variable:
+```bash
+export GCRAWL_API_KEY="your-api-key"
+```
+
+Or pass it directly to the client:
+```python
+client = GcrawlClient(api_key="your-api-key")
+```

gcrawl_sdk-0.1.0/gcrawl_sdk/__init__.py

@@ -0,0 +1,15 @@
+from .client import GcrawlClient
+from .scrape_options import ScrapeOptions
+from .crawl_options import CrawlOptions
+from .screenshot_options import ScreenshotOptions
+from .links_options import LinksOptions
+from .search_options import SearchOptions
+from .task_init_result import GcrawlTaskInitResult
+from .task_result import GcrawlTaskResult, GcrawlPageResult
+from .search_result import SearchResult
+from .exceptions import (
+    GcrawlAPIError,
+    GcrawlTimeoutError,
+    GcrawlValidationError,
+    GcrawlFileError,
+)

gcrawl_sdk-0.1.0/gcrawl_sdk/client.py

@@ -0,0 +1,336 @@
+import requests
+import time
+import os
+from .exceptions import GcrawlAPIError, GcrawlTimeoutError, GcrawlValidationError
+from .task_init_result import GcrawlTaskInitResult
+from .task_result import GcrawlTaskResult
+from .search_result import SearchResult
+from .scrape_options import ScrapeOptions
+from .crawl_options import CrawlOptions
+from .screenshot_options import ScreenshotOptions
+from .links_options import LinksOptions
+from .search_options import SearchOptions
+
+class GcrawlClient:
+    def __init__(self, api_key=None, base_url=None, timeout=300):
+        self.api_key = api_key or os.getenv("GCRAWL_API_KEY")
+        if not self.api_key:
+            raise GcrawlValidationError("API key required")
+
+        self.base_url = base_url or "https://gcrawlai.com/gc"
+        self.timeout = timeout
+
+    def _get_headers(self):
+        return {
+            "Content-Type": "application/json",
+            "X-API-Key": self.api_key
+        }
+
+    def scrape(self, url, options=None, formats=None, geo="default",
+               clean=False, remove_external_links=False, relative_to_absolute_links=True,
+               remove_data_images=False, ignore_tags=None,
+               full_page=False, format="png", quality=90, js_render=False,
+               render_timeout=30000, auto_scroll=True, scroll_delay=500, max_scrolls=2,
+               wait=False, poll_interval=2, timeout=300):
+        if options is not None:
+            if hasattr(options, "to_dict"):
+                payload = options.to_dict()
+            elif isinstance(options, dict):
+                payload = options.copy()
+            else:
+                raise GcrawlValidationError("options must be a ScrapeOptions instance or a dict")
+        else:
+            formats_list = formats if formats is not None else ["markdown"]
+            ignore_tags_list = ignore_tags if ignore_tags is not None else []
+            
+            payload = {
+                "proxy": {
+                    "geo": geo
+                },
+                "markdown": {
+                    "enabled": "markdown" in formats_list,
+                    "clean": clean
+                },
+                "html": {
+                    "enabled": "html" in formats_list,
+                    "clean": clean,
+                    "remove_external_links": remove_external_links,
+                    "relative_to_absolute_links": relative_to_absolute_links,
+                    "remove_data_images": remove_data_images,
+                    "ignore_tags": ignore_tags_list
+                },
+                "screenshot": {
+                    "enabled": "screenshot" in formats_list,
+                    "full_page": full_page,
+                    "format": format,
+                    "quality": quality,
+                    "js_render": js_render,
+                    "render_timeout": render_timeout,
+                    "auto_scroll": auto_scroll,
+                    "scroll_delay": scroll_delay,
+                    "max_scrolls": max_scrolls
+                },
+                "seo": {
+                    "enabled": "seo" in formats_list
+                },
+                "images": {
+                    "enabled": "images" in formats_list
+                }
+            }
+        
+        payload["url"] = url
+
+        try:
+            response = requests.post(
+                f"{self.base_url}/api/v1/scrape",
+                json=payload,
+                headers=self._get_headers(),
+                timeout=self.timeout
+            )
+        except requests.exceptions.Timeout:
+            raise GcrawlTimeoutError("Scrape request timed out")
+
+        if response.status_code != 200:
+            raise GcrawlAPIError(response.status_code, response.text)
+
+        init_result = GcrawlTaskInitResult(response.json())
+        
+        if wait and init_result.crawl_id:
+            return self._poll_task_results(init_result.crawl_id, poll_interval, timeout)
+            
+        return init_result
+
+    def crawl(self, url, options=None, limit=10, formats=None, geo="default",
+              same_domain_only=True, include_subdomains=True,
+              clean=False, remove_external_links=False, relative_to_absolute_links=True,
+              remove_data_images=False, ignore_tags=None,
+              full_page=False, format="png", quality=90, js_render=False,
+              render_timeout=30000, auto_scroll=True, scroll_delay=500, max_scrolls=2,
+              wait=False, poll_interval=2, timeout=300):
+        if options is not None:
+            if hasattr(options, "to_dict"):
+                payload = options.to_dict()
+            elif isinstance(options, dict):
+                payload = options.copy()
+            else:
+                raise GcrawlValidationError("options must be a CrawlOptions instance or a dict")
+        else:
+            formats_list = formats if formats is not None else ["markdown"]
+            ignore_tags_list = ignore_tags if ignore_tags is not None else []
+            
+            payload = {
+                "crawl": {
+                    "max_pages": limit,
+                    "same_domain_only": same_domain_only,
+                    "include_subdomains": include_subdomains
+                },
+                "proxy": {
+                    "geo": geo
+                },
+                "markdown": {
+                    "enabled": "markdown" in formats_list,
+                    "clean": clean
+                },
+                "html": {
+                    "enabled": "html" in formats_list,
+                    "clean": clean,
+                    "remove_external_links": remove_external_links,
+                    "relative_to_absolute_links": relative_to_absolute_links,
+                    "remove_data_images": remove_data_images,
+                    "ignore_tags": ignore_tags_list
+                },
+                "screenshot": {
+                    "enabled": "screenshot" in formats_list,
+                    "full_page": full_page,
+                    "format": format,
+                    "quality": quality,
+                    "js_render": js_render,
+                    "render_timeout": render_timeout,
+                    "auto_scroll": auto_scroll,
+                    "scroll_delay": scroll_delay,
+                    "max_scrolls": max_scrolls
+                },
+                "seo": {
+                    "enabled": "seo" in formats_list
+                },
+                "images": {
+                    "enabled": "images" in formats_list
+                }
+            }
+        
+        payload["url"] = url
+
+        try:
+            response = requests.post(
+                f"{self.base_url}/api/v1/crawl",
+                json=payload,
+                headers=self._get_headers(),
+                timeout=self.timeout
+            )
+        except requests.exceptions.Timeout:
+            raise GcrawlTimeoutError("Crawl request timed out")
+
+        if response.status_code != 200:
+            raise GcrawlAPIError(response.status_code, response.text)
+
+        init_result = GcrawlTaskInitResult(response.json())
+        
+        if wait and init_result.crawl_id:
+            return self._poll_task_results(init_result.crawl_id, poll_interval, timeout)
+            
+        return init_result
+
+    def screenshot(self, url, options=None, geo="default",
+                   full_page=True, format="png", quality=90, js_render=True,
+                   render_timeout=30000, auto_scroll=True, scroll_delay=500, max_scrolls=2,
+                   wait=False, poll_interval=2, timeout=300):
+        if options is not None:
+            if hasattr(options, "to_dict"):
+                payload = options.to_dict()
+            elif isinstance(options, dict):
+                payload = options.copy()
+            else:
+                raise GcrawlValidationError("options must be a ScreenshotOptions instance or a dict")
+        else:
+            payload = {
+                "screenshot": {
+                    "enabled": True,
+                    "full_page": full_page,
+                    "format": format,
+                    "quality": quality,
+                    "js_render": js_render,
+                    "render_timeout": render_timeout,
+                    "auto_scroll": auto_scroll,
+                    "scroll_delay": scroll_delay,
+                    "max_scrolls": max_scrolls
+                }
+            }
+            if geo:
+                payload["proxy"] = {"geo": geo}
+        
+        payload["url"] = url
+
+        try:
+            response = requests.post(
+                f"{self.base_url}/api/v1/screenshot",
+                json=payload,
+                headers=self._get_headers(),
+                timeout=self.timeout
+            )
+        except requests.exceptions.Timeout:
+            raise GcrawlTimeoutError("Screenshot request timed out")
+
+        if response.status_code != 200:
+            raise GcrawlAPIError(response.status_code, response.text)
+
+        init_result = GcrawlTaskInitResult(response.json())
+        
+        if wait and init_result.crawl_id:
+            return self._poll_task_results(init_result.crawl_id, poll_interval, timeout)
+            
+        return init_result
+
+    def links(self, url, options=None, limit=10, same_domain_only=True, include_subdomains=True, geo="default",
+              wait=False, poll_interval=2, timeout=300):
+        if options is not None:
+            if hasattr(options, "to_dict"):
+                payload = options.to_dict()
+            elif isinstance(options, dict):
+                payload = options.copy()
+            else:
+                raise GcrawlValidationError("options must be a LinksOptions instance or a dict")
+        else:
+            payload = {
+                "links": {
+                    "limit": limit,
+                    "same_domain_only": same_domain_only,
+                    "include_subdomains": include_subdomains
+                }
+            }
+            if geo:
+                payload["proxy"] = {"geo": geo}
+        
+        payload["url"] = url
+
+        try:
+            response = requests.post(
+                f"{self.base_url}/api/v1/links",
+                json=payload,
+                headers=self._get_headers(),
+                timeout=self.timeout
+            )
+        except requests.exceptions.Timeout:
+            raise GcrawlTimeoutError("Links request timed out")
+
+        if response.status_code != 200:
+            raise GcrawlAPIError(response.status_code, response.text)
+
+        init_result = GcrawlTaskInitResult(response.json())
+        
+        if wait and init_result.crawl_id:
+            return self._poll_task_results(init_result.crawl_id, poll_interval, timeout)
+            
+        return init_result
+
+    def search(self, query, options=None, limit=10, geo="IN"):
+        if options is not None:
+            if hasattr(options, "to_dict"):
+                payload = options.to_dict()
+            elif isinstance(options, dict):
+                payload = options.copy()
+            else:
+                raise GcrawlValidationError("options must be a SearchOptions instance or a dict")
+        else:
+            payload = {
+                "limit": limit,
+                "geo": geo
+            }
+            
+        payload["query"] = query
+
+        try:
+            response = requests.post(
+                f"{self.base_url}/api/v1/search",
+                json=payload,
+                headers=self._get_headers(),
+                timeout=self.timeout
+            )
+        except requests.exceptions.Timeout:
+            raise GcrawlTimeoutError("Search request timed out")
+
+        if response.status_code != 200:
+            raise GcrawlAPIError(response.status_code, response.text)
+
+        return SearchResult(response.json())
+
+    def get_results(self, crawl_id):
+        headers = {
+            "accept": "application/json",
+            "X-API-Key": self.api_key
+        }
+        
+        try:
+            response = requests.get(
+                f"{self.base_url}/crawler/results/{crawl_id}",
+                headers=headers,
+                timeout=self.timeout
+            )
+        except requests.exceptions.Timeout:
+            raise GcrawlTimeoutError("Get results request timed out")
+
+        if response.status_code != 200:
+            raise GcrawlAPIError(response.status_code, response.text)
+
+        return GcrawlTaskResult(response.json())
+
+    def _poll_task_results(self, crawl_id, poll_interval=2, timeout=600):
+        start_time = time.time()
+        while True:
+            result = self.get_results(crawl_id)
+            if result.status == "completed" or result.status == "failed" or result.is_completed or result.is_failed:
+                return result
+            
+            if time.time() - start_time > timeout:
+                raise GcrawlTimeoutError(f"Polling task {crawl_id} timed out after {timeout} seconds")
+            
+            time.sleep(poll_interval)

gcrawl_sdk-0.1.0/gcrawl_sdk/crawl_options.py

@@ -0,0 +1,94 @@
+class CrawlOptions:
+    def __init__(self,
+                 max_pages=10,
+                 same_domain_only=True,
+                 include_subdomains=True,
+                 proxy_geo="default",
+                 markdown_enabled=True,
+                 markdown_clean=False,
+                 html_enabled=False,
+                 html_clean=False,
+                 remove_external_links=False,
+                 relative_to_absolute_links=True,
+                 remove_data_images=False,
+                 ignore_tags=[],
+                 screenshot_enabled=False,
+                 screenshot_full_page=False,
+                 screenshot_format="png",
+                 screenshot_quality=90,
+                 js_render=False,
+                 render_timeout=30000,
+                 auto_scroll=True,
+                 scroll_delay=500,
+                 max_scrolls=2,
+                 seo_enabled=False,
+                 images_enabled=False):
+        self.max_pages = max_pages
+        self.same_domain_only = same_domain_only
+        self.include_subdomains = include_subdomains
+        self.proxy_geo = proxy_geo
+        self.markdown_enabled = markdown_enabled
+        self.markdown_clean = markdown_clean
+        self.html_enabled = html_enabled
+        self.html_clean = html_clean
+        self.remove_external_links = remove_external_links
+        self.relative_to_absolute_links = relative_to_absolute_links
+        self.remove_data_images = remove_data_images
+        self.ignore_tags = ignore_tags or []
+        self.screenshot_enabled = screenshot_enabled
+        self.screenshot_full_page = screenshot_full_page
+        self.screenshot_format = screenshot_format
+        self.screenshot_quality = screenshot_quality
+        self.js_render = js_render
+        self.render_timeout = render_timeout
+        self.auto_scroll = auto_scroll
+        self.scroll_delay = scroll_delay
+        self.max_scrolls = max_scrolls
+        self.seo_enabled = seo_enabled
+        self.images_enabled = images_enabled
+
+    def to_dict(self):
+        payload = {}
+        payload["crawl"] = {
+            "max_pages": self.max_pages,
+            "same_domain_only": self.same_domain_only,
+            "include_subdomains": self.include_subdomains
+        }
+        
+        if self.proxy_geo:
+            payload["proxy"] = {"geo": self.proxy_geo}
+            
+        payload["markdown"] = {
+            "enabled": self.markdown_enabled,
+            "clean": self.markdown_clean
+        }
+        
+        payload["html"] = {
+            "enabled": self.html_enabled,
+            "clean": self.html_clean,
+            "remove_external_links": self.remove_external_links,
+            "relative_to_absolute_links": self.relative_to_absolute_links,
+            "remove_data_images": self.remove_data_images,
+            "ignore_tags": self.ignore_tags
+        }
+        
+        payload["screenshot"] = {
+            "enabled": self.screenshot_enabled,
+            "full_page": self.screenshot_full_page,
+            "format": self.screenshot_format,
+            "quality": self.screenshot_quality,
+            "js_render": self.js_render,
+            "render_timeout": self.render_timeout,
+            "auto_scroll": self.auto_scroll,
+            "scroll_delay": self.scroll_delay,
+            "max_scrolls": self.max_scrolls
+        }
+        
+        payload["seo"] = {
+            "enabled": self.seo_enabled
+        }
+        
+        payload["images"] = {
+            "enabled": self.images_enabled
+        }
+        return payload

gcrawl_sdk-0.1.0/gcrawl_sdk/exceptions.py

@@ -0,0 +1,14 @@
+class GcrawlAPIError(Exception):
+    def __init__(self, status_code, response_data):
+        self.status_code = status_code
+        self.response_data = response_data
+        super().__init__(f"GCrawl API error {status_code}: {response_data}")
+
+class GcrawlTimeoutError(Exception):
+    pass
+
+class GcrawlFileError(Exception):
+    pass
+
+class GcrawlValidationError(Exception):
+    pass

gcrawl_sdk-0.1.0/gcrawl_sdk/links_options.py

@@ -0,0 +1,22 @@
+class LinksOptions:
+    def __init__(self,
+                 limit=10,
+                 same_domain_only=True,
+                 include_subdomains=True,
+                 proxy_geo="default"):
+        self.limit = limit
+        self.same_domain_only = same_domain_only
+        self.include_subdomains = include_subdomains
+        self.proxy_geo = proxy_geo
+
+    def to_dict(self):
+        payload = {
+            "links": {
+                "limit": self.limit,
+                "same_domain_only": self.same_domain_only,
+                "include_subdomains": self.include_subdomains
+            }
+        }
+        if self.proxy_geo:
+            payload["proxy"] = {"geo": self.proxy_geo}
+        return payload

gcrawl_sdk-0.1.0/gcrawl_sdk/scrape_options.py

@@ -0,0 +1,82 @@
+class ScrapeOptions:
+    def __init__(self,
+                 proxy_geo="default",
+                 markdown_enabled=True,
+                 markdown_clean=False,
+                 html_enabled=False,
+                 html_clean=False,
+                 remove_external_links=False,
+                 relative_to_absolute_links=True,
+                 remove_data_images=False,
+                 ignore_tags=[],
+                 screenshot_enabled=False,
+                 screenshot_full_page=True,
+                 screenshot_format="png",
+                 screenshot_quality=90,
+                 js_render=False,
+                 render_timeout=30000,
+                 auto_scroll=True,
+                 scroll_delay=1500,
+                 max_scrolls=5,
+                 seo_enabled=True,
+                 images_enabled=True):
+        self.proxy_geo = proxy_geo
+        self.markdown_enabled = markdown_enabled
+        self.markdown_clean = markdown_clean
+        self.html_enabled = html_enabled
+        self.html_clean = html_clean
+        self.remove_external_links = remove_external_links
+        self.relative_to_absolute_links = relative_to_absolute_links
+        self.remove_data_images = remove_data_images
+        self.ignore_tags = ignore_tags or []
+        self.screenshot_enabled = screenshot_enabled
+        self.screenshot_full_page = screenshot_full_page
+        self.screenshot_format = screenshot_format
+        self.screenshot_quality = screenshot_quality
+        self.js_render = js_render
+        self.render_timeout = render_timeout
+        self.auto_scroll = auto_scroll
+        self.scroll_delay = scroll_delay
+        self.max_scrolls = max_scrolls
+        self.seo_enabled = seo_enabled
+        self.images_enabled = images_enabled
+
+    def to_dict(self):
+        payload = {}
+        if self.proxy_geo:
+            payload["proxy"] = {"geo": self.proxy_geo}
+        
+        payload["markdown"] = {
+            "enabled": self.markdown_enabled,
+            "clean": self.markdown_clean
+        }
+        
+        payload["html"] = {
+            "enabled": self.html_enabled,
+            "clean": self.html_clean,
+            "remove_external_links": self.remove_external_links,
+            "relative_to_absolute_links": self.relative_to_absolute_links,
+            "remove_data_images": self.remove_data_images,
+            "ignore_tags": self.ignore_tags
+        }
+        
+        payload["screenshot"] = {
+            "enabled": self.screenshot_enabled,
+            "full_page": self.screenshot_full_page,
+            "format": self.screenshot_format,
+            "quality": self.screenshot_quality,
+            "js_render": self.js_render,
+            "render_timeout": self.render_timeout,
+            "auto_scroll": self.auto_scroll,
+            "scroll_delay": self.scroll_delay,
+            "max_scrolls": self.max_scrolls
+        }
+        
+        payload["seo"] = {
+            "enabled": self.seo_enabled
+        }
+        
+        payload["images"] = {
+            "enabled": self.images_enabled
+        }
+        return payload

gcrawl_sdk-0.1.0/gcrawl_sdk/screenshot_options.py

@@ -0,0 +1,40 @@
+class ScreenshotOptions:
+    def __init__(self,
+                 enabled=True,
+                 full_page=True,
+                 format="png",
+                 quality=90,
+                 js_render=True,
+                 render_timeout=30000,
+                 auto_scroll=True,
+                 scroll_delay=500,
+                 max_scrolls=2,
+                 proxy_geo="default"):
+        self.enabled = enabled
+        self.full_page = full_page
+        self.format = format
+        self.quality = quality
+        self.js_render = js_render
+        self.render_timeout = render_timeout
+        self.auto_scroll = auto_scroll
+        self.scroll_delay = scroll_delay
+        self.max_scrolls = max_scrolls
+        self.proxy_geo = proxy_geo
+
+    def to_dict(self):
+        payload = {
+            "screenshot": {
+                "enabled": self.enabled,
+                "full_page": self.full_page,
+                "format": self.format,
+                "quality": self.quality,
+                "js_render": self.js_render,
+                "render_timeout": self.render_timeout,
+                "auto_scroll": self.auto_scroll,
+                "scroll_delay": self.scroll_delay,
+                "max_scrolls": self.max_scrolls
+            }
+        }
+        if self.proxy_geo:
+            payload["proxy"] = {"geo": self.proxy_geo}
+        return payload

gcrawl_sdk-0.1.0/gcrawl_sdk/search_options.py

@@ -0,0 +1,10 @@
+class SearchOptions:
+    def __init__(self, limit=20, geo="IN"):
+        self.limit = limit
+        self.geo = geo
+
+    def to_dict(self):
+        return {
+            "limit": self.limit,
+            "geo": self.geo
+        }

gcrawl_sdk-0.1.0/gcrawl_sdk/search_result.py

@@ -0,0 +1,17 @@
+class SearchItem:
+    def __init__(self, data):
+        self.position = data.get("position")
+        self.url = data.get("url")
+        self.title = data.get("title")
+        self.description = data.get("description")
+        self.raw_data = data
+
+class SearchResult:
+    def __init__(self, data):
+        self.query = data.get("query")
+        self.limit = data.get("limit")
+        self.count = data.get("count")
+        
+        results_list = data.get("results", [])
+        self.results = [SearchItem(item) for item in results_list]
+        self.raw_data = data

gcrawl_sdk-0.1.0/gcrawl_sdk/task_init_result.py

@@ -0,0 +1,17 @@
+class GcrawlTaskInitResult:
+    def __init__(self, data):
+        self.status_code = data.get("status_code")
+        self.crawl_id = data.get("crawl_id")
+        self.url = data.get("url")
+        self.crawl_mode = data.get("crawl_mode")
+        self.created_at = data.get("created_at")
+        self.task_id = data.get("task_id")
+        self.seo = data.get("SEO", False)
+        self.html = data.get("HTML", False)
+        self.screenshot = data.get("Screenshot", False)
+        self.markdown = data.get("Markdown", False)
+        self.images = data.get("Images", False)
+        self.status = data.get("status")
+        self.user_id = data.get("user_id")
+        self.task_url = data.get("task_url")
+        self.raw_data = data

gcrawl_sdk-0.1.0/gcrawl_sdk/task_result.py

@@ -0,0 +1,98 @@
+class GcrawlPageResult:
+    def __init__(self, data):
+        self.raw_data = data
+        self.url = data.get("start_url") or data.get("url")
+        self.markdown = data.get("markdown_content") or data.get("markdown") or data.get("seo_md")
+        self.html = data.get("html_content") or data.get("html")
+        self.screenshot_url = data.get("screenshot_s3_url") or data.get("screenshot") or data.get("screenshot_url")
+        self.crawl_mode = data.get("crawl_mode")
+        self.started_at = data.get("started_at")
+        self.time_taken = data.get("time_taken")
+        self.links = data.get("links")
+        self.seo_json = data.get("seo_json")
+        self.seo_md = data.get("seo_md")
+        self.images_json = data.get("images_json")
+        self.seo_xlsx_url = data.get("seo_xlsx_s3_url")
+
+class GcrawlTaskResult:
+    def __init__(self, data):
+        self.status = data.get("status")
+        self.crawl_id = data.get("crawl_id") or data.get("job_id")
+        self.url = data.get("url")
+        self.raw_data = data
+
+    @property
+    def is_completed(self):
+        return self.status in ["completed", "success"]
+
+    @property
+    def is_failed(self):
+        return self.status == "failed"
+
+    def _get_field_from_data(self, keys):
+        # 1. Search root level
+        for key in keys:
+            if key in self.raw_data:
+                return self.raw_data[key]
+                
+        # 2. Search inside data (which could be a dict or a list of dicts)
+        data_field = self.raw_data.get("data")
+        if isinstance(data_field, dict):
+            for key in keys:
+                if key in data_field:
+                    return data_field[key]
+        elif isinstance(data_field, list):
+            for item in data_field:
+                if isinstance(item, dict):
+                    for key in keys:
+                        if key in item:
+                            return item[key]
+
+        # 3. Search inside results (list of dicts)
+        results = self.raw_data.get("results")
+        if isinstance(results, list):
+            for item in results:
+                if isinstance(item, dict):
+                    for key in keys:
+                        if key in item:
+                            return item[key]
+        return None
+
+    @property
+    def markdown(self):
+        return self._get_field_from_data(["markdown", "markdown_content", "seo_md"])
+
+    @property
+    def html(self):
+        return self._get_field_from_data(["html", "html_content"])
+
+    @property
+    def screenshot_url(self):
+        return self._get_field_from_data(["screenshot_s3_url", "screenshot", "screenshot_url"])
+
+    @property
+    def links(self):
+        return self._get_field_from_data(["links"])
+
+    @property
+    def seo_json(self):
+        return self._get_field_from_data(["seo_json"])
+
+    @property
+    def seo_md(self):
+        return self._get_field_from_data(["seo_md"])
+
+    @property
+    def images_json(self):
+        return self._get_field_from_data(["images_json"])
+
+    @property
+    def seo_xlsx_url(self):
+        return self._get_field_from_data(["seo_xlsx_s3_url"])
+
+    @property
+    def pages(self):
+        data_field = self.raw_data.get("data")
+        if isinstance(data_field, list):
+            return [GcrawlPageResult(item) for item in data_field if isinstance(item, dict)]
+        return []

gcrawl_sdk-0.1.0/gcrawl_sdk.egg-info/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.4
+Name: gcrawl-sdk
+Version: 0.1.0
+Summary: Python SDK for GCrawl — Scrape, crawl, screenshot, links, and search with ease
+Author-email: Ramkumar <ramkumarlpm4@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Gramosoft
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/GramosoftAI/GCrawl
+Keywords: crawl,scraper,screenshot,links,gcrawl,ai
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Dynamic: license-file
+
+# gcrawl-sdk
+
+Official Python SDK for GCrawl — Scrape, crawl, screenshot, fetch links, and search web pages with ease.
+
+## Installation
+
+```bash
+pip install gcrawl-sdk
+```
+
+## Quick Start
+
+```python
+from gcrawl_sdk import GcrawlClient, ScrapeOptions
+
+client = GcrawlClient(api_key="your-api-key")
+
+# Scrape a website (synchronous polling)
+result = client.scrape(
+    url="https://gramosoft.tech",
+    options=ScrapeOptions(markdown_enabled=True, screenshot_enabled=True),
+    wait=True
+)
+print("Scraped Markdown:", result.markdown)
+print("Screenshot URL:", result.screenshot_url)
+
+# Search web synchronously
+search_res = client.search("gramosoft", limit=5, geo="IN")
+for res in search_res.results:
+    print(res.position, res.title, res.url)
+```
+
+## API Key
+
+Set your API key as an environment variable:
+```bash
+export GCRAWL_API_KEY="your-api-key"
+```
+
+Or pass it directly to the client:
+```python
+client = GcrawlClient(api_key="your-api-key")
+```

gcrawl_sdk-0.1.0/gcrawl_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+README.md
+pyproject.toml
+gcrawl_sdk/__init__.py
+gcrawl_sdk/client.py
+gcrawl_sdk/crawl_options.py
+gcrawl_sdk/exceptions.py
+gcrawl_sdk/links_options.py
+gcrawl_sdk/scrape_options.py
+gcrawl_sdk/screenshot_options.py
+gcrawl_sdk/search_options.py
+gcrawl_sdk/search_result.py
+gcrawl_sdk/task_init_result.py
+gcrawl_sdk/task_result.py
+gcrawl_sdk.egg-info/PKG-INFO
+gcrawl_sdk.egg-info/SOURCES.txt
+gcrawl_sdk.egg-info/dependency_links.txt
+gcrawl_sdk.egg-info/requires.txt
+gcrawl_sdk.egg-info/top_level.txt

gcrawl_sdk-0.1.0/gcrawl_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

gcrawl_sdk-0.1.0/gcrawl_sdk.egg-info/requires.txt

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

gcrawl_sdk-0.1.0/gcrawl_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+gcrawl_sdk

gcrawl_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "gcrawl-sdk"
+version = "0.1.0"
+description = "Python SDK for GCrawl — Scrape, crawl, screenshot, links, and search with ease"
+readme = "README.md"
+license = { file = "LICENSE" }
+authors = [
+    { name = "Ramkumar", email = "ramkumarlpm4@gmail.com" }
+]
+keywords = ["crawl", "scraper", "screenshot", "links", "gcrawl", "ai"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+requires-python = ">=3.10"
+dependencies = [
+    "requests>=2.28.0"
+]
+
+[project.urls]
+Homepage = "https://github.com/GramosoftAI/GCrawl"

gcrawl_sdk-0.1.0/setup.cfg

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