How to Run Google Apps Script from Your Phone: 7 Methods Compared

Disclosure: This article is written by the developer of Pocket Actions, one of the methods below. Google's behavior is cited from its official documentation, and community workarounds from public Q&A. Anything I couldn't verify is marked as such.

The problem: your Sheets "button" does nothing on your phone

You built a nice Google Sheets tool. You drew a button, assigned a script to it, and it works perfectly on your laptop. Then you open the sheet on your phone, tap the button, and nothing happens.

That's expected. Google's documentation says that clickable images and drawings with assigned scripts work in Sheets on the web, and that scripts assigned this way don't run in the Sheets mobile apps (Google Developers: Custom menus). Custom menus added with onOpen() don't appear in the mobile apps either. Many people discover this the hard way (Stack Overflow discussion).

You still have options. They differ in setup effort, permissions, how many taps they take, and how much feedback you get. This article compares seven of them.

Three criteria for choosing

1. Does it run where you are?

Some methods only work inside the Sheets app. Some work from your Home Screen, Siri, or a widget. Some only run on a schedule.

2. Setup and permissions

Simple triggers (onEdit) run without authorization but have strict limits. Installable triggers and web apps need authorization and sharing settings, and those settings decide who can run your code.

3. Feedback

Do you see that the script ran, and whether it succeeded? A sheet cell can show a status. A URL call might only tell you it was received.

The methods at a glance

The methods at a glance
MethodWorks in Sheets mobile appWorks outside SheetsSetupFeedbackCost
1. Drawing/image buttonNoNoEasy—Free
2. Checkbox + onEdit (simple trigger)YesNoEasyWrite status to a cellFree
3. Checkbox + installable "On edit" triggerYesNoMediumWrite status to a cellFree
4. Time-driven triggerRuns on its own— (scheduled)EasyLogs or emailFree
5. Browser: Apps Script editorPartly (desktop site)YesNoneExecution logFree
6. Web app URL (doGet) + bookmark or iOS Shortcut—YesMediumWhatever you returnFree
7. Pocket Actions (web app URL)—Yes, 1 tapMediumAccepted / failed onlyFree: 5 runs/day, 17/week

Method by method

1. Drawing or image button (why it fails)

On the web, you can insert a drawing and choose Assign script. In the Sheets mobile apps, that assignment is ignored (Google Developers).

  • Use it for: Desktop users only. Keep it there, and add one of the methods below for mobile.

2. Checkbox + onEdit simple trigger

This is the most common workaround. Insert a checkbox, and when someone ticks it, onEdit(e) runs your function and clears the box.

function onEdit(e) {
  const r = e.range;
  if (r.getSheet().getName() === 'Control' && r.getA1Notation() === 'B2' && r.getValue() === true) {
    r.setValue(false);
    r.offset(0, 1).setValue('Running…');
    myTask();
    r.offset(0, 1).setValue('Done ' + new Date().toLocaleString());
  }
}
  • Strengths: It works inside the Sheets mobile app, needs no deployment, and the user stays in the sheet.
  • Limits:
    • Simple triggers can't call services that require authorization, such as sending email or opening other files.
    • They run for at most 30 seconds (Google Developers: Simple triggers).
    • Edits made by scripts don't fire onEdit.
  • Use it for: Light, sheet-only actions like sorting, stamping a date, or copying a range.

3. Checkbox + installable "On edit" trigger

Same checkbox, but you register the handler as an installable trigger (Triggers → Add trigger → From spreadsheet → On edit). It runs with the authorization of the person who created it, so it can use services like Gmail, Drive, or UrlFetchApp. It also has the normal execution time limit instead of 30 seconds (Google Developers: Installable triggers).

  • Strengths: It works in the mobile app and can do real work: send mail, call APIs, create files.
  • Limits:
    • It runs as the trigger owner, so think about who can edit the sheet.
    • Rename the handler so it isn't onEdit; otherwise it can run twice.
    • The setup is a little more involved.
  • Use it for: Teams who live in the sheet and need heavier actions.

4. Time-driven trigger

Sometimes "run it from my phone" really means "make sure it runs." A time-driven trigger (every hour, daily at a set time) needs no tap at all.

  • Strengths: Fully hands-off.
  • Limits:
    • It doesn't run when you decide.
    • Frequent runs can be wasteful, especially when each run calls a paid API like an AI model.
    • Quotas apply.
  • Use it for: Things that should happen on a schedule no matter what.

