diff --git a/docs/reference.md b/docs/reference.md
index 09308b0d3..44803367c 100644
--- a/docs/reference.md
+++ b/docs/reference.md
@@ -277,7 +277,7 @@ DESCRIPTION
   directory.
 
 USAGE
-  $ apify create [actorName]
+  $ apify create [actorName] [--json]
                  [-l javascript|js|typescript|ts|python|py]
                  [--omit-optional-deps] [--skip-dependency-install]
                  [--skip-git-init] [-t <value>]
@@ -287,6 +287,8 @@ ARGUMENTS
   actorName  Name of the Actor and its directory.
 
 FLAGS
+      --json                     Format the command
+                                 output as JSON.
   -l, --language=<option>        Filter templates by
                                  programming language. Ignored when --template is
                                  provided.
diff --git a/skills/apify/SKILL.md b/skills/apify/SKILL.md
index fe697dbb8..4634b988a 100644
--- a/skills/apify/SKILL.md
+++ b/skills/apify/SKILL.md
@@ -29,6 +29,7 @@ See https://apify.com/auth.md for how to authenticate. Do not assume `APIFY_TOKE
 ## Structured output
 
 - `--json` is supported on most list/info commands (`apify actors ls --json`, `apify actors info <id> --json`, `apify datasets info <id> --json`, `apify runs ls --json`, etc.). Use it and parse with `jq`; don't scrape the human table.
+- `apify create <name> --template <template> --json` prints `{ dir, actorJsonPath, template, source, nextSteps, postCreate, gitRepositoryInitialized }` on stdout. Everything else goes to stderr, so stdout is safe to pipe into `jq`. `postCreate` is non-null when the template needs extra setup before `apify run` works.
 - List commands paginate — control with `--limit` / `--offset` (and `--desc`).
 - Dataset items: `apify datasets get-items <datasetId> --format json`. Use `--limit` / `--offset`.
 
diff --git a/src/commands/create.ts b/src/commands/create.ts
index 32cef85c3..76af082a1 100644
--- a/src/commands/create.ts
+++ b/src/commands/create.ts
@@ -18,6 +18,7 @@ import {
 	SUPPORTED_NODEJS_VERSION,
 } from '../lib/consts.js';
 import {
+	buildNextSteps,
 	enhanceReadmeWithLocalSuffix,
 	ensureValidActorName,
 	formatCreateSuccessMessage,
@@ -36,6 +37,7 @@ import {
 	getJsonFileContent,
 	isNodeVersionSupported,
 	isPythonVersionSupported,
+	printJsonToStdout,
 	setLocalConfig,
 	setLocalEnv,
 } from '../lib/utils.js';
@@ -111,6 +113,13 @@ export class CreateCommand extends ApifyCommand<typeof CreateCommand> {
 			description: 'Skip initializing a git repository in the Actor directory.',
 			required: false,
 		}),
+		origin: Flags.string({
+			description: 'Where the command was invoked from. Used for funnel telemetry.',
+			choices: ['console', 'cli'],
+			default: 'cli',
+			required: false,
+			hidden: true,
+		}),
 	};
 
 	static override args = {
@@ -120,15 +129,29 @@ export class CreateCommand extends ApifyCommand<typeof CreateCommand> {
 		}),
 	};
 
