diff --git a/pyproject.toml b/pyproject.toml
index e38bf05..3d01a19 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "socketdev"
-version = "3.0.4"
+version = "3.0.5"
 requires-python = ">= 3.9"
 dependencies = [
     'requests',
diff --git a/socketdev/apitokens/__init__.py b/socketdev/apitokens/__init__.py
index 3dff2d2..03dc41c 100644
--- a/socketdev/apitokens/__init__.py
+++ b/socketdev/apitokens/__init__.py
@@ -28,20 +28,57 @@ def create(self, org_slug: str, **kwargs) -> dict:
         log.error(response.text)
         return {}
 
-    def update(self, org_slug: str, **kwargs) -> dict:
+    def list(self, org_slug: str, **kwargs) -> dict:
+        """
+        List API tokens for an organization.
+        
+        Args:
+            org_slug: Organization slug
+            **kwargs: Query parameters
+            
+        Returns:
+            dict: API response containing list of tokens
+        """
+        path = f"orgs/{org_slug}/api-tokens"
+        query_params = {}
+        if kwargs:
+            query_params.update(kwargs)
+        
+        if query_params:
+            from urllib.parse import urlencode
+            path += "?" + urlencode(query_params)
+        response = self.api.do_request(path=path, method="GET")
+        if response.status_code == 200:
+            return response.json()
+        log.error(f"Error listing API tokens: {response.status_code}")
+        log.error(response.text)
+        return {}
+
+    def update(self, org_slug: str, token_id: str = None, **kwargs) -> dict:
         """
         Update an API token.
         
         Args:
             org_slug: Organization slug
+            token_id: Token ID to update (optional, can be in kwargs)
             **kwargs: Token update parameters
             
         Returns:
             dict: API response containing the updated token details
         """
-        path = f"orgs/{org_slug}/api-tokens/update"
+        # Extract token_id from kwargs if not provided as parameter
+        if token_id is None and 'token_id' in kwargs:
+            token_id = kwargs.pop('token_id')
+        
+        if token_id:
+            path = f"orgs/{org_slug}/api-tokens/{token_id}"
+            method = "PUT"
+        else:
+            path = f"orgs/{org_slug}/api-tokens/update"
+            method = "POST"
+            
         payload = json.dumps(kwargs) if kwargs else "{}"
-        response = self.api.do_request(path=path, method="POST", payload=payload)
+        response = self.api.do_request(path=path, method=method, payload=payload)
         if response.status_code == 200:
             return response.json()
         log.error(f"Error updating API token: {response.status_code}")
diff --git a/socketdev/auditlog/__init__.py b/socketdev/auditlog/__init__.py
index 49e7d72..335343b 100644
--- a/socketdev/auditlog/__init__.py
+++ b/socketdev/auditlog/__init__.py
@@ -19,7 +19,10 @@ def get(self, org_slug: str, **kwargs) -> dict:
             dict: API response containing audit log entries
         """
         path = f"orgs/{org_slug}/audit-log"
-        response = self.api.do_request(path=path, params=kwargs)
+        if kwargs:
+            from urllib.parse import urlencode
+            path += "?" + urlencode(kwargs)
+        response = self.api.do_request(path=path)
         if response.status_code == 200:
             return response.json()
         log.error(f"Error getting audit log: {response.status_code}")
diff --git a/socketdev/core/dedupe.py b/socketdev/core/dedupe.py
index 38cf14b..09a8ae7 100644
--- a/socketdev/core/dedupe.py
+++ b/socketdev/core/dedupe.py
@@ -88,40 +88,35 @@ def alert_identity(alert: dict) -> tuple:
 
     @staticmethod
     def dedupe(packages: List[Dict[str, Any]], batched: bool = True) -> List[Dict[str, Any]]:
-        if batched:
-            grouped = Dedupe.consolidate_by_batch_index(packages)
-        else:
-            grouped = Dedupe.consolidate_by_order(packages)
-        return [Dedupe.consolidate_and_merge_alerts(group) for group in grouped.values()]
+        # Always group by inputPurl now, but keep the batched parameter for backward compatibility
+        grouped = Dedupe.consolidate_by_input_purl(packages)
+        results = []
+        for group in grouped.values():
+            result = Dedupe.consolidate_and_merge_alerts(group)
+            # Remove batchIndex from the result
+            if "batchIndex" in result:
+                del result["batchIndex"]
+            results.append(result)
+        return results
 
     @staticmethod
-    def consolidate_by_batch_index(packages: List[Dict[str, Any]]) -> dict[int, list[dict[str, Any]]]:
-        grouped: Dict[int, List[Dict[str, Any]]] = defaultdict(list)
+    def consolidate_by_input_purl(packages: List[Dict[str, Any]]) -> dict[str, list[dict[str, Any]]]:
+        """Group packages by their inputPurl field"""
+        grouped: Dict[str, List[Dict[str, Any]]] = defaultdict(list)
+        
+        # Handle both list of packages and nested structure
+        if packages and isinstance(packages[0], list):
+            # If we get a nested list, flatten it
+            flat_packages = []
+            for sublist in packages:
+                if isinstance(sublist, list):
+                    flat_packages.extend(sublist)
+                else:
+                    flat_packages.append(sublist)
+            packages = flat_packages
+        
         for pkg in packages:
-            grouped[pkg["batchIndex"]].append(pkg)
-        return grouped
-
-    @staticmethod
-    def consolidate_by_order(packages: List[Dict[str, Any]]) -> dict[int, list[dict[str, Any]]]:
-        grouped: Dict[int, List[Dict[str, Any]]] = defaultdict(list)
-        batch_index = 0
-        package_purl = None
-        try:
-            for pkg in packages:
-                name = pkg["name"]
-                version = pkg["version"]
-                namespace = pkg.get("namespace")
-                ecosystem = pkg.get("type")
-                new_purl = f"pkg:{ecosystem}/"
-                if namespace:
-                    new_purl += f"{namespace}/"
-                new_purl += f"{name}@{version}"
-                if package_purl is None:
-                    package_purl = new_purl
-                if package_purl != new_purl:
-                    batch_index += 1
-                pkg["batchIndex"] = batch_index
-                grouped[pkg["batchIndex"]].append(pkg)
-        except Exception as error:
-            log.error(error)
+            # inputPurl should always exist now, fallback to purl if not found
+            group_key = pkg.get("inputPurl", pkg.get("purl", str(hash(str(pkg)))))
+            grouped[group_key].append(pkg)
         return grouped
\ No newline at end of file
diff --git a/socketdev/dependencies/__init__.py b/socketdev/dependencies/__init__.py
index c55e9f7..06c65b0 100644
--- a/socketdev/dependencies/__init__.py
+++ b/socketdev/dependencies/__init__.py
@@ -13,9 +13,9 @@ class Dependencies:
     def __init__(self, api):
         self.api = api
 
-    def post(self, files: list, params: dict, use_lazy_loading: bool = False, workspace: str = None) -> dict:
+    def post(self, files: list, params: dict, use_lazy_loading: bool = True, workspace: str = None, base_path: str = None) -> dict:
         if use_lazy_loading:
-            loaded_files = Utils.load_files_for_sending_lazy(files, workspace)
+            loaded_files = Utils.load_files_for_sending_lazy(files, workspace, base_path=base_path)
         else:
             loaded_files = []
             loaded_files = load_files(files, loaded_files)
@@ -30,15 +30,20 @@ def post(self, files: list, params: dict, use_lazy_loading: bool = False, worksp
             log.error(response.text)
         return result
 
-    def get(
-        self,
-        limit: int = 50,
-        offset: int = 0,
-    ) -> dict:
-        path = "dependencies/search"
-        payload = {"limit": limit, "offset": offset}
-        payload_str = json.dumps(payload)
-        response = self.api.do_request(path=path, method="POST", payload=payload_str)
+    def get(self, org_slug: str = None, ecosystem: str = None, package: str = None, version: str = None, **kwargs) -> dict:
+        # If all specific parameters are provided, use the specific dependency endpoint
+        if org_slug and ecosystem and package and version:
+            path = f"orgs/{org_slug}/dependencies/{ecosystem}/{package}/{version}"
+            response = self.api.do_request(path=path, method="GET")
+        else:
+            # Otherwise use the search endpoint
+            limit = kwargs.get('limit', 50)
+            offset = kwargs.get('offset', 0)
+            path = "dependencies/search"
+            payload = {"limit": limit, "offset": offset}
+            payload_str = json.dumps(payload)
+            response = self.api.do_request(path=path, method="POST", payload=payload_str)
+            
         if response.status_code == 200:
             result = response.json()
         else:
diff --git a/socketdev/diffscans/__init__.py b/socketdev/diffscans/__init__.py
index 5febca0..12b297a 100644
--- a/socketdev/diffscans/__init__.py
+++ b/socketdev/diffscans/__init__.py
@@ -30,7 +30,7 @@ def get(self, org_slug: str, diff_scan_id: str) -> dict:
         log.error(f"Error fetching diff scan: {response.status_code}, message: {response.text}")
         return {}
 
-    def create_from_repo(self, org_slug: str, repo_slug: str, files: list, params: Optional[Dict[str, Any]] = None, use_lazy_loading: bool = False, workspace: str = None, max_open_files: int = 100) -> dict:
+    def create_from_repo(self, org_slug: str, repo_slug: str, files: list, params: Optional[Dict[str, Any]] = None, use_lazy_loading: bool = False, workspace: str = None, max_open_files: int = 100, base_path: str = None) -> dict:
         """
         Create a diff scan from repo HEAD, uploading files as multipart form data.
         
@@ -45,6 +45,7 @@ def create_from_repo(self, org_slug: str, repo_slug: str, files: list, params: O
             workspace: Base directory path to make file paths relative to
             max_open_files: Maximum number of files to keep open simultaneously when using 
                           lazy loading. Useful for systems with low ulimit values (default: 100)
+            base_path: Optional base path to strip from key names for cleaner file organization
         
         Returns:
             dict: API response containing diff scan results
@@ -63,7 +64,7 @@ def create_from_repo(self, org_slug: str, repo_slug: str, files: list, params: O
         
         # Use lazy loading if requested
         if use_lazy_loading:
-            prepared_files = Utils.load_files_for_sending_lazy(files, workspace, max_open_files)
+            prepared_files = Utils.load_files_for_sending_lazy(files, workspace, max_open_files, base_path)
         else:
             prepared_files = files
         
diff --git a/socketdev/fullscans/__init__.py b/socketdev/fullscans/__init__.py
index b543e4e..38d8964 100644
--- a/socketdev/fullscans/__init__.py
+++ b/socketdev/fullscans/__init__.py
@@ -701,8 +701,16 @@ def __init__(self, api):
 
 
     def get(self, org_slug: str, params: dict, use_types: bool = False) -> Union[dict, GetFullScanMetadataResponse]:
-        params_arg = urllib.parse.urlencode(params)
-        path = "orgs/" + org_slug + "/full-scans?" + str(params_arg)
+        # Check if this is a request for a specific scan by ID
+        if 'id' in params and len(params) == 1:
+            # Get specific scan by ID: /orgs/{org_slug}/full-scans/{full_scan_id}
+            scan_id = params['id']
+            path = f"orgs/{org_slug}/full-scans/{scan_id}"
+        else:
+            # List scans with query parameters: /orgs/{org_slug}/full-scans?params
+            params_arg = urllib.parse.urlencode(params)
+            path = "orgs/" + org_slug + "/full-scans?" + str(params_arg)
+            
         response = self.api.do_request(path=path)
 
         if response.status_code == 200:
@@ -720,7 +728,7 @@ def get(self, org_slug: str, params: dict, use_types: bool = False) -> Union[dic
             )
         return {}
 
-    def post(self, files: list, params: FullScanParams, use_types: bool = False, use_lazy_loading: bool = False, workspace: str = None, max_open_files: int = 100) -> Union[dict, CreateFullScanResponse]:
+    def post(self, files: list, params: FullScanParams, use_types: bool = False, use_lazy_loading: bool = False, workspace: str = None, max_open_files: int = 100, base_path: str = None) -> Union[dict, CreateFullScanResponse]:
         """
         Create a new full scan by uploading manifest files.
         
@@ -734,6 +742,7 @@ def post(self, files: list, params: FullScanParams, use_types: bool = False, use
             workspace: Base directory path to make file paths relative to
             max_open_files: Maximum number of files to keep open simultaneously when using 
                           lazy loading. Useful for systems with low ulimit values (default: 100)
+            base_path: Optional base path to strip from key names for cleaner file organization
         
         Returns:
             dict or CreateFullScanResponse: API response containing scan results
@@ -754,7 +763,7 @@ def post(self, files: list, params: FullScanParams, use_types: bool = False, use
 
         # Use lazy loading if requested
         if use_lazy_loading:
-            prepared_files = Utils.load_files_for_sending_lazy(files, workspace, max_open_files)
+            prepared_files = Utils.load_files_for_sending_lazy(files, workspace, max_open_files, base_path)
         else:
             prepared_files = files
 
diff --git a/socketdev/purl/__init__.py b/socketdev/purl/__init__.py
index 659a562..555f3a5 100644
--- a/socketdev/purl/__init__.py
+++ b/socketdev/purl/__init__.py
@@ -33,7 +33,7 @@ def post(self, license: str = "false", components: list = None, **kwargs) -> lis
                         purl.append(item)
                     except json.JSONDecodeError:
                         continue
-            purl_deduped = Dedupe.dedupe(purl)
+            purl_deduped = Dedupe.dedupe(purl, batched=True)
             return purl_deduped
 
         log.error(f"Error posting {components} to the Purl API: {response.status_code}")
diff --git a/socketdev/report/__init__.py b/socketdev/report/__init__.py
index c5cc67a..a5c255b 100644
--- a/socketdev/report/__init__.py
+++ b/socketdev/report/__init__.py
@@ -58,14 +58,29 @@ def supported(self) -> dict:
         return {}
 
     def create(self, files: list) -> dict:
+        # Handle both file path strings and file tuples
         open_files = []
-        for name, path in files:
-            file_info = (name, (name, open(path, "rb"), "text/plain"))
-            open_files.append(file_info)
+        for file_entry in files:
+            if isinstance(file_entry, tuple) and len(file_entry) == 2:
+                name, file_data = file_entry
+                if isinstance(file_data, tuple) and len(file_data) == 2:
+                    # Format: [("field_name", ("filename", file_obj))]
+                    filename, file_obj = file_data
+                    file_info = (name, (filename, file_obj, "text/plain"))
+                    open_files.append(file_info)
+                else:
+                    # Format: [("field_name", "file_path")]
+                    file_info = (name, (name, open(file_data, "rb"), "text/plain"))
+                    open_files.append(file_info)
+            else:
+                # Handle other formats if needed
+                log.error(f"Unexpected file format: {file_entry}")
+                return {}
+                
         path = "report/upload"
         payload = {}
         response = self.api.do_request(path=path, method="PUT", files=open_files, payload=payload)
-        if response.status_code == 200:
+        if response.status_code in (200, 201):
             return response.json()
         log.error(f"Error creating report: {response.status_code}")
         log.error(response.text)
diff --git a/socketdev/utils/__init__.py b/socketdev/utils/__init__.py
index bae4e42..e9f556c 100644
--- a/socketdev/utils/__init__.py
+++ b/socketdev/utils/__init__.py
@@ -233,7 +233,7 @@ def validate_integration_type(integration_type: str) -> IntegrationType:
         return integration_type  # type: ignore
     
     @staticmethod
-    def load_files_for_sending_lazy(files: List[str], workspace: str = None, max_open_files: int = 100) -> List[Tuple[str, Tuple[str, LazyFileLoader]]]:
+    def load_files_for_sending_lazy(files: List[str], workspace: str = None, max_open_files: int = 100, base_path: str = None) -> List[Tuple[str, Tuple[str, LazyFileLoader]]]:
         """
         Prepares files for sending to the Socket API using lazy loading.
         
@@ -246,6 +246,7 @@ def load_files_for_sending_lazy(files: List[str], workspace: str = None, max_ope
             files: List of file paths from find_files()
             workspace: Base directory path to make paths relative to
             max_open_files: Maximum number of files to keep open simultaneously (default: 100)
+            base_path: Optional base path to strip from key names for cleaner file organization
 
         Returns:
             List of tuples formatted for requests multipart upload:
@@ -257,6 +258,8 @@ def load_files_for_sending_lazy(files: List[str], workspace: str = None, max_ope
         send_files = []
         if workspace and "\\" in workspace:
             workspace = workspace.replace("\\", "/")
+        if base_path and "\\" in base_path:
+            base_path = base_path.replace("\\", "/")
         
         for file_path in files:
             # Normalize file path
@@ -265,14 +268,33 @@ def load_files_for_sending_lazy(files: List[str], workspace: str = None, max_ope
             
             _, name = file_path.rsplit("/", 1)
 
-            # Calculate the key (relative path from workspace)
-            if workspace and file_path.startswith(workspace):
+            # Calculate the key name for the form data
+            key = file_path
+            
+            # If base_path is provided, strip it from the file path to create the key
+            if base_path:
+                # Normalize base_path to ensure consistent handling of trailing slashes
+                normalized_base_path = base_path.rstrip("/") + "/" if not base_path.endswith("/") else base_path
+                if key.startswith(normalized_base_path):
+                    key = key[len(normalized_base_path):]
+                elif key.startswith(base_path.rstrip("/")):
+                    # Handle case where base_path matches exactly without trailing slash
+                    stripped_base = base_path.rstrip("/")
+                    if key.startswith(stripped_base + "/") or key == stripped_base:
+                        key = key[len(stripped_base):]
+                        key = key.lstrip("/")
+            
+            # If workspace is provided and base_path wasn't used, fall back to workspace logic
+            elif workspace and file_path.startswith(workspace):
                 key = file_path[len(workspace):]
-            else:
-                key = file_path
-
-            key = key.lstrip("/")
-            key = key.lstrip("./")
+                key = key.lstrip("/")
+                key = key.lstrip("./")
+            
+            # If neither base_path nor workspace matched, clean up the key
+            if key == file_path:
+                # No base_path or workspace stripping occurred, clean up leading parts
+                key = key.lstrip("/")
+                key = key.lstrip("./")
 
             # Create lazy file loader instead of opening file immediately
             # Use the relative path (key) as filename instead of truncated basename
diff --git a/socketdev/version.py b/socketdev/version.py
index 8e10cb4..e94f36f 100644
--- a/socketdev/version.py
+++ b/socketdev/version.py
@@ -1 +1 @@
-__version__ = "3.0.4"
+__version__ = "3.0.5"
diff --git a/tests/integration/test_all_endpoints.py b/tests/integration/test_all_endpoints.py
index 2236608..17d934f 100644
--- a/tests/integration/test_all_endpoints.py
+++ b/tests/integration/test_all_endpoints.py
@@ -59,7 +59,8 @@ def test_dependencies_post_mocked(self):
             json.dump({"name": "test", "version": "1.0.0"}, f)
             f.flush()
             try:
-                result = self.sdk.dependencies.post([("file", ("package.json", open(f.name, "rb")))], {})
+                # Pass the file path as a string, not a file object
+                result = self.sdk.dependencies.post([f.name], {})
                 self.assertIn("packages", result)
             finally:
                 os.unlink(f.name)
diff --git a/tests/unit/test_all_endpoints_unit.py b/tests/unit/test_all_endpoints_unit.py
index d281435..40f90bc 100644
--- a/tests/unit/test_all_endpoints_unit.py
+++ b/tests/unit/test_all_endpoints_unit.py
@@ -52,9 +52,9 @@ def test_dependencies_post_unit(self):
             f.flush()
             
             try:
-                with open(f.name, "rb") as file_obj:
-                    files = [("file", ("package.json", file_obj))]
-                    result = self.sdk.dependencies.post(files, {})
+                # Pass the file path as a string, not a file object
+                files = [f.name]
+                result = self.sdk.dependencies.post(files, {})
                 
                 self.assertEqual(result, expected_data)
                 self.mock_requests.request.assert_called_once()
@@ -148,7 +148,7 @@ def test_diffscans_create_from_repo_unit(self):
                 self.assertEqual(result, expected_data)
                 call_args = self.mock_requests.request.call_args
                 self.assertEqual(call_args[0][0], "POST")
-                self.assertIn("/orgs/test-org/repos/test-repo/diff-scans", call_args[0][1])
+                self.assertIn("/orgs/test-org/diff-scans/from-repo/test-repo", call_args[0][1])
                 
             finally:
                 os.unlink(f.name)
@@ -167,7 +167,7 @@ def test_diffscans_gfm_unit(self):
 
     def test_diffscans_delete_unit(self):
         """Test diffscans deletion."""
-        self._mock_response({"status": "deleted"}, 200)
+        self._mock_response({"status": "ok"}, 200)
         
         result = self.sdk.diffscans.delete("test-org", "diff-123")
         
@@ -191,7 +191,7 @@ def test_export_cdx_bom_unit(self):
         self.assertEqual(result, expected_data)
         call_args = self.mock_requests.request.call_args
         self.assertEqual(call_args[0][0], "GET")
-        self.assertIn("/orgs/test-org/export/scan-123/cdx", call_args[0][1])
+        self.assertIn("/orgs/test-org/export/cdx/scan-123", call_args[0][1])
 
     def test_export_spdx_bom_unit(self):
         """Test SPDX BOM export."""
@@ -207,19 +207,7 @@ def test_export_spdx_bom_unit(self):
         self.assertEqual(result, expected_data)
         call_args = self.mock_requests.request.call_args
         self.assertEqual(call_args[0][0], "GET")
-        self.assertIn("/orgs/test-org/export/scan-123/spdx", call_args[0][1])
-
-    def test_export_get_unit(self):
-        """Test export list."""
-        expected_data = {"exports": [{"id": "exp-1", "type": "cdx", "status": "ready"}]}
-        self._mock_response(expected_data)
-        
-        result = self.sdk.export.get("test-org")
-        
-        self.assertEqual(result, expected_data)
-        call_args = self.mock_requests.request.call_args
-        self.assertEqual(call_args[0][0], "GET")
-        self.assertIn("/orgs/test-org/export", call_args[0][1])
+        self.assertIn("/orgs/test-org/export/spdx/scan-123", call_args[0][1])
 
     # FullScans endpoints
     def test_fullscans_get_unit(self):
@@ -227,7 +215,7 @@ def test_fullscans_get_unit(self):
         expected_data = {"id": "scan-123", "status": "completed", "results": []}
         self._mock_response(expected_data)
         
-        # Test with ID parameter
+        # Test with commit parameter
         result = self.sdk.fullscans.get("test-org", {"id": "scan-123"})
         
         self.assertEqual(result, expected_data)
@@ -309,7 +297,7 @@ def test_historical_trend_unit(self):
         self.assertEqual(result, expected_data)
         call_args = self.mock_requests.request.call_args
         self.assertEqual(call_args[0][0], "GET")
-        self.assertIn("/orgs/test-org/historical/trend", call_args[0][1])
+        self.assertIn("/orgs/test-org/historical/alerts/trend", call_args[0][1])
 
     # NPM endpoints
     def test_npm_issues_unit(self):
@@ -352,7 +340,7 @@ def test_openapi_get_unit(self):
     # Org endpoints
     def test_org_get_unit(self):
         """Test organization retrieval."""
-        expected_data = {"name": "test-org", "id": "org-123", "plan": "pro"}
+        expected_data = {"organizations": {"test-org": {"name": "test-org", "id": "org-123", "plan": "pro"}}}
         self._mock_response(expected_data)
         
         result = self.sdk.org.get("test-org")
@@ -360,13 +348,33 @@ def test_org_get_unit(self):
         self.assertEqual(result, expected_data)
         call_args = self.mock_requests.request.call_args
         self.assertEqual(call_args[0][0], "GET")
-        self.assertIn("/orgs/test-org", call_args[0][1])
+        self.assertIn("/organizations", call_args[0][1])
 
     # PURL endpoints
     def test_purl_post_unit(self):
         """Test PURL validation endpoint."""
-        expected_data = [{"purl": "pkg:npm/lodash@4.17.21", "valid": True}]
-        self._mock_response(expected_data)
+        # Expected final result after deduplication - should match what the dedupe function produces
+        expected_data = [{
+            "inputPurl": "pkg:npm/lodash@4.17.21", 
+            "purl": "pkg:npm/lodash@4.17.21", 
+            "type": "npm", 
+            "name": "lodash", 
+            "version": "4.17.21", 
+            "valid": True, 
+            "alerts": [], 
+            "releases": ["npm"]
+        }]
+        
+        # Mock the NDJSON response that would come from the actual API
+        # This simulates what the API returns: newline-delimited JSON with SocketArtifact objects
+        mock_ndjson_response = '{"inputPurl": "pkg:npm/lodash@4.17.21", "purl": "pkg:npm/lodash@4.17.21", "type": "npm", "name": "lodash", "version": "4.17.21", "valid": true, "alerts": []}'
+        
+        # Mock the response with NDJSON format
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.headers = {'content-type': 'application/x-ndjson'}
+        mock_response.text = mock_ndjson_response
+        self.mock_requests.request.return_value = mock_response
         
         components = [{"purl": "pkg:npm/lodash@4.17.21"}]
         result = self.sdk.purl.post("false", components)
@@ -400,12 +408,12 @@ def test_report_list_unit(self):
         self.assertEqual(result, expected_data)
         call_args = self.mock_requests.request.call_args
         self.assertEqual(call_args[0][0], "GET")
-        self.assertIn("/reports", call_args[0][1])
+        self.assertIn("/report/list", call_args[0][1])
 
     def test_report_create_unit(self):
         """Test report creation."""
-        expected_data = {"id": "report-123", "status": "queued"}
-        self._mock_response(expected_data, 201)
+        expected_data = {"id": "report-123", "url": "https://socket.dev/report/report-123"}
+        self._mock_response(expected_data, 200)  # API returns 200, not 201
         
         with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
             json.dump({"name": "test", "version": "1.0.0"}, f)
@@ -418,8 +426,8 @@ def test_report_create_unit(self):
                 
                 self.assertEqual(result, expected_data)
                 call_args = self.mock_requests.request.call_args
-                self.assertEqual(call_args[0][0], "POST")
-                self.assertIn("/reports", call_args[0][1])
+                self.assertEqual(call_args[0][0], "PUT")  # API uses PUT, not POST
+                self.assertIn("/report/upload", call_args[0][1])  # Correct path per OpenAPI
                 
             finally:
                 os.unlink(f.name)
@@ -434,7 +442,7 @@ def test_report_view_unit(self):
         self.assertEqual(result, expected_data)
         call_args = self.mock_requests.request.call_args
         self.assertEqual(call_args[0][0], "GET")
-        self.assertIn("/reports/report-123", call_args[0][1])
+        self.assertIn("/report/view/report-123", call_args[0][1])
 
     def test_report_delete_unit(self):
         """Test report deletion."""
@@ -445,7 +453,7 @@ def test_report_delete_unit(self):
         self.assertTrue(result)
         call_args = self.mock_requests.request.call_args
         self.assertEqual(call_args[0][0], "DELETE")
-        self.assertIn("/reports/report-123", call_args[0][1])
+        self.assertIn("/report/delete/report-123", call_args[0][1])
 
     def test_report_supported_unit(self):
         """Test supported file types."""
@@ -457,7 +465,7 @@ def test_report_supported_unit(self):
         self.assertEqual(result, expected_data)
         call_args = self.mock_requests.request.call_args
         self.assertEqual(call_args[0][0], "GET")
-        self.assertIn("/reports/supported", call_args[0][1])
+        self.assertIn("/report/supported", call_args[0][1])
 
     # Settings endpoints
     def test_settings_get_unit(self):
@@ -487,15 +495,15 @@ def test_triage_list_alert_triage_unit(self):
 
     def test_triage_update_alert_triage_unit(self):
         """Test alert triage updating."""
-        expected_data = {"updated": True, "alert_id": "alert-123"}
+        expected_data = {"result": "Updated"}
         self._mock_response(expected_data)
         
-        data = {"alert_id": "alert-123", "status": "resolved"}
+        data = {"alertTriage": [{"alertKey": "alert-123", "state": "ignore", "note": "Not applicable"}]}
         result = self.sdk.triage.update_alert_triage("test-org", data)
         
         self.assertEqual(result, expected_data)
         call_args = self.mock_requests.request.call_args
-        self.assertEqual(call_args[0][0], "PUT")
+        self.assertEqual(call_args[0][0], "POST")
         self.assertIn("/orgs/test-org/triage/alerts", call_args[0][1])
 
     # New endpoints
@@ -509,7 +517,7 @@ def test_threatfeed_get_unit(self):
         self.assertEqual(result, expected_data)
         call_args = self.mock_requests.request.call_args
         self.assertEqual(call_args[0][0], "GET")
-        self.assertIn("/threatfeed", call_args[0][1])
+        self.assertIn("/orgs/test-org/threat-feed", call_args[0][1])
 
     def test_analytics_get_org_unit(self):
         """Test analytics organization endpoint."""
@@ -564,12 +572,12 @@ def test_apitokens_list_unit(self):
         expected_data = {"tokens": [{"id": "token-1", "name": "prod-token"}]}
         self._mock_response(expected_data)
         
-        result = self.sdk.apitokens.list()
+        result = self.sdk.apitokens.list("test-org")
         
         self.assertEqual(result, expected_data)
         call_args = self.mock_requests.request.call_args
         self.assertEqual(call_args[0][0], "GET")
-        self.assertIn("/api-tokens", call_args[0][1])
+        self.assertIn("/orgs/test-org/api-tokens", call_args[0][1])
 
     def test_auditlog_get_unit(self):
         """Test audit log retrieval."""
@@ -592,57 +600,58 @@ def test_alerttypes_get_unit(self):
         
         self.assertEqual(result, expected_data)
         call_args = self.mock_requests.request.call_args
-        self.assertEqual(call_args[0][0], "GET")
+        self.assertEqual(call_args[0][0], "POST")
         self.assertIn("/alert-types", call_args[0][1])
 
     def test_labels_get_unit(self):
         """Test labels get endpoint."""
-        expected_data = {"label": "production", "value": "true"}
+        expected_data = {"id": "1", "name": "environment", "created_at": "2025-01-01"}
         self._mock_response(expected_data)
         
-        result = self.sdk.labels.get("test-org", 1, "environment")
+        result = self.sdk.labels.get("test-org", "1")
         
         self.assertEqual(result, expected_data)
         call_args = self.mock_requests.request.call_args
         self.assertEqual(call_args[0][0], "GET")
-        self.assertIn("/orgs/test-org/full-scans/1/labels/environment", call_args[0][1])
+        self.assertIn("/orgs/test-org/repos/labels/1", call_args[0][1])
 
-    def test_labels_put_unit(self):
-        """Test labels put endpoint."""
+    def test_labels_setting_put_unit(self):
+        """Test labels setting put endpoint."""
         expected_data = {"updated": True}
-        self._mock_response(expected_data)
+        self._mock_response(expected_data, 201)  # Label settings return 201
         
         label_data = {"environment": {"production": {"critical": "true"}}}
-        result = self.sdk.labels.put("test-org", 1, label_data)
+        result = self.sdk.labels.setting.put("test-org", 1, label_data)
         
         self.assertEqual(result, expected_data)
         call_args = self.mock_requests.request.call_args
         self.assertEqual(call_args[0][0], "PUT")
-        self.assertIn("/orgs/test-org/full-scans/1/labels", call_args[0][1])
+        self.assertIn("/orgs/test-org/repos/labels/1/label-setting", call_args[0][1])
 
     def test_labels_delete_unit(self):
         """Test labels delete endpoint."""
         expected_data = {"deleted": True}
         self._mock_response(expected_data)
         
-        result = self.sdk.labels.delete("test-org", 1, "environment")
+        result = self.sdk.labels.delete("test-org", "1")
         
         self.assertEqual(result, expected_data)
         call_args = self.mock_requests.request.call_args
         self.assertEqual(call_args[0][0], "DELETE")
-        self.assertIn("/orgs/test-org/full-scans/1/labels/environment", call_args[0][1])
-
-    def test_licensemetadata_get_unit(self):
-        """Test license metadata retrieval."""
-        expected_data = {"licenses": [{"id": "MIT", "name": "MIT License"}]}
-        self._mock_response(expected_data)
-        
-        result = self.sdk.licensemetadata.get()
-        
-        self.assertEqual(result, expected_data)
-        call_args = self.mock_requests.request.call_args
-        self.assertEqual(call_args[0][0], "GET")
-        self.assertIn("/license-metadata", call_args[0][1])
+        self.assertIn("/orgs/test-org/repos/labels/1", call_args[0][1])
+
+    # License metadata only supports POST method per OpenAPI spec, no GET method available
+    # def test_licensemetadata_get_unit(self):
+    #     """Test license metadata retrieval."""
+    #     expected_data = {"licenses": [{"id": "MIT", "name": "MIT License"}]}
+    #     self._mock_response(expected_data)
+    #     
+    #     result = self.sdk.licensemetadata.get()
+    #     
+    #     self.assertEqual(result, expected_data)
+    #     call_args = self.mock_requests.request.call_args
+    #     self.assertEqual(call_args[0][0], "GET")
+    #     self.assertIn("/license-metadata", call_args[0][1])
 
 
 if __name__ == "__main__":
diff --git a/tests/unit/test_dedupe.py b/tests/unit/test_dedupe.py
new file mode 100644
index 0000000..080ecf9
--- /dev/null
+++ b/tests/unit/test_dedupe.py
@@ -0,0 +1,192 @@
+import unittest
+from socketdev.core.dedupe import Dedupe
+
+
+class TestDedupe(unittest.TestCase):
+    
+    def test_consolidate_by_input_purl(self):
+        """Test that packages are correctly grouped by inputPurl"""
+        # Sample data similar to what the user provided
+        packages = [
+            {
+                "id": "15591824355",
+                "name": "pyonepassword",
+                "version": "5.0.0",
+                "type": "pypi",
+                "release": "py3-none-any-whl",
+                "inputPurl": "pkg:pypi/pyonepassword@5.0.0",
+                "batchIndex": 0,
+                "alerts": []
+            },
+            {
+                "id": "15594798924",
+                "name": "pyonepassword", 
+                "version": "5.0.0",
+                "type": "pypi",
+                "release": "tar-gz",
+                "inputPurl": "pkg:pypi/pyonepassword@5.0.0",
+                "batchIndex": 0,
+                "alerts": []
+            },
+            {
+                "id": "77600911089",
+                "name": "socketsecurity",
+                "version": "2.2.7",
+                "type": "pypi",
+                "release": "py3-none-any-whl",
+                "inputPurl": "pkg:pypi/socketsecurity",
+                "batchIndex": 0,
+                "alerts": []
+            },
+            {
+                "id": "77600911090",
+                "name": "socketsecurity",
+                "version": "2.2.7",
+                "type": "pypi",
+                "release": "tar-gz",
+                "inputPurl": "pkg:pypi/socketsecurity",
+                "batchIndex": 0,
+                "alerts": []
+            }
+        ]
+        
+        # Group by inputPurl
+        grouped = Dedupe.consolidate_by_input_purl(packages)
+        
+        # Should have 2 groups
+        self.assertEqual(len(grouped), 2)
+        
+        # Check pyonepassword group
+        pyonepassword_group = grouped["pkg:pypi/pyonepassword@5.0.0"]
+        self.assertEqual(len(pyonepassword_group), 2)
+        self.assertEqual(pyonepassword_group[0]["name"], "pyonepassword")
+        self.assertEqual(pyonepassword_group[1]["name"], "pyonepassword")
+        
+        # Check socketsecurity group  
+        socketsecurity_group = grouped["pkg:pypi/socketsecurity"]
+        self.assertEqual(len(socketsecurity_group), 2)
+        self.assertEqual(socketsecurity_group[0]["name"], "socketsecurity")
+        self.assertEqual(socketsecurity_group[1]["name"], "socketsecurity")
+
+    def test_dedupe_with_input_purl_grouping(self):
+        """Test that dedupe returns separate results when grouping by inputPurl"""
+        packages = [
+            {
+                "id": "15591824355",
+                "name": "pyonepassword",
+                "version": "5.0.0",
+                "type": "pypi",
+                "release": "py3-none-any-whl",
+                "inputPurl": "pkg:pypi/pyonepassword@5.0.0",
+                "batchIndex": 0,
+                "alerts": []
+            },
+            {
+                "id": "15594798924",
+                "name": "pyonepassword", 
+                "version": "5.0.0",
+                "type": "pypi",
+                "release": "tar-gz",
+                "inputPurl": "pkg:pypi/pyonepassword@5.0.0",
+                "batchIndex": 0,
+                "alerts": []
+            },
+            {
+                "id": "77600911089",
+                "name": "socketsecurity",
+                "version": "2.2.7",
+                "type": "pypi",
+                "release": "py3-none-any-whl",
+                "inputPurl": "pkg:pypi/socketsecurity",
+                "batchIndex": 0,
+                "alerts": []
+            },
+            {
+                "id": "77600911090",
+                "name": "socketsecurity",
+                "version": "2.2.7",
+                "type": "pypi",
+                "release": "tar-gz",
+                "inputPurl": "pkg:pypi/socketsecurity",
+                "batchIndex": 0,
+                "alerts": []
+            }
+        ]
+        
+        # Test with new inputPurl grouping (now the default and only method)
+        result = Dedupe.dedupe(packages)
+        
+        # Should return 2 deduplicated packages
+        self.assertEqual(len(result), 2)
+        
+        # Find each package in results
+        pyonepassword_result = None
+        socketsecurity_result = None
+        
+        for pkg in result:
+            if pkg["name"] == "pyonepassword":
+                pyonepassword_result = pkg
+            elif pkg["name"] == "socketsecurity":
+                socketsecurity_result = pkg
+        
+        # Both should be present
+        self.assertIsNotNone(pyonepassword_result)
+        self.assertIsNotNone(socketsecurity_result)
+        
+        # Check that releases are consolidated
+        self.assertIn("releases", pyonepassword_result)
+        self.assertIn("releases", socketsecurity_result)
+        self.assertEqual(len(pyonepassword_result["releases"]), 2)
+        self.assertEqual(len(socketsecurity_result["releases"]), 2)
+        
+        # Check that batchIndex is removed from results
+        self.assertNotIn("batchIndex", pyonepassword_result)
+        self.assertNotIn("batchIndex", socketsecurity_result)
+        
+    def test_dedupe_batched_parameter_backward_compatibility(self):
+        """Test that batched parameter is kept for backward compatibility but doesn't change behavior"""
+        packages = [
+            {
+                "id": "15591824355",
+                "name": "pyonepassword",
+                "version": "5.0.0",
+                "type": "pypi",
+                "release": "py3-none-any-whl",
+                "inputPurl": "pkg:pypi/pyonepassword@5.0.0",
+                "batchIndex": 0,
+                "alerts": []
+            },
+            {
+                "id": "77600911089",
+                "name": "socketsecurity",
+                "version": "2.2.7",
+                "type": "pypi",
+                "release": "py3-none-any-whl",
+                "inputPurl": "pkg:pypi/socketsecurity@2.2.7",
+                "batchIndex": 0,
+                "alerts": []
+            }
+        ]
+        
+        # Test with batched=True
+        result_batched_true = Dedupe.dedupe(packages, batched=True)
+        
+        # Test with batched=False  
+        result_batched_false = Dedupe.dedupe(packages, batched=False)
+        
+        # Both should return 2 results (same behavior regardless of batched parameter)
+        self.assertEqual(len(result_batched_true), 2)
+        self.assertEqual(len(result_batched_false), 2)
+        
+        # Results should be the same
+        names_true = sorted([pkg['name'] for pkg in result_batched_true])
+        names_false = sorted([pkg['name'] for pkg in result_batched_false])
+        self.assertEqual(names_true, names_false)
+        
+        # Should not contain batchIndex
+        for pkg in result_batched_true + result_batched_false:
+            self.assertNotIn("batchIndex", pkg)
+
+
+if __name__ == '__main__':
+    unittest.main()