5. Browser: open the Apps Script editor

On a phone browser you can request the desktop site, open script.google.com, pick the function, and press Run.

  • Strengths: Nothing to set up, and you see the execution log.
  • Limits: It's awkward on a small screen. There's also a risk of running the wrong function or accidentally editing code.
  • Use it for: Rare, one-off runs.

6. Web app URL (doGet) + a bookmark or iOS Shortcut

Deploy the script as a web app. Any GET request to its /exec URL calls doGet(e), which can run your function:

function doGet(e) {
  main();
  return ContentService.createTextOutput('OK');
}

Deploy → New deployment → Web app. Then open the URL from a bookmark, a Home Screen icon, or an iOS Shortcut ("Get Contents of URL").

  • Strengths: It works from anywhere: the Home Screen, Siri, Shortcuts automations, even other apps. It's free and flexible, and you can pass parameters with e.parameter.
  • Limits and cautions:
    • Who can access matters. If a phone or Shortcut calls the URL without your Google session, you usually need "Execute as: Me" and "Who has access: Anyone," which means anyone with the URL can run it. Treat the URL like a password, and consider checking a secret parameter. (This is my reading of how the access settings behave, not an official statement for every account type. Test it with your own account.)
    • After you change the code, you need to update the deployment version.
    • Visiting the URL in a browser shows the raw response.
  • Use it for: People comfortable building their own Shortcuts, with one or two scripts.

7. Pocket Actions (web app URL, organized)

Pocket Actions is an iPhone app that runs GitHub Actions workflows and Google Apps Script web apps from one screen. The GAS part works without connecting GitHub at all.

Setup takes two steps in the app:

  1. Enter a name and the function to run (default main). The app shows a matching doGet template that calls that function and returns "OK," with a copy button.
  2. Paste that code into your script, deploy it as a web app (Method 6), and paste the /exec URL into the app. URLs that don't start with https://script.google.com/ are rejected.

After that, the script is one tap away in a list next to any GitHub workflows.

  • Strengths:
    • One list for all your scripts (and GitHub workflows).
    • One-tap runs, with no Shortcut to build or maintain for each script.
    • No account and no backend. The app calls Google directly.
  • Limits:
    • No per-run parameters. The app calls the saved URL exactly as stored. A fixed query string (like ?key=...) is sent every time, but you can't type different values per run.
    • "Success" means the request went through, not that your script succeeded. The app doesn't read the response. A script that throws an error, or returns "NG" for a wrong key, still shows as sent. Only a network failure shows as failed. Write results to a sheet or send yourself an email if you need confirmation.
    • It relies on the web app access settings described in Method 6.
    • Free use is limited to 5 runs a day and 17 a week, counted together with GitHub runs.
    • iPhone only for now (Android is in closed testing).
  • Use it for: People with several scripts (or GAS plus GitHub Actions) who want them one tap away.

Limits that matter when you run scripts from a phone

These come from Google's quotas page. The first number is for consumer (gmail.com) accounts, the second for Google Workspace accounts.

Limits that matter when you run scripts from a phone
LimitConsumerWorkspaceWhy it matters here
Script runtime6 min / execution6 min / executionA tap-triggered job still has to finish in 6 minutes
Simple trigger (onEdit) runtime30 sec30 secMethod 2 is only for light work
Triggers total runtime90 min / day6 hr / dayFrequent time triggers (Method 4) eat into this
URL Fetch calls20,000 / day100,000 / dayRelevant if your script calls AI or other APIs
Email recipients100 / day1,500 / dayRelevant if each run emails a report
Simultaneous executions per user3030Rapid repeated taps can stack up

The "triggers total runtime" row shows one practical benefit of on-demand runs. A script that runs hourly by trigger uses that budget around the clock. Running it from your phone only when you need it uses far less, and the same goes for paid API calls inside the script.

Putting it together: one function, three entry points

You don't have to choose just one method. Keep the real work in one function and give it several thin entry points:

// The real work
function main() {
  const lock = LockService.getScriptLock();
  if (!lock.tryLock(10000)) return 'busy';   // avoid overlapping runs
  try {
    // ... your task ...
    SpreadsheetApp.getActive().getSheetByName('Control')
      .getRange('C2').setValue('Last run: ' + new Date().toLocaleString());
    return 'done';
  } finally {
    lock.releaseLock();
  }
}

