diff --git a/AGENTS.md b/AGENTS.md
index 3c889631..f5fa8f56 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -108,6 +108,8 @@ cli/
 │       │   ├── prompts.ts        # Prompt utilities
 │       │   ├── theme.ts          # Centralized theme configuration (colors, styles)
 │       │   ├── urls.ts           # URL utilities (getDashboardUrl)
+│       │   ├── json.ts           # JSON output utilities for --json flag
+│       │   ├── log.ts            # Wrapped @clack/prompts log (auto-suppresses in JSON mode)
 │       │   └── index.ts
 │       ├── errors.ts             # CLI-specific errors (CLIExitError)
 │       ├── program.ts            # Commander program definition
@@ -128,11 +130,20 @@ Commands live in `src/cli/commands/`. Follow these steps:
 ```typescript
 // src/cli/commands/<domain>/<action>.ts
 import { Command } from "commander";
-import { log } from "@clack/prompts";
-import { runCommand, runTask, theme } from "../../utils/index.js";
+import { runCommand, runTask, theme, log } from "../../utils/index.js";
 import type { RunCommandResult } from "../../utils/index.js";
 
-async function myAction(): Promise<RunCommandResult> {
+/**
+ * JSON output result for the my-action command.
+ */
+interface MyActionResult {
+  /** The display name of the created resource. */
+  name: string;
+  /** The unique identifier of the created resource. */
+  id: string;
+}
+
+async function myAction(): Promise<RunCommandResult<MyActionResult>> {
   // Use runTask for async operations with spinners
   const result = await runTask(
     "Doing something...",
@@ -147,10 +158,17 @@ async function myAction(): Promise<RunCommandResult> {
     }
   );
 
+  // log.* calls are automatically suppressed in JSON mode
   log.success("Operation completed!");
 
-  // Return an optional outro message (displayed at the end)
-  return { outroMessage: `Created ${theme.styles.bold(result.name)}` };
+  // Return both human-friendly message and structured data for JSON output
+  return {
+    outroMessage: `Created ${theme.styles.bold(result.name)}`,
+    data: {
+      name: result.name,
+      id: result.id,
+    },
+  };
 }
 
 export const myCommand = new Command("<name>")
@@ -367,6 +385,113 @@ base44 deploy -y     # Skip confirmation
 base44 deploy --yes  # Skip confirmation
 ```
 
+## JSON Output Mode
+
+All commands support the `--json` flag for machine-readable output, except `login` and `logout` (user-facing auth commands, rarely scripted).
+
+### Behavior
+
+When `--json` is passed:
+- Suppresses all human-friendly output (banners, spinners, colored text, progress messages)
+- Outputs a single JSON object to stdout
+- Errors output JSON to stderr with exit code 1
+- Interactive prompts are disabled; required flags must be provided
+- Commands that open browsers skip that action (see `dashboard --no-open`)
+
+### JSON Output Structure
+
+```typescript
+// Success response (stdout)
+{
+  "success": true,
+  "data": { /* command-specific result */ }
+}
+
+// Error response (stderr)
+{
+  "success": false,
+  "error": {
+    "message": "Error description",
+    "code": "ERROR_CODE" // optional
+  }
+}
+```
+
+### Implementation Requirements
+
+When creating new commands:
+
+1. **Define a typed result interface** after the options interface:
+
+```typescript
+interface MyCommandOptions {
+  flag?: boolean;
+}
+
+/**
+ * JSON output result for the my-command command.
+ */
+interface MyCommandResult {
+  /** The unique identifier of the created resource. */
+  resourceId: string;
+  /** The URL to access the resource. */
+  resourceUrl: string;
+}
+```
+
+2. **Return structured `data`** with the typed `RunCommandResult<T>`:
+
+```typescript
+async function myAction(): Promise<RunCommandResult<MyCommandResult>> {
+  // ... do work ...
+  return {
+    outroMessage: "Human-friendly message",
+    data: {
+      resourceId: "abc123",
+      resourceUrl: "https://...",
+    },
+  };
+}
+```
+
+For commands that don't support `--json` (like `login`, `logout`), use `never`:
+
+```typescript
+async function login(): Promise<RunCommandResult<never>> {
+  // ... interactive auth flow ...
+  return { outroMessage: "Logged in successfully" };
+}
+```
+
+3. **Use wrapped `log` from utils** - The wrapped `log` automatically suppresses output in JSON mode:
+
+```typescript
+import { log } from "../../utils/index.js";
+
+// No need to check isJsonMode() - log is automatically suppressed
+log.info("Found 5 entities to push");
+```
+
+4. **Handle interactive prompts** - In JSON mode, either:
+   - Require flags that provide the same information (fail early with clear error)
+   - Auto-confirm prompts (for non-destructive actions)
+
+5. **Validate required flags** in `preAction` hook (throw errors, never use `command.error()`):
+
+```typescript
+function validateFlags(command: Command): void {
+  const opts = command.optsWithGlobals<Options & { json?: boolean }>();
+  if (opts.json && !opts.requiredFlag) {
+    throw new Error("JSON mode requires: --required-flag");
+  }
+}
+```
+
+### Exceptions
+
+- `login`: Does not support `--json` (interactive browser authentication)
+- `logout`: Does not support `--json` (user-facing command, rarely scripted)
+
 ## Path Aliases
 
 Single alias defined in `tsconfig.json`:
@@ -392,7 +517,10 @@ import { base44Client } from "@core/api/index.js";
 10. **Zero-dependency distribution** - All packages go in `devDependencies`; they get bundled at build time
 11. **Use theme for styling** - Never use `chalk` directly in commands; import `theme` from utils and use semantic color/style names
 12. **Use fs.ts utilities** - Always use `@core/utils/fs.js` for file operations
