@@ -38,9 +38,9 @@ export const appFlags = {
 export const bulkOperationFlags = {
   query: Flags.string({
     char: 'q',
-    description: 'The GraphQL query or mutation to run as a bulk operation.',
+    description: 'The GraphQL query or mutation to run as a bulk operation. If omitted, reads from standard input.',
     env: 'SHOPIFY_FLAG_QUERY',
-    required: true,
+    required: false,
   }),
   variables: Flags.string({
     char: 'v',
 
@@ -5,13 +5,15 @@ import {AppLinkedInterface} from '../../models/app/app.js'
 import {OrganizationApp} from '../../models/organization.js'
 import {renderSuccess, renderWarning} from '@shopify/cli-kit/node/ui'
 import {ensureAuthenticatedAdminAsApp} from '@shopify/cli-kit/node/session'
+import {readStdin} from '@shopify/cli-kit/node/system'
 import {inTemporaryDirectory, writeFile} from '@shopify/cli-kit/node/fs'
 import {joinPath} from '@shopify/cli-kit/node/path'
 import {describe, test, expect, vi, beforeEach} from 'vitest'
 
 vi.mock('./run-query.js')
 vi.mock('./run-mutation.js')
 vi.mock('@shopify/cli-kit/node/ui')
+vi.mock('@shopify/cli-kit/node/system')
 vi.mock('@shopify/cli-kit/node/session', async () => {
   const actual = await vi.importActual('@shopify/cli-kit/node/session')
   return {
@@ -335,4 +337,67 @@ describe('executeBulkOperation', () => {
       expect(runBulkOperationMutation).not.toHaveBeenCalled()
     })
   })
+
+  test('reads query from stdin when query flag is not provided', async () => {
+    const stdinQuery = '{ products { edges { node { id } } } }'
+    vi.mocked(readStdin).mockResolvedValue(stdinQuery)
+
+    const mockResponse = {
+      bulkOperation: successfulBulkOperation,
+      userErrors: [],
+    }
+    vi.mocked(runBulkOperationQuery).mockResolvedValue(mockResponse as any)
+
+    await executeBulkOperation({
+      app: mockApp,
+      remoteApp: mockRemoteApp,
+      storeFqdn,
+    })
+
+    expect(readStdin).toHaveBeenCalled()
+    expect(runBulkOperationQuery).toHaveBeenCalledWith({
+      adminSession: mockAdminSession,
+      query: stdinQuery,
+    })
+  })
+
+  test('prefers query flag over stdin when both are available', async () => {
+    const flagQuery = 'query { orders { edges { node { id } } } }'
+    const stdinQuery = '{ products { edges { node { id } } } }'
+    vi.mocked(readStdin).mockResolvedValue(stdinQuery)
+
+    const mockResponse = {
+      bulkOperation: successfulBulkOperation,
+      userErrors: [],
+    }
+    vi.mocked(runBulkOperationQuery).mockResolvedValue(mockResponse as any)
+
+    await executeBulkOperation({
+      app: mockApp,
+      remoteApp: mockRemoteApp,
+      storeFqdn,
+      query: flagQuery,
+    })
+
+    expect(readStdin).not.toHaveBeenCalled()
+    expect(runBulkOperationQuery).toHaveBeenCalledWith({
+      adminSession: mockAdminSession,
+      query: flagQuery,
+    })
+  })
+
+  test('throws error when no query is provided and stdin is empty', async () => {
+    vi.mocked(readStdin).mockResolvedValue(undefined)
+
+    await expect(
+      executeBulkOperation({
+        app: mockApp,
+        remoteApp: mockRemoteApp,
+        storeFqdn,
+      }),
+    ).rejects.toThrow('No query provided')
+
+    expect(runBulkOperationQuery).not.toHaveBeenCalled()
+    expect(runBulkOperationMutation).not.toHaveBeenCalled()
+  })
 })
@@ -6,18 +6,39 @@ import {renderSuccess, renderInfo, renderWarning} from '@shopify/cli-kit/node/ui
 import {outputContent, outputToken} from '@shopify/cli-kit/node/output'
 import {ensureAuthenticatedAdminAsApp} from '@shopify/cli-kit/node/session'
 import {AbortError} from '@shopify/cli-kit/node/error'
+import {readStdin} from '@shopify/cli-kit/node/system'
 import {parse} from 'graphql'
 import {readFile, fileExists} from '@shopify/cli-kit/node/fs'
 
 interface ExecuteBulkOperationInput {
   app: AppLinkedInterface
   remoteApp: OrganizationApp
   storeFqdn: string
-  query: string
+  query?: string
   variables?: string[]
   variableFile?: string
 }
 
+/**
+ * Resolves the query from the provided flag or stdin.
+ * Follows the same pattern as parseVariablesToJsonl for consistency.
+ */
+async function resolveQuery(query?: string): Promise<string> {
+  if (query) {
+    return query
+  }
+
+  const stdinContent = await readStdin()
+  if (stdinContent) {
+    return stdinContent
+  }
+
+  throw new AbortError(
+    'No query provided. Use the --query flag or pipe input via stdin.',
+    'Example: echo "query { ... }" | shopify app execute',
+  )
+}
+
 async function parseVariablesToJsonl(variables?: string[], variableFile?: string): Promise<string | undefined> {
   if (variables) {
     return variables.join('\n')
@@ -36,7 +57,9 @@ async function parseVariablesToJsonl(variables?: string[], variableFile?: string
 }
 
 export async function executeBulkOperation(input: ExecuteBulkOperationInput): Promise<void> {
-  const {app, remoteApp, storeFqdn, query, variables, variableFile} = input
+  const {app, remoteApp, storeFqdn, variables, variableFile} = input
+
+  const query = await resolveQuery(input.query)
 
   renderInfo({
     headline: 'Starting bulk operation.',
 
@@ -2,9 +2,18 @@ import * as system from './system.js'
 import {execa} from 'execa'
 import {describe, expect, test, vi} from 'vitest'
 import which from 'which'
+import {Readable} from 'stream'
+import * as fs from 'fs'
 
 vi.mock('which')
 vi.mock('execa')
+vi.mock('fs', async (importOriginal) => {
+  const actual = await importOriginal<typeof fs>()
+  return {
+    ...actual,
+    fstatSync: vi.fn(),
+  }
+})
 
 describe('captureOutput', () => {
   test('runs the command when it is not found in the current directory', async () => {
@@ -30,3 +39,77 @@ describe('captureOutput', () => {
     await expect(got).rejects.toThrowError('Skipped run of unsecure binary command found in the current directory.')
   })
 })
+
+describe('isStdinPiped', () => {
+  test('returns true when stdin is a FIFO (pipe)', () => {
+    // Given
+    vi.mocked(fs.fstatSync).mockReturnValue({isFIFO: () => true, isFile: () => false} as fs.Stats)
+
+    // When
+    const got = system.isStdinPiped()
+
+    // Then
+    expect(got).toBe(true)
+  })
+
+  test('returns true when stdin is a file redirect', () => {
+    // Given
+    vi.mocked(fs.fstatSync).mockReturnValue({isFIFO: () => false, isFile: () => true} as fs.Stats)
+
+    // When
+    const got = system.isStdinPiped()
+
+    // Then
+    expect(got).toBe(true)
+  })
+
+  test('returns false when stdin is a TTY (interactive)', () => {
+    // Given
+    vi.mocked(fs.fstatSync).mockReturnValue({isFIFO: () => false, isFile: () => false} as fs.Stats)
+
+    // When
+    const got = system.isStdinPiped()
+
+    // Then
+    expect(got).toBe(false)
+  })
+
+  test('returns false when fstatSync throws (e.g., CI with no stdin)', () => {
+    // Given
+    vi.mocked(fs.fstatSync).mockImplementation(() => {
+      throw new Error('EBADF')
+    })
+
+    // When
+    const got = system.isStdinPiped()
+
+    // Then
+    expect(got).toBe(false)
+  })
+})
+
+describe('readStdin', () => {
+  test('returns undefined when stdin is not piped', async () => {
+    // Given
+    vi.mocked(fs.fstatSync).mockReturnValue({isFIFO: () => false, isFile: () => false} as fs.Stats)
+
+    // When
+    const got = await system.readStdin()
+
+    // Then
+    expect(got).toBeUndefined()
+  })
+
+  test('returns trimmed content when stdin is piped', async () => {
+    // Given
+    vi.mocked(fs.fstatSync).mockReturnValue({isFIFO: () => true, isFile: () => false} as fs.Stats)
+    const mockStdin = Readable.from(['  hello world  '])
+    vi.spyOn(process, 'stdin', 'get').mockReturnValue(mockStdin as unknown as typeof process.stdin)
+
+    // When
+    const got = await system.readStdin()
+
+    // Then
+    expect(got).toBe('hello world')
+  })
+})
@@ -9,6 +9,7 @@ import {shouldDisplayColors, outputDebug} from '../../public/node/output.js'
 import {execa, ExecaChildProcess} from 'execa'
 import which from 'which'
 import {delimiter} from 'pathe'
+import {fstatSync} from 'fs'
 import type {Writable, Readable} from 'stream'
 
 export interface ExecOptions {
@@ -200,3 +201,42 @@ export async function isWsl(): Promise<boolean> {
   const wsl = await import('is-wsl')
   return wsl.default
 }
+
+/**
+ * Check if stdin has piped data available.
+ * This distinguishes between actual piped input (e.g., `echo "query" | cmd`)
+ * and non-TTY environments without input (e.g., CI).
+ *
+ * @returns True if stdin is receiving piped data or file redirect, false otherwise.
+ */
+export function isStdinPiped(): boolean {
+  try {
+    const stats = fstatSync(0)
+    return stats.isFIFO() || stats.isFile()
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Reads all data from stdin and returns it as a string.
+ * This is useful for commands that accept input via piping.
+ *
+ * @example
+ * // Usage: echo "your query" | shopify app execute
+ * const query = await readStdin()
+ *
+ * @returns A promise that resolves with the stdin content, or undefined if stdin is a TTY.
+ */
+export async function readStdin(): Promise<string | undefined> {
+  if (!isStdinPiped()) {
+    return undefined
+  }
+
+  let data = ''
+  process.stdin.setEncoding('utf8')
+  for await (const chunk of process.stdin) {
+    data += String(chunk)
+  }
+  return data.trim()
+}
@@ -857,12 +857,12 @@
         },
         "query": {
           "char": "q",
-          "description": "The GraphQL query or mutation to run as a bulk operation.",
+          "description": "The GraphQL query or mutation to run as a bulk operation. If omitted, reads from standard input.",
           "env": "SHOPIFY_FLAG_QUERY",
           "hasDynamicHelp": false,
           "multiple": false,
           "name": "query",
-          "required": true,
+          "required": false,
           "type": "option"
         },
         "reset": {