Delete Project

DELETE /api/projects/{project_id}

Authorization: Bearer YOUR_API_KEY

{
  "message": "Project deleted successfully",
  "project_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
}

{
  "detail": "Cannot delete default project"
}

{
  "detail": "Project not found"
}

curl -X DELETE "https://markdownapi.io/api/projects/a1b2c3d4-e5f6-7890-abcd-ef1234567890" \
  -H "Authorization: Bearer YOUR_TOKEN"

import httpx
import os
from uuid import UUID
 
async def delete_project(project_id: UUID):
    """Delete project with confirmation and error handling."""
 
    api_key = os.getenv("MARKDOWN_API_KEY")
 
    async with httpx.AsyncClient() as client:
        try:
            response = await client.delete(
                f"https://markdownapi.io/api/projects/{project_id}",
                headers={"Authorization": f"Bearer {api_key}"},
                timeout=30.0  # Longer timeout for deletion
            )
 
            response.raise_for_status()
            result = response.json()
 
            print(f"✓ Project deleted: {result['project_id']}")
            print(f"  {result['message']}")
 
            return result
 
        except httpx.HTTPStatusError as e:
            if e.response.status_code == 403:
                error = e.response.json()
                if "default" in error.get("detail", "").lower():
                    print(f"✗ Cannot delete default project")
                else:
                    print(f"✗ Access denied")
            elif e.response.status_code == 404:
                print(f"✗ Project not found or already deleted")
            else:
                print(f"✗ HTTP error: {e.response.status_code}")
            raise
 
# Usage
# await delete_project(UUID("a1b2c3d4-e5f6-7890-abcd-ef1234567890"))

interface DeleteProjectResponse {
  message: string;
  project_id: string;
}
 
async function deleteProject(projectId: string): Promise<DeleteProjectResponse> {
  const apiKey = process.env.MARKDOWN_API_KEY;
 
  try {
    const response = await fetch(
      `https://markdownapi.io/api/projects/${projectId}`,
      {
        method: 'DELETE',
        headers: {
          'Authorization': `Bearer ${apiKey!}`,
        },
      }
    );
 
    if (!response.ok) {
      if (response.status === 403) {
        const error = await response.json();
        if (error.detail?.toLowerCase().includes('default')) {
          throw new Error('Cannot delete default project');
        }
        throw new Error('Access denied');
      } else if (response.status === 404) {
        throw new Error('Project not found or already deleted');
      }
      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
    }
 
    const result: DeleteProjectResponse = await response.json();
 
    console.log(`✓ Project deleted: ${result.project_id}`);
    console.log(`  ${result.message}`);
 
    return result;
 
  } catch (error) {
    console.error('✗ Failed to delete project:', error);
    throw error;
  }
}
 
// Usage
// await deleteProject('a1b2c3d4-e5f6-7890-abcd-ef1234567890');

async def delete_project_with_confirmation(project_id: UUID):
    """Delete project with user confirmation."""
    project = await get_project(project_id)
 
    print(f"About to delete project: {project['name']}")
    print(f"  Files: {project['file_count']}")
    print(f"  Size: {project['total_size_bytes']} bytes")
 
    confirm = input("Type project name to confirm deletion: ")
 
    if confirm != project['name']:
        print("✗ Deletion cancelled - name mismatch")
        return None
 
    return await delete_project(project_id)

async def backup_and_delete_project(project_id: UUID, backup_path: str):
    """Backup all files before deleting project."""
    import os
 
    # Get all files
    files = await list_files(project_id)
 
    # Download each file
    for file in files:
        content = await download_file(project_id, file['filename'])
        file_path = os.path.join(backup_path, file['filename'])
        with open(file_path, 'wb') as f:
            f.write(content)
 
    print(f"✓ Backed up {len(files)} files to {backup_path}")
 
    # Delete project
    return await delete_project(project_id)

import asyncio
 
async def delete_multiple_projects(project_ids: list[UUID]):
    """Delete multiple projects (use with caution)."""
 
    async def delete_single(project_id):
        try:
            return await delete_project(project_id)
        except Exception as e:
            print(f"Failed to delete {project_id}: {e}")
            return None
 
    results = await asyncio.gather(*[
        delete_single(pid) for pid in project_ids
    ])
 
    successful = [r for r in results if r is not None]
    print(f"Deleted {len(successful)}/{len(project_ids)} projects")
    return successful

async def safe_delete_project(project_id: UUID):
    """Delete project with safety checks."""
 
    # Check project exists and get details
    try:
        project = await get_project(project_id)
    except httpx.HTTPStatusError as e:
        if e.response.status_code == 404:
            print("✓ Project already deleted")
            return None
        raise
 
    # Check if default
    if project['is_default']:
        raise ValueError("Cannot delete default project")
 
    # Check file count
    if project['file_count'] > 100:
        print(f"⚠ Warning: Project has {project['file_count']} files")
        confirm = input("Continue? (yes/no): ")
        if confirm.lower() != 'yes':
            print("✗ Deletion cancelled")
            return None
 
    # Proceed with deletion
    return await delete_project(project_id)

# This will fail with 403 Forbidden
try:
    await delete_project(default_project_id)
except httpx.HTTPStatusError as e:
    print(e.response.json())
    # {"detail": "Cannot delete default project"}

# Attempting to delete another user's project returns 403
try:
    await delete_project(other_users_project_id)
except httpx.HTTPStatusError as e:
    print(e.response.json())
    # {"detail": "You do not have permission to access this resource"}

# Good practice
await backup_and_delete_project(project_id, "/backups")
 
# Risky
await delete_project(project_id)  # No backup!

# Good - verify before delete
project = await get_project(project_id)
print(f"Deleting: {project['name']}")
await delete_project(project_id)
 
# Risky - delete without verification
await delete_project(project_id)

# Instead of deleting, mark as inactive
await update_project(project_id, name=f"[DELETED] {project['name']}")
# Then later, actually delete when confirmed

async def delete_project_idempotent(project_id: UUID):
    """Delete project with idempotent behavior."""
    try:
        return await delete_project(project_id)
    except httpx.HTTPStatusError as e:
        if e.response.status_code == 404:
            # Already deleted - treat as success
            return {"message": "Project already deleted", "project_id": str(project_id)}
        raise