+	static override enableJsonFlag = true;
+
 	async run() {
 		let { actorName } = this.args;
-		const { template: templateName, useCase, language, skipDependencyInstall, skipGitInit } = this.flags;
+		const { template: templateName, useCase, language, skipDependencyInstall, skipGitInit, origin, json } = this.flags;
 
 		// --template-archive-url is an internal, undocumented flag that's used
 		// for testing of templates that are not yet published in the manifest
 		let { templateArchiveUrl } = this.flags;
 		let skipOptionalDeps = false;
 
+		// `--json` implies non-interactive: a caller parsing stdout cannot answer a prompt. Reject
+		// before creating any directories so a failed run leaves nothing behind.
+		if (json && !actorName) {
+			throw new Error('--json runs non-interactively. Pass the Actor name as an argument.');
+		}
+
+		if (json && !templateName && !templateArchiveUrl) {
+			throw new Error(
+				'--json runs non-interactively. Pass --template <name>; run `apify templates ls` to list values.',
+			);
+		}
+
 		// Start fetching manifest immediately to prevent
 		// annoying delays that sometimes happen on CLI startup.
 		const manifestPromise = fetchManifest().catch((err) => {
@@ -149,11 +172,15 @@ export class CreateCommand extends ApifyCommand<typeof CreateCommand> {
 					.catch(() => false));
 
 			if (folderExists?.isDirectory() && folderHasFiles) {
-				error({
-					message:
-						`Cannot create new Actor, directory '${actorName}' already exists. Please provide a different name.` +
-						' You can use "apify init" to create a local Actor environment inside an existing directory.',
-				});
+				const message =
+					`Cannot create new Actor, directory '${actorName}' already exists. Please provide a different name.` +
+					' You can use "apify init" to create a local Actor environment inside an existing directory.';
+
+				if (json) {
+					throw new Error(message);
+				}
+
+				error({ message });
 
 				actorName = await ensureValidActorName();
 				actFolderDir = join(cwd, actorName);
@@ -169,14 +196,17 @@ export class CreateCommand extends ApifyCommand<typeof CreateCommand> {
 		}
 
 		let messages = null;
+		let templateId: string | null = null;
 
 		this.telemetryData.create = {
 			fromArchiveUrl: !!templateArchiveUrl,
+			origin,
 		};
 
 		if (!templateArchiveUrl) {
 			const templateDefinition = await getTemplateDefinition(templateName, manifestPromise, { useCase, language });
 			({ archiveUrl: templateArchiveUrl, messages } = templateDefinition);
+			templateId = templateDefinition.id;
 			this.telemetryData.create.templateId = templateDefinition.id;
 			this.telemetryData.create.templateName = templateDefinition.name;
 			this.telemetryData.create.templateLanguage = templateDefinition.category;
@@ -389,8 +419,9 @@ export class CreateCommand extends ApifyCommand<typeof CreateCommand> {
 		// Initialize git repository before reporting success, but store result for later
 		let gitInitResult: { success: boolean; error?: Error } = { success: true };
 		const cwdHasGit = await stat(join(cwd, '.git')).catch(() => null);
+		const gitInitAttempted = !skipGitInit && !cwdHasGit;
 
-		if (!skipGitInit && !cwdHasGit) {
+		if (gitInitAttempted) {
 			try {
 				await execWithLog({
 					cmd: 'git',
@@ -405,20 +436,33 @@ export class CreateCommand extends ApifyCommand<typeof CreateCommand> {
 		// Suggest install command if dependencies were not installed
 		const installCommandSuggestion = !dependenciesInstalled ? await getInstallCommandSuggestion(actFolderDir) : null;
 
-		// Success message with extra empty line
-		simpleLog({ message: '' });
-		success({
-			message: formatCreateSuccessMessage({
-				actorName,
-				dependenciesInstalled,
+		const gitRepositoryInitialized = gitInitAttempted && gitInitResult.success;
+
+		if (json) {
+			printJsonToStdout({
+				dir: actFolderDir,
+				actorJsonPath: join(actFolderDir, LOCAL_CONFIG_PATH),
+				template: templateId,
+				source: 'apify',
+				nextSteps: buildNextSteps({ actorName, dependenciesInstalled, installCommandSuggestion }),
+				// Some templates need extra setup (e.g. "playwright install") before "apify run" works.
 				postCreate: messages?.postCreate ?? null,
-				gitRepositoryInitialized: !skipGitInit && !cwdHasGit && gitInitResult.success,
-				installCommandSuggestion,
-			}),
-		});
+				gitRepositoryInitialized,
+			});
+		} else {
+			simpleLog({ message: '' });
+			success({
+				message: formatCreateSuccessMessage({
+					actorName,
+					dependenciesInstalled,
+					postCreate: messages?.postCreate ?? null,
+					gitRepositoryInitialized,
+					installCommandSuggestion,
+				}),
+			});
+		}
 
-		// Report git initialization result only if it failed (success already included in success message)
-		if (!skipGitInit && !cwdHasGit && !gitInitResult.success) {
+		if (gitInitAttempted && !gitInitResult.success) {
 			// Git init is not critical, so we just warn if it fails
 			warning({ message: `Failed to initialize git repository: ${gitInitResult.error!.message}` });
 			warning({ message: 'You can manually run "git init" in the Actor directory if needed.' });
diff --git a/src/commands/templates/ls.ts b/src/commands/templates/ls.ts
index ec30eafa5..b4ad8f547 100644
--- a/src/commands/templates/ls.ts
+++ b/src/commands/templates/ls.ts
@@ -3,6 +3,7 @@ import { fetchManifest } from '@apify/actor-templates';
 import { ApifyCommand } from '../../lib/command-framework/apify-command.js';
 import { CompactMode, ResponsiveTable } from '../../lib/commands/responsive-table.js';
 import { info, simpleLog } from '../../lib/outputs.js';
+import { languageLabel } from '../../lib/templates/consts.js';
 import { printJsonToStdout } from '../../lib/utils.js';
 
 const table = new ResponsiveTable({
@@ -50,7 +51,7 @@ export class TemplatesLsCommand extends ApifyCommand<typeof TemplatesLsCommand>
 			table.pushRow({
 				Template: template.name,
 				Label: template.label,
-				Language: template.category,
+				Language: languageLabel(template.category),
 				'Use cases': (template.useCases ?? []).join(', '),
 			});
 		}
diff --git a/src/lib/command-framework/apify-command.ts b/src/lib/command-framework/apify-command.ts
index 43c81c937..06b024537 100644
--- a/src/lib/command-framework/apify-command.ts
+++ b/src/lib/command-framework/apify-command.ts
@@ -10,6 +10,7 @@ import widestLine from 'widest-line';
 import wrapAnsi from 'wrap-ansi';
 
 import { cachedStdinInput } from '../../entrypoints/_shared.js';
+import { keepStdoutClean } from '../exec.js';
 import { detectAiAgent, detectCi, detectIsInteractive } from '../hooks/telemetry/detectEnvironment.js';
 import type { TrackEventMap } from '../hooks/telemetry/trackEvent.js';
 import { trackEvent } from '../hooks/telemetry/trackEvent.js';
@@ -338,6 +339,10 @@ export abstract class ApifyCommand<T extends typeof BuiltApifyCommand = typeof B
 			} else {
 				this.flags.json = false;
 			}
+
+			if (this.flags.json) {
+				keepStdoutClean();
+			}
 		}
 
 		const missingRequiredArgs = new Map<string, TaggedArgBuilder<ArgTag, unknown>>();
diff --git a/src/lib/create-utils.ts b/src/lib/create-utils.ts
index c95d8827b..806bfb17c 100644
--- a/src/lib/create-utils.ts
+++ b/src/lib/create-utils.ts
@@ -47,7 +47,10 @@ export async function getTemplateDefinition(
 	if (manifest instanceof Error) throw manifest;
 
 	if (maybeTemplateName) {
-		const templateDefinition = manifest.templates.find((t) => t.name === maybeTemplateName);
+		// Accept both the template name and its id — `--json` output and older docs reference the id.
+		const templateDefinition = manifest.templates.find(
+			(t) => t.name === maybeTemplateName || t.id === maybeTemplateName,
+		);
 		if (!templateDefinition) {
 			throw new Error(`Could not find the selected template: ${maybeTemplateName} in the list of templates.`);
 		}
@@ -77,6 +80,22 @@ export async function enhanceReadmeWithLocalSuffix(readmePath: string, manifestP
 	}
 }
 
+export function buildNextSteps(params: {
+	actorName: string;
+	dependenciesInstalled: boolean;
+	installCommandSuggestion?: string | null;
+}): string[] {
+	const { actorName, dependenciesInstalled, installCommandSuggestion } = params;
+
+	const steps = [`cd "${actorName}"`];
+	if (!dependenciesInstalled) {
+		steps.push(installCommandSuggestion || 'install dependencies with your package manager');
+	}
+	steps.push('apify run');
+
+	return steps;
+}
+
 export function formatCreateSuccessMessage(params: {
 	actorName: string;
 	dependenciesInstalled: boolean;
@@ -88,12 +107,8 @@ export function formatCreateSuccessMessage(params: {
 
 	let message = `✅ Actor '${actorName}' created successfully!`;
 
-	if (dependenciesInstalled) {
-		message += `\n\nNext steps:\n\ncd "${actorName}"\napify run`;
-	} else {
-		const installLine = installCommandSuggestion || 'install dependencies with your package manager';
-		message += `\n\nNext steps:\n\ncd "${actorName}"\n${installLine}\napify run`;
-	}
+	const nextSteps = buildNextSteps({ actorName, dependenciesInstalled, installCommandSuggestion });
+	message += `\n\nNext steps:\n\n${nextSteps.join('\n')}`;
 
 	message += `\n\n💡 Tip: Use 'apify push' to deploy your Actor to the Apify platform\n📖 Docs: https://docs.apify.com/platform/actors/development`;
 
diff --git a/src/lib/exec.ts b/src/lib/exec.ts
index fb5865c58..e9ff7cdc1 100644
--- a/src/lib/exec.ts
+++ b/src/lib/exec.ts
@@ -1,3 +1,5 @@
+import process from 'node:process';
+
 import { Result } from '@sapphire/result';
 import { execa, type ExecaError, type Options } from 'execa';
 
@@ -5,6 +7,13 @@ import { normalizeExecutablePath } from './hooks/runtimes/utils.js';
 import { error, run } from './outputs.js';
 import { cliDebugPrint } from './utils/cliDebugPrint.js';
 
+let childStdout: 'inherit' | typeof process.stderr = 'inherit';
+
+/** Route child process stdout to our stderr, so it cannot corrupt a machine-readable payload. */
+export function keepStdoutClean() {
+	childStdout = process.stderr;
+}
+
 interface SpawnPromisedInternalOptions {
 	/**
 	 * Signals that should be forwarded from the parent process to the spawned
@@ -31,7 +40,7 @@ const spawnPromised = async (
 		env: opts.env,
 		cwd: opts.cwd,
 		// Pipe means it gets collected by the parent process, inherit means it gets collected by the parent process and printed out to the console
-		stdout: process.env.APIFY_NO_LOGS_IN_TESTS ? ['pipe'] : ['pipe', 'inherit'],
+		stdout: process.env.APIFY_NO_LOGS_IN_TESTS ? ['pipe'] : ['pipe', childStdout],
 		stderr: process.env.APIFY_NO_LOGS_IN_TESTS ? ['pipe'] : ['pipe', 'inherit'],
 		verbose: process.env.APIFY_CLI_DEBUG ? 'full' : undefined,
 	});
diff --git a/src/lib/hooks/telemetry/trackEvent.ts b/src/lib/hooks/telemetry/trackEvent.ts
index e801d35a0..864d7ded1 100644
--- a/src/lib/hooks/telemetry/trackEvent.ts
+++ b/src/lib/hooks/telemetry/trackEvent.ts
@@ -33,6 +33,7 @@ interface CliCommandEvent {
 		templateId?: string;
 		templateName?: string;
 		templateLanguage?: string;
+		origin?: 'console' | 'cli';
 	};
 
 	push?: {
diff --git a/src/lib/hooks/user-confirmations/_stdinCheckWrapper.ts b/src/lib/hooks/user-confirmations/_stdinCheckWrapper.ts
index 6cf3d9854..dd2db6223 100644
--- a/src/lib/hooks/user-confirmations/_stdinCheckWrapper.ts
+++ b/src/lib/hooks/user-confirmations/_stdinCheckWrapper.ts
@@ -1,7 +1,15 @@
+import process from 'node:process';
+
 import { isCI } from 'ci-info';
 
 import { useStdin } from '../useStdin.js';
 
+/**
+ * Inquirer renders to stdout by default. Prompts are UI, not command output, so they must stay off
+ * stdout, otherwise they corrupt the payload of commands invoked with `--json`.
+ */
+export const promptContext = { output: process.stderr };
+
 export interface StdinCheckWrapperInput<ReturnedType> extends StdinCheckWrapperOptions {
 	/**
 	 * When set, this value will be used in environments where stdin is not available.
@@ -45,11 +53,7 @@ export function stdinCheckWrapper<Fn extends (...args: any[]) => any>(
 
 		if (isCI || (!isTTY && !hasData)) {
 			if (typeof casted.providedConfirmFromStdin === 'undefined') {
-				throw new Error(
-					casted.errorMessageForStdin ??
-						errorMessageForStdin ??
-						`Please use the --${ConfirmFlag}/--${NoConfirmFlag} flags to confirm the action.`,
-				);
+				throw new Error(casted.errorMessageForStdin ?? errorMessageForStdin);
 			}
 
 			return casted.providedConfirmFromStdin;
diff --git a/src/lib/hooks/user-confirmations/useInputConfirmation.ts b/src/lib/hooks/user-confirmations/useInputConfirmation.ts
index c5a09b570..5c0b1e14b 100644
--- a/src/lib/hooks/user-confirmations/useInputConfirmation.ts
+++ b/src/lib/hooks/user-confirmations/useInputConfirmation.ts
@@ -1,6 +1,6 @@
 import input from '@inquirer/input';
 
-import { stdinCheckWrapper } from './_stdinCheckWrapper.js';
+import { promptContext, stdinCheckWrapper } from './_stdinCheckWrapper.js';
 
 interface UseInputConfirmationInput {
 	message: string;
@@ -10,16 +10,19 @@ interface UseInputConfirmationInput {
 
 export const useInputConfirmation = stdinCheckWrapper(
 	async ({ message, expectedValue, failureMessage }: UseInputConfirmationInput) => {
-		const result = await input({
-			message,
-			validate(value) {
-				if (value === expectedValue) {
-					return true;
-				}
+		const result = await input(
+			{
+				message,
+				validate(value) {
+					if (value === expectedValue) {
+						return true;
+					}
 
-				return failureMessage ?? 'That is not the correct input!';
+					return failureMessage ?? 'That is not the correct input!';
+				},
 			},
-		});
+			promptContext,
+		);
 
 		return result;
 	},
diff --git a/src/lib/hooks/user-confirmations/useMaskedInput.ts b/src/lib/hooks/user-confirmations/useMaskedInput.ts
index afae3c800..877ae1ccc 100644
--- a/src/lib/hooks/user-confirmations/useMaskedInput.ts
+++ b/src/lib/hooks/user-confirmations/useMaskedInput.ts
@@ -1,6 +1,6 @@
 import password from '@inquirer/password';
 
-import { stdinCheckWrapper } from './_stdinCheckWrapper.js';
+import { promptContext, stdinCheckWrapper } from './_stdinCheckWrapper.js';
 
 interface UseMaskedInputInput {
 	message: string;
@@ -8,7 +8,7 @@ interface UseMaskedInputInput {
 }
 
 export const useMaskedInput = stdinCheckWrapper(async ({ message, mask }: UseMaskedInputInput) => {
-	const result = await password({ message, mask: mask ?? '*' });
+	const result = await password({ message, mask: mask ?? '*' }, promptContext);
 
 	return result;
 });
diff --git a/src/lib/hooks/user-confirmations/useSelectFromList.ts b/src/lib/hooks/user-confirmations/useSelectFromList.ts
index 0642087ed..82230fbea 100644
--- a/src/lib/hooks/user-confirmations/useSelectFromList.ts
+++ b/src/lib/hooks/user-confirmations/useSelectFromList.ts
@@ -1,6 +1,6 @@
 import select from '@inquirer/select';
 
-import { stdinCheckWrapper } from './_stdinCheckWrapper.js';
+import { promptContext, stdinCheckWrapper } from './_stdinCheckWrapper.js';
 
 export type ChoicesType<T = unknown> = Parameters<typeof select<T>>[0]['choices'];
 
@@ -14,8 +14,11 @@ interface UseSelectFromListInput<T> {
 
 export const useSelectFromList = stdinCheckWrapper(
 	async ({ message, choices, pageSize, loop, default: defaultValue }: UseSelectFromListInput<unknown>) => {
-		const result = await select({ message, choices, pageSize, loop, default: defaultValue });
+		const result = await select({ message, choices, pageSize, loop, default: defaultValue }, promptContext);
 
 		return result;
 	},
+	{
+		errorMessageForStdin: 'Please provide the selection using the command options.',
+	},
 ) as <T>(input: UseSelectFromListInput<T>) => Promise<T>;
diff --git a/src/lib/hooks/user-confirmations/useUserInput.ts b/src/lib/hooks/user-confirmations/useUserInput.ts
index 4796ecfed..a7a37b6c4 100644
--- a/src/lib/hooks/user-confirmations/useUserInput.ts
+++ b/src/lib/hooks/user-confirmations/useUserInput.ts
@@ -1,6 +1,6 @@
 import input from '@inquirer/input';
 
-import { stdinCheckWrapper } from './_stdinCheckWrapper.js';
+import { promptContext, stdinCheckWrapper } from './_stdinCheckWrapper.js';
 
 interface UseUserInputInput {
 	message: string;
@@ -10,7 +10,7 @@ interface UseUserInputInput {
 
 export const useUserInput = stdinCheckWrapper(
 	async ({ message, validate, default: defaultValue }: UseUserInputInput) => {
-		const result = await input({ message, validate, default: defaultValue });
+		const result = await input({ message, validate, default: defaultValue }, promptContext);
 
 		return result;
 	},
diff --git a/src/lib/hooks/user-confirmations/useYesNoConfirm.ts b/src/lib/hooks/user-confirmations/useYesNoConfirm.ts
index fe1952ff9..92a8950fc 100644
--- a/src/lib/hooks/user-confirmations/useYesNoConfirm.ts
+++ b/src/lib/hooks/user-confirmations/useYesNoConfirm.ts
@@ -1,5 +1,5 @@
 import { confirmImpl } from '../../utils/inquirer/confirmImpl.js';
-import { stdinCheckWrapper } from './_stdinCheckWrapper.js';
+import { promptContext, stdinCheckWrapper } from './_stdinCheckWrapper.js';
 
 interface UseYesNoConfirmInput {
 	message: string;
@@ -7,7 +7,7 @@ interface UseYesNoConfirmInput {
 }
 
 export const useYesNoConfirm = stdinCheckWrapper(async ({ message, default: defaultValue }: UseYesNoConfirmInput) => {
-	const result = await confirmImpl({ message, default: defaultValue });
+	const result = await confirmImpl({ message, default: defaultValue }, promptContext);
 
 	return result;
 });
diff --git a/src/lib/templates/consts.ts b/src/lib/templates/consts.ts
index 9b4b7ec81..bfe961303 100644
--- a/src/lib/templates/consts.ts
+++ b/src/lib/templates/consts.ts
@@ -113,7 +113,7 @@ export function useCaseLabel(id: string): string {
 	return USE_CASE_OPTIONS.find((option) => option.templateTag === id)?.label ?? id;
 }
 
-/** Human-readable label for a language tag (used in the "no exact match" hint). */
+/** Human-readable label for a language tag. */
 export function languageLabel(id: string): string {
 	if (id === ANY_TEMPLATE_LANGUAGE) return 'any language';
 	return LANGUAGE_OPTIONS.find((option) => option.templateTag === id)?.label ?? id;
diff --git a/test/local/commands/create.test.ts b/test/local/commands/create.test.ts
index 2dfa3a189..fb1616463 100644
--- a/test/local/commands/create.test.ts
+++ b/test/local/commands/create.test.ts
@@ -1,5 +1,5 @@
 import { existsSync, readFileSync } from 'node:fs';
-import { mkdir, rm } from 'node:fs/promises';
+import { mkdir, rm, writeFile } from 'node:fs/promises';
 
 import { KEY_VALUE_STORE_KEYS } from '@apify/consts';
 
@@ -18,7 +18,7 @@ const { beforeAllCalls, afterAllCalls, joinPath, joinCwdPath, toggleCwdBetweenFu
 		cwdParent: true,
 	});
 
-const { lastErrorMessage } = useConsoleSpy();
+const { lastErrorMessage, logMessages } = useConsoleSpy();
 
 const { CreateCommand } = await import('../../../src/commands/create.js');
 
@@ -126,6 +126,102 @@ describe('apify create', () => {
 		).to.be.eql(expectedInput);
 	});
 
+	it('prints a machine-readable contract with --json', async () => {
+		await testRunCommand(CreateCommand, {
+			args_actorName: actName,
+			flags_template: 'project_empty',
+			flags_skipDependencyInstall: true,
+			flags_skipGitInit: true,
+			flags_json: true,
+		});
+
+		// Nothing but the payload may reach stdout, otherwise callers cannot parse it.
+		expect(logMessages.log).toHaveLength(1);
+
+		const output = JSON.parse(logMessages.log[0]);
+		expect(output.source).toBe('apify');
+		expect(typeof output.template).toBe('string');
+		expect(output.dir.endsWith(actName)).toBe(true);
+		expect(output.actorJsonPath.endsWith(LOCAL_CONFIG_PATH)).toBe(true);
+		expect(output.nextSteps[0]).toBe(`cd "${actName}"`);
+		expect(output.nextSteps).toContain('apify run');
+		expect(output.postCreate).toBeNull();
+		expect(output.gitRepositoryInitialized).toBe(false);
+	});
+
+	it('reports a successful git init in the --json contract', async () => {
+		await testRunCommand(CreateCommand, {
+			args_actorName: actName,
+			flags_template: 'project_empty',
+			flags_skipDependencyInstall: true,
+			flags_json: true,
+		});
+
+		expect(logMessages.log).toHaveLength(1);
+		expect(JSON.parse(logMessages.log[0]).gitRepositoryInitialized).toBe(true);
+	});
+
+	it('--json without --template fails before creating the directory', async () => {
+		await testRunCommand(CreateCommand, {
+			args_actorName: actName,
+			flags_skipDependencyInstall: true,
+			flags_json: true,
+		});
+
+		expect(lastErrorMessage()).toMatch(/--template/);
+		expect(logMessages.log).toHaveLength(0);
+		expect(existsSync(tmpPath)).toBe(false);
+	});
+
+	it('--json without an Actor name fails instead of prompting', async () => {
+		await testRunCommand(CreateCommand, {
+			flags_template: 'project_empty',
+			flags_skipDependencyInstall: true,
+			flags_json: true,
+		});
+
+		expect(lastErrorMessage()).toMatch(/name/i);
+		expect(logMessages.log).toHaveLength(0);
+	});
+
+	it('--json reports an existing directory once instead of reprompting', async () => {
+		await mkdir(tmpPath, { recursive: true });
+		await writeFile(joinPath('placeholder.txt'), '');
+
+		await testRunCommand(CreateCommand, {
+			args_actorName: actName,
+			flags_template: 'project_empty',
+			flags_skipDependencyInstall: true,
+			flags_json: true,
+		});
+
+		expect(lastErrorMessage()).toMatch(/already exists/);
+		expect(logMessages.log).toHaveLength(0);
+	});
+
+	it('records the hidden --origin flag in telemetry', async () => {
+		const instance = await testRunCommand(CreateCommand, {
+			args_actorName: actName,
+			flags_template: 'project_empty',
+			flags_skipDependencyInstall: true,
+			flags_skipGitInit: true,
+			flags_origin: 'console',
+		});
+
+		expect(instance['telemetryData'].create!.origin).toBe('console');
+	});
+
+	it('defaults --origin to cli', async () => {
+		const instance = await testRunCommand(CreateCommand, {
+			args_actorName: actName,
+			flags_template: 'project_empty',
+			flags_skipDependencyInstall: true,
+			flags_skipGitInit: true,
+		});
+
+		expect(instance['telemetryData'].create!.origin).toBe('cli');
+	});
+
 	it('should skip installing optional dependencies', async () => {
 		const ACT_TEMPLATE = 'project_cheerio_crawler_js';
 
diff --git a/test/local/lib/exec.test.ts b/test/local/lib/exec.test.ts
new file mode 100644
index 000000000..c9e58282e
--- /dev/null
+++ b/test/local/lib/exec.test.ts
@@ -0,0 +1,37 @@
+import process from 'node:process';
+
+import { execWithLog, keepStdoutClean } from '../../../src/lib/exec.js';
+
+describe('keepStdoutClean', () => {
+	const originalNoLogs = process.env.APIFY_NO_LOGS_IN_TESTS;
+
+	beforeEach(() => {
+		// The redirect is skipped entirely when this is set, so it has to be off for this test.
+		delete process.env.APIFY_NO_LOGS_IN_TESTS;
+	});
+
+	afterEach(() => {
+		if (originalNoLogs === undefined) delete process.env.APIFY_NO_LOGS_IN_TESTS;
+		else process.env.APIFY_NO_LOGS_IN_TESTS = originalNoLogs;
+	});
+
+	it('routes child process stdout to stderr', async () => {
+		const stdoutChunks: string[] = [];
+		const stderrChunks: string[] = [];
+
+		vitest.spyOn(process.stdout, 'write').mockImplementation((chunk) => {
+			stdoutChunks.push(String(chunk));
+			return true;
+		});
+		vitest.spyOn(process.stderr, 'write').mockImplementation((chunk) => {
+			stderrChunks.push(String(chunk));
+			return true;
+		});
+
+		keepStdoutClean();
+		await execWithLog({ cmd: 'echo', args: ['marker-from-child'] });
+
+		expect(stderrChunks.join('')).toContain('marker-from-child');
+		expect(stdoutChunks.join('')).not.toContain('marker-from-child');
+	});
+});