-13. **No direct process.exit()** - Throw `CLIExitError` instead; entry points handle the actual exit 
+13. **No direct process.exit()** - Throw `CLIExitError` instead; entry points handle the actual exit
+14. **JSON output support** - Commands must return `data` in `RunCommandResult`
+15. **Never use `command.error()`** - Always use `throw new Error()` instead; errors are caught globally and output as JSON when `--json` is used
+16. **Use wrapped log for output** - Import `log` from `../../utils/index.js`, not from `@clack/prompts`. The wrapped `log` automatically suppresses output in JSON mode. Only use `isJsonMode()` directly for non-logging decisions (prompts, browser opens)
 
 ## Development
 
diff --git a/bin/dev.js b/bin/dev.js
index 76f2de09..448f155a 100755
--- a/bin/dev.js
+++ b/bin/dev.js
@@ -1,5 +1,6 @@
 #!/usr/bin/env tsx
-import { program, CLIExitError } from "../src/cli/index.ts";
+import { CommanderError } from "commander";
+import { program, CLIExitError, isJsonMode, outputJsonError } from "../src/cli/index.ts";
 
 try {
   await program.parseAsync();
@@ -7,6 +8,23 @@ try {
   if (error instanceof CLIExitError) {
     process.exit(error.code);
   }
-  console.error(error);
+
+  if (error instanceof CommanderError) {
+    if (isJsonMode()) {
+      outputJsonError(error.message, error.code);
+    }
+    // Non-JSON mode: Commander already output the error via configureOutput
+    process.exit(error.exitCode);
+  }
+
+  // Handle all other errors
+  if (isJsonMode()) {
+    outputJsonError(error instanceof Error ? error : String(error));
+    process.exit(1);
+  }
+
+  // Non-JSON mode: show clean error message
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`error: ${message}`);
   process.exit(1);
 }
diff --git a/bin/run.js b/bin/run.js
index 33a48126..dffa7db4 100755
--- a/bin/run.js
+++ b/bin/run.js
@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-import { program, CLIExitError } from "../dist/index.js";
+import { CommanderError } from "commander";
+import { program, CLIExitError, isJsonMode, outputJsonError } from "../dist/index.js";
 
 try {
   await program.parseAsync();
@@ -7,6 +8,23 @@ try {
   if (error instanceof CLIExitError) {
     process.exit(error.code);
   }
-  console.error(error);
+
+  if (error instanceof CommanderError) {
+    if (isJsonMode()) {
+      outputJsonError(error.message, error.code);
+    }
+    // Non-JSON mode: Commander already output the error via configureOutput
+    process.exit(error.exitCode);
+  }
+
+  // Handle all other errors
+  if (isJsonMode()) {
+    outputJsonError(error instanceof Error ? error : String(error));
+    process.exit(1);
+  }
+
+  // Non-JSON mode: show clean error message
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`error: ${message}`);
   process.exit(1);
 }
diff --git a/src/cli/commands/auth/login.ts b/src/cli/commands/auth/login.ts
index cae9edaa..ff55ddb5 100644
--- a/src/cli/commands/auth/login.ts
+++ b/src/cli/commands/auth/login.ts
@@ -1,5 +1,4 @@
 import { Command } from "commander";