// Entry 1: desktop drawing button → assign "main"

// Entry 2: checkbox for the Sheets mobile app (installable On edit trigger → onCheckbox)
function onCheckbox(e) {
  if (e.range.getA1Notation() === 'B2' && e.value === 'TRUE') {
    e.range.setValue(false);
    main();
  }
}

// Entry 3: web app for Shortcuts / Pocket Actions
function doGet(e) {
  if ((e.parameter.key || '') !== PropertiesService.getScriptProperties().getProperty('KEY')) {
    return ContentService.createTextOutput('NG');
  }
  return ContentService.createTextOutput(main());
}
  • The "Last run" cell gives every entry point the same feedback, which matters for Pocket Actions because it doesn't read the response.
  • Storing the key in Script Properties keeps it out of the code.
  • LockService stops two taps from running the job twice at once.

Troubleshooting

  • The drawing button does nothing on the phone. That's expected (Method 1). Use a checkbox or a web app.
  • onEdit fires on the laptop but nothing happens on the phone. Check that the edit is made by a person. Edits made by scripts don't fire triggers. Also, if the function needs authorization (email, other files, URL fetch), switch to an installable trigger.
  • The function runs twice. You probably named an installable trigger handler onEdit, so both the simple and the installable trigger fire. Rename it.
  • The web app still runs old code. Edit the deployment and choose a new version. The /exec URL keeps serving the version you deployed.
  • The URL returns a Google sign-in page. The access setting doesn't allow anonymous calls. A Shortcut or app without your Google session can't get through.

Security notes for web app URLs

  • Anyone with an "Anyone"-access web app URL can run it. Don't paste it in public places.
  • Add a simple shared secret: if (e.parameter.key !== 'your-secret') return ContentService.createTextOutput('NG'); (in Pocket Actions, include it in the registered URL as ?key=.... The app calls the registered URL exactly as saved, query string included).
  • Keep doGet small. Have it call one function, and don't return private data.
  • Review deployments now and then, and archive the ones you don't use.

Recommendations by reader

  • "My team uses the sheet on phones and needs a light action." → Checkbox + onEdit (Method 2).
  • "Same, but it has to send email or call an API." → Checkbox + installable trigger (Method 3).
  • "It just needs to happen every morning." → Time-driven trigger (Method 4).
  • "I want to run it from my Home Screen or by asking Siri, and I like building things." → Web app + iOS Shortcut (Method 6).
  • "I have several scripts (maybe GitHub workflows too) and want one-tap runs without building Shortcuts." → Pocket Actions (Method 7).
  • "It's a one-off." → The browser (Method 5).

Combining methods

  • Keep the desktop button for laptop users and add a checkbox for phone users. Both can call the same function.
  • Replace a frequent time trigger with a less frequent one, and run on demand when you actually need fresh results. That cuts both quota use and paid API calls.

A real use case

An App Store review of Pocket Actions describes triggering AI-powered jobs "with one quick tap whenever something catches my eye." Because of that, the reviewer reduced how often those jobs ran on a schedule and saved on AI costs. (Translated from Japanese. This is a user's review.)

As the developer, I use it for an automation that has AI evaluate stocks I'm curious about, run only when I need it.

Try Pocket Actions free

If you'd like your Apps Script one tap away, Pocket Actions is free to start: 5 runs a day, 17 a week.

FAQ

Why doesn't my Google Sheets script button work on mobile? Scripts assigned to drawings or images only run in Sheets on the web. Google's docs state that they don't run in the mobile apps. Use a checkbox with an edit trigger, or call a web app URL instead.

Can onEdit send email when triggered from my phone? Not as a simple trigger, because simple triggers can't use services that need authorization. Use an installable "On edit" trigger instead.

Is there a time limit for onEdit? Yes. Simple triggers can run for up to 30 seconds. Installable triggers follow the normal execution time limits.

How do I run Apps Script from an iPhone Shortcut? Deploy the script as a web app with a doGet function. Then use the Shortcuts action "Get Contents of URL" with the /exec URL.

Can Pocket Actions pass parameters to Apps Script? No. It calls the URL you registered. The app calls the saved URL as-is, so a fixed query string, such as a secret key, is sent every time.

Last checked: 2026-11-01 (Google Apps Script documentation, Pocket Actions features).