@@ -339,14 +339,13 @@ def project(self, project_name, the_workspace=None):
             else:
                 the_workspace = self.current_workspace
 
-        dataset_info = requests.get(API_URL + "/" + the_workspace + "/" + project_name + "?api_key=" + self.api_key)
-
-        # Throw error if dataset isn't valid/user doesn't have
-        #   permissions to access the dataset
-        if dataset_info.status_code != 200:
-            raise RuntimeError(dataset_info.text)
-
-        dataset_info = dataset_info.json()["project"]
+        try:
+            dataset_info = rfapi.get_project(self.api_key, the_workspace, project_name)["project"]
+        except rfapi.ProjectNotFoundError:
+            raise
+        except rfapi.RoboflowError as e:
+            # keep the RuntimeError callers have always caught
+            raise RuntimeError(str(e)) from e
 
         return Project(self.api_key, dataset_info)
 
 
@@ -28,6 +28,26 @@ def __init__(self, message, status_code=None):
         self.status_code = status_code
 
 
+class ProjectNotFoundError(RoboflowError, RuntimeError):
+    """The API answered 404 for a project lookup.
+
+    Roboflow answers 404 alike for a project that never existed, one that
+    was deleted (in Trash) and one the API key cannot see. Subclasses
+    `RuntimeError` because `Roboflow.project()` raised that before.
+    """
+
+    def __init__(self, workspace_url, project_url):
+        super().__init__(
+            f"Project '{project_url}' not found in workspace '{workspace_url}'. "
+            "It may not exist, may have been deleted (check the workspace Trash), "
+            "or your API key may not have access to it. "
+            "Check the project id: it is the URL slug, e.g. 'my-project', not the display name.",
+            status_code=404,
+        )
+        self.workspace_url = workspace_url
+        self.project_url = project_url
+
+
 class ImageUploadError(RoboflowError):
     def __init__(self, message, status_code=None):
         self.message = message
@@ -54,6 +74,8 @@ def get_workspace(api_key, workspace_url):
 def get_project(api_key, workspace_url, project_url):
     url = f"{API_URL}/{workspace_url}/{project_url}?api_key={api_key}"
     response = requests.get(url)
+    if response.status_code == 404:
+        raise ProjectNotFoundError(workspace_url, project_url)
     if response.status_code != 200:
         raise RoboflowError(response.text, status_code=response.status_code)
     result = response.json()
 
@@ -0,0 +1,78 @@
+"""A project id that resolves to nothing must raise, not return a Project (#302)."""
+
+import responses
+
+from roboflow.adapters.rfapi import ProjectNotFoundError, RoboflowError
+from roboflow.config import API_URL
+from tests import ROBOFLOW_API_KEY, WORKSPACE_NAME, RoboflowTest
+
+MISSING = "my_project"
+
+# What the API answers for a missing, trashed or inaccessible project.
+NOT_FOUND_BODY = {
+    "error": {
+        "message": f"Unsupported request. `GET /{WORKSPACE_NAME}/{MISSING}` does not exist "
+        "or cannot be loaded due to missing permissions.",
+        "type": "GraphMethodException",
+    }
+}
+
+
+class TestProjectNotFound(RoboflowTest):
+    def _answer(self, status, body):
+        responses.add(
+            responses.GET,
+            f"{API_URL}/{WORKSPACE_NAME}/{MISSING}?api_key={ROBOFLOW_API_KEY}",
+            json=body,
+            status=status,
+        )
+
+    def test_workspace_project_raises_naming_workspace_and_project(self):
+        self._answer(404, NOT_FOUND_BODY)
+
+        with self.assertRaises(ProjectNotFoundError) as ctx:
+            self.workspace.project(MISSING)
+
+        message = str(ctx.exception)
+        self.assertIn(f"'{MISSING}'", message)
+        self.assertIn(f"'{WORKSPACE_NAME}'", message)
+        self.assertIn("Trash", message)
+        self.assertEqual(ctx.exception.status_code, 404)
+        self.assertEqual(ctx.exception.workspace_url, WORKSPACE_NAME)
+        self.assertEqual(ctx.exception.project_url, MISSING)
+
+    def test_missing_project_never_reaches_upload(self):
+        self._answer(404, NOT_FOUND_BODY)
+
+        with self.assertRaises(ProjectNotFoundError):
+            self.workspace.project(MISSING).upload(image_path="tests/images/hand-rabbit.PNG")
+
+        upload_calls = [c for c in responses.calls if "/upload" in c.request.url]
+        self.assertEqual(upload_calls, [])
+
+    def test_roboflow_project_raises_and_stays_a_runtime_error(self):
+        self._answer(404, NOT_FOUND_BODY)
+
+        with self.assertRaises(ProjectNotFoundError) as ctx:
+            self.rf.project(f"{WORKSPACE_NAME}/{MISSING}")
+
+        self.assertIsInstance(ctx.exception, RuntimeError)
+        self.assertIn(f"'{WORKSPACE_NAME}'", str(ctx.exception))
+
+    def test_other_errors_keep_the_api_body(self):
+        self._answer(500, {"error": "boom"})
+
+        with self.assertRaises(RoboflowError) as ctx:
+            self.workspace.project(MISSING)
+
+        self.assertNotIsInstance(ctx.exception, ProjectNotFoundError)
+        self.assertIn("boom", str(ctx.exception))
+        self.assertEqual(ctx.exception.status_code, 500)
+
+    def test_roboflow_project_other_errors_stay_runtime_error(self):
+        self._answer(403, {"error": "forbidden"})
+
+        with self.assertRaises(RuntimeError) as ctx:
+            self.rf.project(f"{WORKSPACE_NAME}/{MISSING}")
+
+        self.assertIn("forbidden", str(ctx.exception))