-import { log } from "@clack/prompts";
 import pWaitFor from "p-wait-for";
 import {
   writeAuth,
@@ -12,10 +11,15 @@ import type {
   TokenResponse,
   UserInfoResponse,
 } from "@core/auth/index.js";
-import { runCommand, runTask } from "../../utils/index.js";
+import { runCommand, runTask, log } from "../../utils/index.js";
 import type { RunCommandResult } from "../../utils/runCommand.js";
 import { theme } from "../../utils/theme.js";
 
+/**
+ * Login command does not support --json output.
+ * It requires interactive browser authentication via device code flow.
+ */
+
 async function generateAndDisplayDeviceCode(): Promise<DeviceCodeResponse> {
   const deviceCodeResponse = await runTask(
     "Generating device code...",
@@ -96,7 +100,7 @@ async function saveAuthData(
   });
 }
 
-export async function login(): Promise<RunCommandResult> {
+export async function login(): Promise<RunCommandResult<never>> {
   const deviceCodeResponse = await generateAndDisplayDeviceCode();
 
   const token = await waitForAuthentication(
diff --git a/src/cli/commands/auth/logout.ts b/src/cli/commands/auth/logout.ts
index 6781ab38..df67c373 100644
--- a/src/cli/commands/auth/logout.ts
+++ b/src/cli/commands/auth/logout.ts
@@ -3,7 +3,11 @@ import { deleteAuth } from "@core/auth/index.js";
 import { runCommand } from "../../utils/index.js";
 import type { RunCommandResult } from "../../utils/runCommand.js";
 
-async function logout(): Promise<RunCommandResult> {
+/**
+ * Logout command does not support --json output.
+ * It is a user-facing auth command that is rarely scripted.
+ */
+async function logout(): Promise<RunCommandResult<never>> {
   await deleteAuth();
   return { outroMessage: "Logged out successfully" };
 }
diff --git a/src/cli/commands/auth/whoami.ts b/src/cli/commands/auth/whoami.ts
index a3770009..9fe173ea 100644
--- a/src/cli/commands/auth/whoami.ts
+++ b/src/cli/commands/auth/whoami.ts
@@ -3,9 +3,25 @@ import { readAuth } from "@core/auth/index.js";
 import { runCommand, theme } from "../../utils/index.js";
 import type { RunCommandResult } from "../../utils/runCommand.js";
 
-async function whoami(): Promise<RunCommandResult> {
+/**
+ * JSON output result for the whoami command.
+ */
+interface WhoamiResult {
+  /** The email address of the authenticated user. */
+  email: string;
+  /** The display name of the authenticated user. */
+  name: string;
+}
+
+async function whoami(): Promise<RunCommandResult<WhoamiResult>> {
   const auth = await readAuth();
-  return { outroMessage: `Logged in as: ${theme.styles.bold(auth.email)}` };
+  return {
+    outroMessage: `Logged in as: ${theme.styles.bold(auth.email)}`,
+    data: {
+      email: auth.email,
+      name: auth.name,
+    },
+  };
 }
 
 export const whoamiCommand = new Command("whoami")
diff --git a/src/cli/commands/entities/push.ts b/src/cli/commands/entities/push.ts
index 65f70c65..e3d94ff4 100644
--- a/src/cli/commands/entities/push.ts
+++ b/src/cli/commands/entities/push.ts
@@ -1,15 +1,29 @@
 import { Command } from "commander";
-import { log } from "@clack/prompts";
 import { pushEntities } from "@core/resources/entity/index.js";
 import { readProjectConfig } from "@core/index.js";
-import { runCommand, runTask } from "../../utils/index.js";
+import { runCommand, runTask, log } from "../../utils/index.js";
 import type { RunCommandResult } from "../../utils/runCommand.js";
 
-async function pushEntitiesAction(): Promise<RunCommandResult> {
+/**
+ * JSON output result for the entities push command.
+ */
+interface EntitiesPushResult {
+  /** Names of entities that were newly created. */
+  created: string[];
+  /** Names of entities that were updated. */
+  updated: string[];
+  /** Names of entities that were deleted. */
+  deleted: string[];
+}
+
+async function pushEntitiesAction(): Promise<RunCommandResult<EntitiesPushResult>> {
   const { entities } = await readProjectConfig();
 
   if (entities.length === 0) {
-    return { outroMessage: "No entities found in project" };
+    return {
+      outroMessage: "No entities found in project",
+      data: { created: [], updated: [], deleted: [] },
+    };
   }
 
   log.info(`Found ${entities.length} entities to push`);
@@ -25,7 +39,6 @@ async function pushEntitiesAction(): Promise<RunCommandResult> {
     }
   );
 
-  // Print the results
   if (result.created.length > 0) {
     log.success(`Created: ${result.created.join(", ")}`);
   }
@@ -36,7 +49,13 @@ async function pushEntitiesAction(): Promise<RunCommandResult> {
     log.warn(`Deleted: ${result.deleted.join(", ")}`);
   }
 
-  return {};
+  return {
+    data: {
+      created: result.created,
+      updated: result.updated,
+      deleted: result.deleted,
+    },
+  };
 }
 
 export const entitiesPushCommand = new Command("entities")
diff --git a/src/cli/commands/functions/deploy.ts b/src/cli/commands/functions/deploy.ts
index ea9818f4..eddc59ec 100644
--- a/src/cli/commands/functions/deploy.ts
+++ b/src/cli/commands/functions/deploy.ts
@@ -1,17 +1,27 @@
 import { Command } from "commander";
-import { log } from "@clack/prompts";
 import { pushFunctions } from "@core/resources/function/index.js";
 import { readProjectConfig } from "@core/index.js";
-import { runCommand, runTask } from "../../utils/index.js";
+import { runCommand, runTask, log } from "../../utils/index.js";
 import type { RunCommandResult } from "../../utils/runCommand.js";
 
-async function deployFunctionsAction(): Promise<RunCommandResult> {
+/**
+ * JSON output result for the functions deploy command.
+ */
+interface FunctionsDeployResult {
+  /** Names of functions that were successfully deployed. */
+  deployed: string[];
+  /** Names of functions that were deleted from the server. */
+  deleted: string[];
+}
+
+async function deployFunctionsAction(): Promise<RunCommandResult<FunctionsDeployResult>> {
   const { functions } = await readProjectConfig();
 
   if (functions.length === 0) {
     return {
       outroMessage:
         "No functions found. Create functions in the 'functions' directory.",
+      data: { deployed: [], deleted: [] },
     };
   }
 
@@ -36,6 +46,7 @@ async function deployFunctionsAction(): Promise<RunCommandResult> {
   if (result.deleted.length > 0) {
     log.warn(`Deleted: ${result.deleted.join(", ")}`);
   }
+
   if (result.errors && result.errors.length > 0) {
     const errorMessages = result.errors
       .map((e) => `'${e.name}' function: ${e.message}`)
@@ -43,7 +54,12 @@ async function deployFunctionsAction(): Promise<RunCommandResult> {
     throw new Error(`Function deployment errors:\n${errorMessages}`);
   }
 
-  return {};
+  return {
+    data: {
+      deployed: result.deployed,
+      deleted: result.deleted,
+    },
+  };
 }
 
 export const functionsDeployCommand = new Command("functions")
diff --git a/src/cli/commands/project/create.ts b/src/cli/commands/project/create.ts
index 235e3df0..afd383ce 100644
--- a/src/cli/commands/project/create.ts
+++ b/src/cli/commands/project/create.ts
@@ -1,7 +1,7 @@
 import { resolve, join } from "node:path";
 import { execa } from "execa";
 import { Command } from "commander";
-import { log, group, text, select, confirm, isCancel } from "@clack/prompts";
+import { group, text, select, confirm, isCancel } from "@clack/prompts";
 import type { Option } from "@clack/prompts";
 import kebabCase from "lodash.kebabcase";
 import { createProjectFiles, listTemplates, readProjectConfig, setAppConfig } from "@core/project/index.js";
@@ -13,6 +13,7 @@ import {
   onPromptCancel,
   theme,
   getDashboardUrl,
+  log,
 } from "../../utils/index.js";
 import type { RunCommandResult } from "../../utils/runCommand.js";
 
@@ -27,6 +28,20 @@ interface CreateOptions {
   skills?: boolean;
 }
 
+/**
+ * JSON output result for the create command.
+ */
+interface CreateResult {
+  /** The unique identifier of the created project. */
+  projectId: string;
+  /** The absolute path where the project was created. */
+  path: string;
+  /** The URL to the project dashboard. */
+  dashboardUrl: string;
+  /** The public URL where the site is hosted (if deployed). */
+  appUrl?: string;
+}
+
 async function getTemplateById(templateId: string): Promise<Template> {
   const templates = await listTemplates();
   const template = templates.find((t) => t.id === templateId);
@@ -38,11 +53,18 @@ async function getTemplateById(templateId: string): Promise<Template> {
 }
 
 function validateNonInteractiveFlags(command: Command): void {
-  const { name, path } = command.opts<CreateOptions>();
+  const opts = command.optsWithGlobals<CreateOptions & { json?: boolean }>();
+  const { name, path, json } = opts;
   const providedCount = [name, path].filter(Boolean).length;
 
+  // In JSON mode, all flags are required (no interactive prompts)
+  if (json && providedCount < 2) {
+    throw new Error("JSON mode requires all flags: --name, --path");
+  }
+
+  // In non-interactive mode (some flags provided), all must be provided
   if (providedCount > 0 && providedCount < 2) {
-    command.error("Non-interactive mode requires all flags: --name, --path");
+    throw new Error("Non-interactive mode requires all flags: --name, --path");
   }
 }
 
@@ -56,7 +78,7 @@ async function chooseCreate(options: CreateOptions): Promise<void> {
   }
 }
 
-async function createInteractive(options: CreateOptions): Promise<RunCommandResult> {
+async function createInteractive(options: CreateOptions): Promise<RunCommandResult<CreateResult>> {
   const templates = await listTemplates();
   const templateOptions: Array<Option<Template>> = templates.map((t) => ({
     value: t,
@@ -111,7 +133,7 @@ async function createInteractive(options: CreateOptions): Promise<RunCommandResu
   });
 }
 
-async function createNonInteractive(options: CreateOptions): Promise<RunCommandResult> {
+async function createNonInteractive(options: CreateOptions): Promise<RunCommandResult<CreateResult>> {
   const template = await getTemplateById(options.template ?? DEFAULT_TEMPLATE_ID);
 
   return await executeCreate({
@@ -141,7 +163,7 @@ async function executeCreate({
   deploy?: boolean;
   skills?: boolean;
   isInteractive: boolean;
-}): Promise<RunCommandResult> {
+}): Promise<RunCommandResult<CreateResult>> {
   const name = rawName.trim();
   const resolvedPath = resolve(projectPath);
 
@@ -229,7 +251,7 @@ async function executeCreate({
     }
   }
 
-  // Add AI agent skills
+// Add AI agent skills
   let shouldAddSkills = false;
 
   if (isInteractive) {
@@ -257,14 +279,24 @@ async function executeCreate({
     );
   }
 
+  const dashboardUrl = getDashboardUrl(projectId);
+
   log.message(`${theme.styles.header("Project")}: ${theme.colors.base44Orange(name)}`);
-  log.message(`${theme.styles.header("Dashboard")}: ${theme.colors.links(getDashboardUrl(projectId))}`);
+  log.message(`${theme.styles.header("Dashboard")}: ${theme.colors.links(dashboardUrl)}`);
 
   if (finalAppUrl) {
     log.message(`${theme.styles.header("Site")}: ${theme.colors.links(finalAppUrl)}`);
   }
 
-  return { outroMessage: "Your project is set up and ready to use" };
+  return {
+    outroMessage: "Your project is set up and ready to use",
+    data: {
+      projectId,
+      path: resolvedPath,
+      dashboardUrl,
+      ...(finalAppUrl && { appUrl: finalAppUrl }),
+    },
+  };
 }
 
 export const createCommand = new Command("create")
diff --git a/src/cli/commands/project/dashboard.ts b/src/cli/commands/project/dashboard.ts
index 968fa8f3..1a063ce7 100644
--- a/src/cli/commands/project/dashboard.ts
+++ b/src/cli/commands/project/dashboard.ts
@@ -1,18 +1,43 @@
 import { Command } from "commander";
 import open from "open";
-import { runCommand, getDashboardUrl } from "../../utils/index.js";
+import { runCommand, getDashboardUrl, isJsonMode } from "../../utils/index.js";
 import type { RunCommandResult } from "../../utils/runCommand.js";
 
-async function openDashboard(): Promise<RunCommandResult> {
+interface DashboardOptions {
+  open?: boolean;
+}
+
+/**
+ * JSON output result for the dashboard command.
+ */
+interface DashboardResult {
+  /** The URL to the project dashboard. */
+  dashboardUrl: string;
+}
+
+async function openDashboard(options: DashboardOptions): Promise<RunCommandResult<DashboardResult>> {
   const dashboardUrl = getDashboardUrl();
 
-  await open(dashboardUrl);
+  // Skip opening browser in JSON mode or with --no-open flag
+  const shouldOpen = !isJsonMode() && options.open !== false;
+
+  if (shouldOpen) {
+    await open(dashboardUrl);
+  }
 
-  return { outroMessage: `Dashboard opened at ${dashboardUrl}` };
+  return {
+    outroMessage: shouldOpen
+      ? `Dashboard opened at ${dashboardUrl}`
+      : `Dashboard URL: ${dashboardUrl}`,
+    data: {
+      dashboardUrl,
+    },
+  };
 }
 
 export const dashboardCommand = new Command("dashboard")
   .description("Open the app dashboard in your browser")
-  .action(async () => {
-    await runCommand(openDashboard, { requireAuth: true });
+  .option("--no-open", "Print the URL without opening the browser")
+  .action(async (options: DashboardOptions) => {
+    await runCommand(() => openDashboard(options), { requireAuth: true });
   });
diff --git a/src/cli/commands/project/deploy.ts b/src/cli/commands/project/deploy.ts
index dfc0c507..8b381b25 100644
--- a/src/cli/commands/project/deploy.ts
+++ b/src/cli/commands/project/deploy.ts
@@ -1,23 +1,54 @@
 import { Command } from "commander";
-import { confirm, isCancel, log } from "@clack/prompts";
+import { confirm, isCancel } from "@clack/prompts";
 import {
   readProjectConfig,
   deployAll,
   hasResourcesToDeploy,
 } from "@core/project/index.js";
-import { runCommand, runTask, theme, getDashboardUrl } from "../../utils/index.js";
+import { runCommand, runTask, theme, getDashboardUrl, isJsonMode, log } from "../../utils/index.js";
 import type { RunCommandResult } from "../../utils/runCommand.js";
 
 interface DeployOptions {
   yes?: boolean;
 }
 
-async function deployAction(options: DeployOptions): Promise<RunCommandResult> {
+/**
+ * JSON output result for the deploy command.
+ */
+interface DeployResult {
+  /** The URL to the project dashboard. */
+  dashboardUrl: string;
+  /** The public URL where the site is hosted (if site was deployed). */
+  appUrl?: string;
+  /** Number of entities deployed. */
+  entitiesCount: number;
+  /** Number of functions deployed. */
+  functionsCount: number;
+  /** Whether the site was deployed. */
+  siteDeployed: boolean;
+  /** True if the deployment was cancelled by the user. */
+  cancelled?: boolean;
+}
+
+function validateNonInteractiveFlags(command: Command): void {
+  const opts = command.optsWithGlobals<DeployOptions & { json?: boolean }>();
+  if (opts.json && !opts.yes) {
+    throw new Error("JSON mode requires: --yes (-y) to skip confirmation");
+  }
+}
+
+async function deployAction(options: DeployOptions): Promise<RunCommandResult<DeployResult>> {
   const projectData = await readProjectConfig();
 
   if (!hasResourcesToDeploy(projectData)) {
     return {
       outroMessage: "No resources found to deploy",
+      data: {
+        dashboardUrl: getDashboardUrl(),
+        entitiesCount: 0,
+        functionsCount: 0,
+        siteDeployed: false,
+      },
     };
   }
 
@@ -35,7 +66,7 @@ async function deployAction(options: DeployOptions): Promise<RunCommandResult> {
     summaryLines.push(`  - Site from ${project.site.outputDirectory}`);
   }
 
-  // Confirmation prompt
+  // Confirmation prompt (skipped in JSON mode due to validateNonInteractiveFlags)
   if (!options.yes) {
     log.warn(
       `This will update your Base44 app with:\n${summaryLines.join("\n")}`
@@ -46,9 +77,18 @@ async function deployAction(options: DeployOptions): Promise<RunCommandResult> {
     });
 
     if (isCancel(shouldDeploy) || !shouldDeploy) {
-      return { outroMessage: "Deployment cancelled" };
+      return {
+        outroMessage: "Deployment cancelled",
+        data: {
+          dashboardUrl: getDashboardUrl(),
+          entitiesCount: entities.length,
+          functionsCount: functions.length,
+          siteDeployed: false,
+          cancelled: true,
+        },
+      };
     }
-  } else {
+  } else if (!isJsonMode()) {
     log.info(`Deploying:\n${summaryLines.join("\n")}`);
   }
 
@@ -63,17 +103,29 @@ async function deployAction(options: DeployOptions): Promise<RunCommandResult> {
     }
   );
 
-  log.message(`${theme.styles.header("Dashboard")}: ${theme.colors.links(getDashboardUrl())}`);
+  const dashboardUrl = getDashboardUrl();
+
+  log.message(`${theme.styles.header("Dashboard")}: ${theme.colors.links(dashboardUrl)}`);
   if (result.appUrl) {
     log.message(`${theme.styles.header("App URL")}: ${theme.colors.links(result.appUrl)}`);
   }
 
-  return { outroMessage: "App deployed successfully" };
+  return {
+    outroMessage: "App deployed successfully",
+    data: {
+      dashboardUrl,
+      appUrl: result.appUrl,
+      entitiesCount: entities.length,
+      functionsCount: functions.length,
+      siteDeployed: !!project.site?.outputDirectory,
+    },
+  };
 }
 
 export const deployCommand = new Command("deploy")
   .description("Deploy all project resources (entities, functions, and site)")
   .option("-y, --yes", "Skip confirmation prompt")
+  .hook("preAction", validateNonInteractiveFlags)
   .action(async (options: DeployOptions) => {
     await runCommand(() => deployAction(options), { requireAuth: true });
   });
diff --git a/src/cli/commands/project/link.ts b/src/cli/commands/project/link.ts
index 596342b7..33bd5dd8 100644
--- a/src/cli/commands/project/link.ts
+++ b/src/cli/commands/project/link.ts
@@ -1,5 +1,5 @@
 import { Command } from "commander";
-import { log, group, text, select, isCancel, cancel } from "@clack/prompts";
+import { group, text, select, isCancel, cancel } from "@clack/prompts";
 import type { Option } from "@clack/prompts";
 import {
   findProjectRoot,
@@ -16,6 +16,7 @@ import {
   onPromptCancel,
   theme,
   getDashboardUrl,
+  log,
 } from "../../utils/index.js";
 import type { RunCommandResult } from "../../utils/runCommand.js";
 
@@ -26,17 +27,33 @@ interface LinkOptions {
   projectId?: string;
 }
 
+/**
+ * JSON output result for the link command.
+ */
+interface LinkResult {
+  /** The unique identifier of the linked project. */
+  projectId: string;
+  /** The URL to the project dashboard. */
+  dashboardUrl: string;
+}
+
 type LinkAction = "create" | "choose";
 
 function validateNonInteractiveFlags(command: Command): void {
-  const { create, name, projectId } = command.opts<LinkOptions>();
+  const opts = command.optsWithGlobals<LinkOptions & { json?: boolean }>();
+  const { create, name, projectId, json } = opts;
 
   if (create && projectId) {
-    command.error("--create and --projectId cannot be used together");
+    throw new Error("--create and --projectId cannot be used together");
   }
 
   if (create && !name) {
-    command.error("--name is required when using --create");
+    throw new Error("--name is required when using --create");
+  }
+
+  // In JSON mode, either --create with --name OR --projectId is required
+  if (json && !create && !projectId) {
+    throw new Error("JSON mode requires flags: --create and --name, or --projectId");
   }
 }
 
@@ -118,7 +135,7 @@ async function promptForExistingProject(linkableProjects: Project[]): Promise<Pr
   return selectedProject;
 }
 
-async function link(options: LinkOptions): Promise<RunCommandResult> {
+async function link(options: LinkOptions): Promise<RunCommandResult<LinkResult>> {
   const projectRoot = await findProjectRoot();
 
   if (!projectRoot) {
@@ -149,7 +166,7 @@ async function link(options: LinkOptions): Promise<RunCommandResult> {
     const linkableProjects = projects.filter((p) => p.isManagedSourceCode !== true);
 
     if (!linkableProjects.length) {
-      return { outroMessage: "No projects available for linking" };
+      throw new Error("No projects available for linking");
     }
 
     let projectId: string;
@@ -208,8 +225,17 @@ async function link(options: LinkOptions): Promise<RunCommandResult> {
     finalProjectId = projectId;
   }
 
-  log.message(`${theme.styles.header("Dashboard")}: ${theme.colors.links(getDashboardUrl(finalProjectId))}`);
-  return { outroMessage: "Project linked" };
+  const dashboardUrl = getDashboardUrl(finalProjectId);
+
+  log.message(`${theme.styles.header("Dashboard")}: ${theme.colors.links(dashboardUrl)}`);
+
+  return {
+    outroMessage: "Project linked",
+    data: {
+      projectId: finalProjectId!,
+      dashboardUrl,
+    },
+  };
 }
 
 export const linkCommand = new Command("link")
diff --git a/src/cli/commands/site/deploy.ts b/src/cli/commands/site/deploy.ts
index 11d09535..e3c8a2a8 100644
--- a/src/cli/commands/site/deploy.ts
+++ b/src/cli/commands/site/deploy.ts
@@ -3,14 +3,24 @@ import { Command } from "commander";
 import { confirm, isCancel } from "@clack/prompts";
 import { readProjectConfig } from "@core/project/index.js";
 import { deploySite } from "@core/site/index.js";
-import { runCommand, runTask } from "../../utils/index.js";
+import { runCommand, runTask, isJsonMode } from "../../utils/index.js";
 import type { RunCommandResult } from "../../utils/runCommand.js";
 
 interface DeployOptions {
   yes?: boolean;
 }
 
-async function deployAction(options: DeployOptions): Promise<RunCommandResult> {
+/**
+ * JSON output result for the site deploy command.
+ */
+interface SiteDeployResult {
+  /** The public URL where the site is hosted. */
+  appUrl?: string;
+  /** True if the deployment was cancelled by the user. */
+  cancelled?: boolean;
+}
+
+async function deployAction(options: DeployOptions): Promise<RunCommandResult<SiteDeployResult>> {
   const { project } = await readProjectConfig();
 
   if (!project.site?.outputDirectory) {
@@ -21,13 +31,17 @@ async function deployAction(options: DeployOptions): Promise<RunCommandResult> {
 
   const outputDir = resolve(project.root, project.site.outputDirectory);
 
-  if (!options.yes) {
+  // Skip confirmation in JSON mode (no interactive prompts) or with --yes flag
+  if (!options.yes && !isJsonMode()) {
     const shouldDeploy = await confirm({
       message: `Deploy site from ${project.site.outputDirectory}?`,
     });
 
     if (isCancel(shouldDeploy) || !shouldDeploy) {
-      return { outroMessage: "Deployment cancelled" };
+      return {
+        outroMessage: "Deployment cancelled",
+        data: { cancelled: true },
+      };
     }
   }
 
@@ -42,7 +56,12 @@ async function deployAction(options: DeployOptions): Promise<RunCommandResult> {
     }
   );
 
-  return { outroMessage: `Visit your site at: ${result.appUrl}` };
+  return {
+    outroMessage: `Visit your site at: ${result.appUrl}`,
+    data: {
+      appUrl: result.appUrl,
+    },
+  };
 }
 
 export const siteDeployCommand = new Command("site")
diff --git a/src/cli/index.ts b/src/cli/index.ts
index e3bb43a3..db8ea2ba 100644
--- a/src/cli/index.ts
+++ b/src/cli/index.ts
@@ -1,2 +1,3 @@
 export { program } from "./program.js";
 export { CLIExitError } from "./errors.js";
+export { isJsonMode, outputJsonError } from "./utils/json.js";
diff --git a/src/cli/program.ts b/src/cli/program.ts
index ef42b78a..8c048519 100644
--- a/src/cli/program.ts
+++ b/src/cli/program.ts
@@ -9,20 +9,53 @@ import { dashboardCommand } from "./commands/project/dashboard.js";
 import { deployCommand } from "./commands/project/deploy.js";
 import { linkCommand } from "./commands/project/link.js";
 import { siteDeployCommand } from "./commands/site/deploy.js";
+import { setJsonMode, isJsonMode } from "./utils/json.js";
 import packageJson from "../../package.json";
 
+// Detect --json flag early from process.argv before Commander parses
+// This is needed because configureOutput runs before preAction hooks
+const isJsonFromArgv = process.argv.includes("--json");
+if (isJsonFromArgv) {
+  setJsonMode(true);
+}
+
 const program = new Command();
 
+// Configure Commander to throw instead of calling process.exit()
+// This allows us to catch errors and output JSON when appropriate
+program.exitOverride();
+
+// Configure output to suppress default error messages in JSON mode
+// We handle error output ourselves in the entry points
+program.configureOutput({
+  outputError: (str, write) => {
+    if (isJsonMode()) {
+      // Don't write default error - entry points will handle it
+      return;
+    }
+    write(str);
+  },
+});
+
 program
   .name("base44")
   .description(
     "Base44 CLI - Unified interface for managing Base44 applications"
   )
-  .version(packageJson.version);
+  .version(packageJson.version)
+  .option("--json", "Output results as JSON (for scripting)");
+
+// Set JSON mode before any command runs (backup for preAction validation)
+program.hook("preAction", (thisCommand) => {
+  const opts = thisCommand.optsWithGlobals();
+  if (opts.json) {
+    setJsonMode(true);
+  }
+});
 
 program.configureHelp({
-  sortSubcommands: true
-})
+  sortSubcommands: true,
+});
 
 // Register authentication commands
 program.addCommand(loginCommand);
diff --git a/src/cli/utils/index.ts b/src/cli/utils/index.ts
index 2eb6e9b7..96dad569 100644
--- a/src/cli/utils/index.ts
+++ b/src/cli/utils/index.ts
@@ -4,3 +4,5 @@ export * from "./prompts.js";
 export * from "./banner.js";
 export * from "./theme.js";
 export * from "./urls.js";
+export * from "./json.js";
+export * from "./log.js";
\ No newline at end of file
diff --git a/src/cli/utils/json.ts b/src/cli/utils/json.ts
new file mode 100644
index 00000000..a026a67b
--- /dev/null
+++ b/src/cli/utils/json.ts
@@ -0,0 +1,80 @@
+/**
+ * JSON output utilities for CLI commands.
+ *
+ * These utilities support the `--json` flag which outputs machine-readable JSON
+ * instead of human-friendly formatted output.
+ */
+
+let jsonModeEnabled = false;
+
+/**
+ * Enable JSON output mode. Called by runCommand when --json flag is detected.
+ */
+export function setJsonMode(enabled: boolean): void {
+  jsonModeEnabled = enabled;
+}
+
+/**
+ * Check if JSON output mode is currently active.
+ */
+export function isJsonMode(): boolean {
+  return jsonModeEnabled;
+}
+
+/**
+ * JSON success response structure.
+ */
+export interface JsonSuccessResponse {
+  success: true;
+  data: Record<string, unknown>;
+}
+
+/**
+ * JSON error response structure.
+ */
+export interface JsonErrorResponse {
+  success: false;
+  error: {
+    message: string;
+    code?: string;
+  };
+}
+
+/**
+ * Output a success JSON response to stdout.
+ * Only outputs if JSON mode is enabled.
+ */
+export function outputJson(data: Record<string, unknown>): void {
+  if (!jsonModeEnabled) {
+    return;
+  }
+
+  const response: JsonSuccessResponse = {
+    success: true,
+    data,
+  };
+  console.log(JSON.stringify(response, null, 2));
+}
+
+/**
+ * Output an error JSON response to stderr.
+ * Only outputs if JSON mode is enabled.
+ *
+ * @param error - The error to output
+ * @param code - Optional error code
+ */
+export function outputJsonError(error: Error | string, code?: string): void {
+  if (!jsonModeEnabled) {
+    return;
+  }
+
+  const message = error instanceof Error ? error.message : error;
+  const response: JsonErrorResponse = {
+    success: false,
+    error: {
+      message,
+      ...(code && { code }),
+    },
+  };
+  console.error(JSON.stringify(response, null, 2));
+}
diff --git a/src/cli/utils/log.ts b/src/cli/utils/log.ts
new file mode 100644
index 00000000..a681ed8f
--- /dev/null
+++ b/src/cli/utils/log.ts
@@ -0,0 +1,37 @@
+/**
+ * Wrapped @clack/prompts log that auto-suppresses in JSON mode.
+ *
+ * Import `log` from this file (via utils/index.ts) instead of @clack/prompts
+ * to automatically suppress output when --json flag is used.
+ */
+import { log as clackLog } from "@clack/prompts";
+import { isJsonMode } from "./json.js";
+
+type LogMessage = typeof clackLog.message;
+type LogInfo = typeof clackLog.info;
+
+function wrapMessage(method: LogMessage): LogMessage {
+  return (message, opts) => {
+    if (!isJsonMode()) {
+      method(message, opts);
+    }
+  };
+}
+
+function wrapSimple(method: LogInfo): LogInfo {
+  return (message) => {
+    if (!isJsonMode()) {
+      method(message);
+    }
+  };
+}
+
+export const log = {
+  message: wrapMessage(clackLog.message),
+  info: wrapSimple(clackLog.info),
+  success: wrapSimple(clackLog.success),
+  step: wrapSimple(clackLog.step),
+  warn: wrapSimple(clackLog.warn),
+  warning: wrapSimple(clackLog.warning),
+  error: wrapSimple(clackLog.error),
+};
diff --git a/src/cli/utils/runCommand.ts b/src/cli/utils/runCommand.ts
index e6ae72fd..9dc92629 100644
--- a/src/cli/utils/runCommand.ts
+++ b/src/cli/utils/runCommand.ts
@@ -5,6 +5,7 @@ import { CLIExitError } from "../errors.js";
 import { printBanner } from "./banner.js";
 import { login } from "../commands/auth/login.js";
 import { theme } from "./theme.js";
+import { isJsonMode, outputJson, outputJsonError } from "./json.js";
 
 export interface RunCommandOptions {
   /**
@@ -27,9 +28,25 @@ export interface RunCommandOptions {
   requireAppConfig?: boolean;
 }
 
-export interface RunCommandResult {
+/**
+ * Result returned by command functions.
+ *
+ * @template TData - The shape of the JSON output data. Use `never` for commands
+ *                   that don't support `--json` output (e.g., login, logout).
+ */
+export interface RunCommandResult<TData = Record<string, unknown>> {
+  /**
+   * Human-friendly message displayed in the outro (non-JSON mode only).
+   */
   outroMessage?: string;
-};
+  /**
+   * Structured data for JSON output. When `--json` flag is used,
+   * this data is output as `{ success: true, data: ... }`.
+   *
+   * Commands that don't support `--json` should use `never` for TData.
+   */
+  data?: TData;
+}
 
 /**
  * Wraps a command function with the Base44 intro/outro and error handling.
@@ -61,17 +78,22 @@ export interface RunCommandResult {
  *     await runCommand(myAction, { requireAuth: true, fullBanner: true });
  *   });
  */
-export async function runCommand(
-  commandFn: () => Promise<RunCommandResult>,
+export async function runCommand<TData = Record<string, unknown>>(
+  commandFn: () => Promise<RunCommandResult<TData>>,
   options?: RunCommandOptions
 ): Promise<void> {
-  console.log();
+  const jsonMode = isJsonMode();
 
-  if (options?.fullBanner) {
-    await printBanner();
-    intro("");
-  } else {
-    intro(theme.colors.base44OrangeBackground(" Base 44 "));
+  // Skip visual elements in JSON mode
+  if (!jsonMode) {
+    console.log();
+
+    if (options?.fullBanner) {
+      await printBanner();
+      intro("");
+    } else {
+      intro(theme.colors.base44OrangeBackground(" Base 44 "));
+    }
   }
 
   try {
@@ -80,6 +102,9 @@ export async function runCommand(
       const loggedIn = await isLoggedIn();
 
       if (!loggedIn) {
+        if (jsonMode) {
+          throw new Error("Authentication required. Please run 'base44 login' first.");
+        }
         log.info("You need to login first to continue.");
         await login();
       }
@@ -90,14 +115,24 @@ export async function runCommand(
       await initAppConfig();
     }
 
-    const { outroMessage } = await commandFn();
-    outro(outroMessage || "");
-  } catch (e) {
-    if (e instanceof Error) {
-      log.error(e.stack ?? e.message);
+    const { outroMessage, data } = await commandFn();
+
+    if (jsonMode) {
+      // Output JSON response
+      outputJson(data ?? {});
     } else {
-      log.error(String(e));
+      // Output human-friendly outro
+      outro(outroMessage || "");
     }
+  } catch (e) {
+    if (jsonMode) {
+      // Output JSON error
+      outputJsonError(e instanceof Error ? e : String(e));
+    } else if (e instanceof Error) {
+        log.error(e.stack ?? e.message);
+      } else {
+        log.error(String(e));
+      }
     throw new CLIExitError(1);
   }
 }
diff --git a/src/cli/utils/runTask.ts b/src/cli/utils/runTask.ts
index e602d6ef..9bd83927 100644
--- a/src/cli/utils/runTask.ts
+++ b/src/cli/utils/runTask.ts
@@ -1,9 +1,12 @@
 import { spinner } from "@clack/prompts";
+import { isJsonMode } from "./json.js";
 
 /**
  * Wraps an async operation with automatic spinner management.
  * The spinner is automatically started, and stopped on both success and error.
  *
+ * In JSON mode, the spinner is suppressed and the operation runs silently.
+ *
  * @param startMessage - Message to show when spinner starts
  * @param operation - The async operation to execute. Receives an updateMessage function
  *                    to update the spinner text during long-running operations.
@@ -46,6 +49,12 @@ export async function runTask<T>(
     errorMessage?: string;
   }
 ): Promise<T> {
+  // In JSON mode, run silently without spinner
+  if (isJsonMode()) {
+    const noopUpdateMessage = () => {};
+    return await operation(noopUpdateMessage);
+  }
+
   const s = spinner();
   s.start(startMessage);