These changes help ensure Macro Scheduler scripts continue working with modern email services as providers increasingly move away from basic username/password authentication.

Why OAuth2 Support Matters

Many email providers — including Microsoft 365, Outlook.com and Gmail — are gradually disabling SMTP Basic Authentication. Instead they require OAuth2-based authentication.

Without OAuth2 support, automated scripts that send email via SMTP may stop working when basic auth is disabled.

With version 15.5.07, Macro Scheduler’s SMTPSendMail command now supports OAuth2 tokens, allowing scripts to authenticate securely with modern email providers.

Using OAuth2 with SMTPSendMail

To enable OAuth2 authentication simply set:

• SMTP_OAUTH2 = 1
• SMTP_OAUTH2_TOKEN = <access token>

Example:

Let>SMTP_OAUTH2=1
Let>SMTP_OAUTH2_TOKEN=ya29.a0AfH6SMBx...
Let>SMTP_USERID=yourname@gmail.com
Let>SMTP_SSL=1
Let>SMTP_PORT=465SMTPSendMail>recipient@example.com,smtp.gmail.com,yourname@gmail.com,Your Name,Test subject,Test body,

Macro Scheduler expects a valid OAuth2 access token in SMTP_OAUTH2_TOKEN.

Token retrieval itself is not handled automatically by SMTPSendMail. Your script (or another process) must obtain the access token from the provider first. This typically involves:

1. Creating an application with your email provider (e.g. Azure AD or Google Cloud).
2. Obtaining a client ID and client secret.
3. Using these credentials to obtain a refresh token.
4. Exchanging the refresh token for an access token.
5. Passing the access token to SMTPSendMail via SMTP_OAUTH2_TOKEN.

You can use Macro Scheduler’s HTTPRequest command to perform these token exchanges if needed.

Improved SMTP Timeout Handling

Version 15.5.07 also improves the behaviour of the SMTP_TIMEOUT variable.

Previously this timeout applied only to the initial connection to the SMTP server. In some environments this could still leave scripts waiting indefinitely if a later SMTP operation stalled.

Now the timeout applies to all SMTP operations, including:

• Authentication
• Message transfer
• Server responses

This results in more predictable behaviour when network issues or server delays occur.

Existing Scripts Continue to Work

If your SMTP server still supports username/password authentication, existing scripts will continue to work exactly as before using:

Let>SMTP_AUTH=1
Let>SMTP_USERID=myuser
Let>SMTP_PASSWORD=mypassword

OAuth2 is simply an additional authentication option for providers that require it.

Full Documentation

You can find the full SMTPSendMail documentation here:

https://www.mjtnet.com/manuals/b/v15/topics/smtpsendmail.htm

Download Macro Scheduler 15.5.07

If you rely on SMTP automation in your scripts, we recommend upgrading to Macro Scheduler 15.5.07 to ensure compatibility with modern email systems.

Trial Downloads | Registered Updates

• Finding the right element on a web page
• Extracting the right value from structured JSON data

Two technologies solve these problems:

• XPath — for navigating and selecting HTML elements
• JSONPath — for querying and extracting values from JSON

We’ve published two practical primer articles that go deep into both topics:

 An XPath Primer for Web Automation (with Macro Scheduler examples)
https://help.mjtnet.com/article/554-an-xpath-primer-for-web-automation-with-macro-scheduler-examples

 A JSONPath Primer (with Macro Scheduler examples)
https://help.mjtnet.com/article/555-a-jsonpath-primer-with-macro-scheduler-examples

Below is a high-level overview of each, with real Macro Scheduler examples to show why these skills are so valuable.

XPath — Find Web Elements Reliably

https://help.mjtnet.com/article/554-an-xpath-primer-for-web-automation-with-macro-scheduler-examples

When automating Chrome using Macro Scheduler’s Chrome functions, element IDs and class names are often unreliable:

• IDs may be missing or dynamically generated
• Class names may change between builds
• Multiple elements may share the same attributes

XPath lets you locate elements by describing their position and relationship within the page structure.

In Macro Scheduler, XPath is used with:

ChromeFindElements>session_id,xpath,value,elements_array

Example: Find an Input by Attribute

ChromeFindElements>session_id,xpath,//input[@name='q'],elements
ChromeSetElementValue>session_id,elements_1,macro scheduler

This finds an <input> element whose name attribute equals q.

Using Partial Matches

When values are dynamic:

ChromeFindElements>session_id,xpath,//button[contains(@id,'save')],elements

This matches any button whose ID contains the word “save”.

Real-World Scenario: Clicking a Button Based on a Child Element

HTML:

<button>
  <label for="checkbox-123">Pacific Islander</label>
  <input id="checkbox-123">
</button>

You know the ID of the input, but need to click the surrounding button.

XPath:

ChromeFindElements>session_id,xpath,//input[@id='checkbox-123']/ancestor::button,btn
ChromeClickElement>session_id,btn_1

This moves up the DOM from the input to its parent button.

Real-World Scenario: Find a Button Based on Nearby Text

HTML:

<div class="option">
  <h3>Premium Plan</h3>
  <button>Select</button>
</div>

XPath:

ChromeFindElements>session_id,xpath,//h3[text()='Premium Plan']/following-sibling::button,btn
ChromeClickElement>session_id,btn_1

This selects the button associated with the “Premium Plan” heading.

XPath Best Practices

• Prefer relative paths starting with //
• Use contains() for dynamic values
• Avoid full /html/body/... absolute paths
• Check elements_array_count before using results

For a full walkthrough and many more patterns, see:
https://help.mjtnet.com/article/554-an-xpath-primer-for-web-automation-with-macro-scheduler-examples

JSONPath — Extract Data from JSON

https://help.mjtnet.com/article/555-a-jsonpath-primer-with-macro-scheduler-examples

JSON is everywhere: APIs, cloud services, configuration files, and web responses.

Macro Scheduler’s JSONParse command uses JSONPath to pull specific values from JSON text.

JSONParse>json_string,json_path,result_array

Results are always returned as an array:

• result_array_1
• result_array_2
• result_array_count

Example: Extract a Simple Value

JSON:

{ "uid": "1234" }

Macro Scheduler:

JSONParse>sJSON,$.uid,result
MessageModal>UID is: %result_1%

Note the required $ at the start of the path.

Working with Arrays

JSONParse>sJSON,$.clients[0],result

Gets the first client.

JSONParse>sJSON,$.clients[*],result

Gets all clients.

Using Filters

Select only books cheaper than 10:

JSONParse>json,$.store.book[?@.price < 10],cheapBooks

Select books that contain an ISBN:

JSONParse>json,$.store.book[?@.isbn],withIsbn

Get titles of books under 15:

JSONParse>json,$.store.book[?@.price < 15].title,titles

JSONPath Best Practices

• Always start paths with $
• Remember results are arrays
• Check result_count before using values
• Build paths step by step

For full explanations and more examples:
https://help.mjtnet.com/article/555-a-jsonpath-primer-with-macro-scheduler-examples

Final Thoughts

XPath and JSONPath solve two of the most common automation problems:

• XPath → finding the right element on a web page
• JSONPath → extracting the right value from structured data

Mastering these will make your Macro Scheduler scripts more reliable, more flexible, and easier to maintain.

If you regularly automate websites or APIs, these two primers are essential reading.

Macro Recorder

• Added ability to select an open window to activate
• Added option to constrain mouse events to selected initial window when recording
• Added SetFocus lines to macro recorder output when window activated
• Updated layout of macro recorder

Web Automation

• Added ChromeWaitForText command
• Added EdgeWaitForText command
• Added ‘text’ and ‘partial text’ strategies to ChromeFindElements
• Added ‘text’ and ‘partial text’ strategies to EdgeFindElements
• Updated WebRecorder toolbar button to visit the Chrome WebRecorder Extension:
  https://www.mjtnet.com/webrecorder.htm

New Commands & Functions

• Added PowerShell command to run PowerShell scripts and commands
• Added GetWindowTitle command
• Added GetISOTimeStamp command
• Added StrContains function
• Added StrStartsWith function
• Added StrEndsWith function
• Added GFL_RECURSIVE directive
• Added MSG_TIMEOUT option

Improvements

• Updated JSONParse to handle ‘?’ filters and ‘@’ (Current) operator
• Updated data path / OneDrive handling
• Updated HTTPRequest, SMTP, POP3, and FTP functions to default to TLS 1.2 and removed deprecated SSLv2/SSLv3 support

Fixes

• Fixed ReadFile command to cope better with Unicode characters
• Fixed minor issues in command definition file

Registered Downloads/Upgrades | Trial Downloads

Why call APIs from Macro Scheduler?

• Pull or push data (orders, tickets, metrics) as part of a daily job
• Trigger SaaS workflows without opening a browser
• Glue apps together (cron-style) with simple, reliable scripts

Everything below runs in plain Macro Scheduler—no external dependencies.

Quick start: GET a JSON endpoint

// 1) Optional: set a timeout (seconds)
Let>HTTP_TIMEOUT=15

// 2) Optional: custom headers (multiple lines use %CRLF%)
Let>HTTP_CUSTOM_HEADERS=Accept: application/json

// 3) Make the request
HTTPRequest>https://api.example.com/status,,GET,,RESP

// 4) Parse JSON (example path)
JSONParse>RESP,$.service,result
If>result_count>0
  MessageModal>Service: %result_1%
Else
  // Log full response if JSON path not found
  WriteLn>%SCRIPT_DIR%\api_log.txt,WF_APPEND,Unexpected response: %RESP%
EndIf

HTTPRequest signature:
HTTPRequest>URL,[LocalFilename],Method,[POST_Data],Result_Variable mjtnet.com

POST JSON (with Bearer token)

Let>HTTP_TIMEOUT=20
Let>HTTP_POSTJSON=1
Let>HTTP_CUSTOM_HEADERS=Authorization: Bearer YOUR_API_KEY%CRLF%Accept: application/json

// JSON body (can be built up dynamically)
Let>payload={"name":"Widget 42","price":19.99}

// POST it
HTTPRequest>https://api.example.com/items,,POST,payload,RESP

// Extract a field from the JSON response
JSONParse>RESP,$.id,itemId
If>itemId_count=1
  MessageModal>Created item id: %itemId_1%
Else
  WriteLn>%SCRIPT_DIR%\api_log.txt,WF_APPEND,Create failed: %RESP%
EndIf

• For JSON bodies, set HTTP_POSTJSON=1 (Macro Scheduler sets the content type for you). mjtnet.com
• JSONParse returns an array (result_1, result_2, …) with a *_count—use JSONPath like $.id. mjtnet.com

Custom headers, SSL/TLS & timeouts (reliability)

Let>HTTP_TIMEOUT=30
Let>HTTP_CUSTOM_HEADERS=Authorization: Bearer YOUR_API_KEY%CRLF%X-Trace: msched

• Timeouts: set HTTP_TIMEOUT (seconds) so a hung API doesn’t block your run. mjtnet.com
• Headers: set multiple lines via HTTP_CUSTOM_HEADERS—great for auth, idempotency keys, etc. mjtnet.com
• HTTPS/TLS: Use an https:// URL (or set HTTP_SSL=1). If you must pin a TLS version, set TLS_VER (12 for TLS 1.2). 

Example: create a short link with a custom Open Graph preview (ogli)

Swap in your endpoint/headers if you’re using another service—the pattern is the same.

This example uses the Ogli link shorter service. Grab a free API key from Ogli to try out the code below.

// Go get a free API key from app.ogli.sh
Let>OGLI_API_KEY=YOUR_API_KEY_HERE

// Timeouts & JSON
Let>HTTP_TIMEOUT=20
Let>HTTP_POSTJSON=1

// Auth (Bearer) + accept JSON
Let>HTTP_CUSTOM_HEADERS=Authorization: Bearer %OGLI_API_KEY%%CRLF%Accept: application/json

// Build the request body
/*
PAYLOAD:
{
"targetUrl":"https://example.com/product/1232",
"title":"SuperWidget — Launch Day"
}
*/
LabelToVar>PAYLOAD,postBody

// POST
HTTPRequest>https://api.ogli.sh/link,,POST,postBody,RESP

// Parse shortUrl from response
JSONParse>RESP,$.url,short_link
If>short_link_count>0
  Let>the_link=short_link_1
  MessageModal>short link is %the_link%
Endif

Later, PATCH the same link to swap the OG image and platforms will refresh the preview when reshared.

Error handling & logging pattern

Let>LOG=%SCRIPT_DIR%\api_log.txt

// After any HTTPRequest:
If>RESP=
  // If you saved to a LocalFileName, RESP will be blank on success.
  // Otherwise blank usually means an error occurred – log it:
  WriteLn>%LOG%,WF_APPEND,Blank response (check URL/timeout/SSL)
Else
  // Try to parse a known field; if none, log full response
  JSONParse>RESP,$.status,status
  If>status_count=0
    WriteLn>%LOG%,WF_APPEND,Unexpected JSON: %RESP%
  EndIf
EndIf

Tip: when you save to a file (use the LocalFilename parameter), a successful call leaves the result variable blank by design; otherwise it contains the response or an error message. mjtnet.com

Parse more JSON with JSONPath

/*
RESP:
{
  "id":"lnk_abc123",
  "shortUrl":"https://ogli.sh/launch-123",
  "stats":{"clicks":42,"countries":["GB","US"]}
}
*/
JSONParse>RESP,$.stats.clicks,c
If>c_count=1
  Let>clicks=%c_1%
EndIf

// Loop an array (countries)
JSONParse>RESP,$.stats.countries[*],cc
Let>k=0
Repeat>k
  Let>k=k+1
  Let>country=cc_%k%
  // do something with %country%
Until>k=cc_count

JSONParse returns an array and a *_count—loop over it with Repeat/Until. 

Common gotchas

• For JSON, always set HTTP_POSTJSON=1 (don’t hand-craft Content-Type). mjtnet.com
• Escape quotes inside JSON strings correctly.
• Use timeouts so a bad endpoint doesn’t hang your run (Let>HTTP_TIMEOUT=15). mjtnet.com
• If an API returns HTML (error pages), JSONParse will fail—log RESP to inspect.

Further reading

• Macro Scheduler: HTTPRequest (methods, headers, files, SSL, timeouts). mjtnet.com
• Macro Scheduler: JSONParse (JSONPath, arrays, examples). 
• If you prefer you can use Python requests with PyExec.

But did you know we also offer done-for-you automation services?

We understand that not everyone has the time to dive into scripting, or sometimes the task at hand is a little too complex to tackle alone. That’s where our team comes in.

Automation Built for You

We’ve created custom automations for organizations of all sizes — from small businesses right through to the NHS and other major healthcare providers. Whether it’s:

• Filling out forms automatically
• Extracting and processing data
• Integrating with legacy systems
• Or orchestrating complete workflows across multiple applications

…our team can design, script, and deliver a solution that works seamlessly for you.

And if you already have a Macro Scheduler script — whether it’s partly built, needs fixing, or could do with enhancements — we can adapt, maintain, and improve your existing routines too.

How It Works

To automate something properly, we need to see the process in action. That means we’ll ask you to walk us through the steps, and in most cases we’ll need secure remote access to your system so we can interact directly with the applications involved.

Once we’ve observed the process, we’ll design and build a Macro Scheduler script or set of scripts that replicate your workflow reliably. These run inside Macro Scheduler — giving you flexibility to adapt, extend, and manage your automations over time.

From simple repetitive actions to complex multi-application workflows, our goal is to remove the manual effort so you can focus on more important things.

Why Use Our Services?

• Save time quickly — no need to learn scripting from scratch.
• Tailored solutions — we adapt to your processes, not the other way around.
• Proven experience — decades of automation expertise across industries.
• Ongoing support — we can update and enhance scripts as your needs evolve.

Ready to Talk?

If you’ve got a task in mind — whether it’s something you do dozens of times a day, or a regular process that eats into your team’s time — let’s discuss how we can automate it for you.

 Contact us today and let’s see how much time we can save you.

What is it?

A Chrome browser extension that records user interactions on web pages and generates Macro Scheduler automation scripts with Chrome WebDriver commands.

• Records user interactions such as clicks, typing and form submissions
• Generates optimized Macro Scheduler scripts with proper syntax
• Supports Chrome WebDriver commands (ChromeStart, ChromeNavigate, ChromeFindElements, etc.)
• Smart duplicate event removal for cleaner scripts
• One-click script download

Beta Installation Instructions

Download here:

https://www.mjtnet.com/software/macro-scheduler-extension-1-5-7.zip

Since this extension is in beta testing and not yet published to the Chrome Web Store, you’ll need to install it as an “unpacked extension”:

Step 1: Extract the Extension

1. Download and extract the macro-scheduler-extension.zip file to a folder on your computer
2. Remember the location of this folder – you’ll need it in Step 3

Step 2: Enable Developer Mode in Chrome

1. Open Google Chrome
2. Click the three dots menu (⋮) in the top-right corner
3. Go to More tools → Extensions
4. Or directly navigate to: chrome://extensions/
5. Toggle “Developer mode” ON in the top-right corner of the Extensions page

Step 3: Load the Extension

1. Click “Load unpacked” button (appears after enabling Developer mode)
2. Navigate to and select the folder where you extracted the extension files
3. Click “Select Folder”
4. The extension should now appear in your extensions list

Step 4: Pin the Extension (Optional but Recommended)

1. Click the puzzle piece icon () in Chrome’s toolbar
2. Find “Macro Scheduler Recorder” in the list
3. Click the pin icon () next to it
4. The extension icon will now appear directly in your toolbar

How to Use

1. Start Recording: Click the extension icon and press “Start Recording”
2. Perform Actions: Navigate to any website and perform the actions you want to automate (clicking, typing, form submissions, etc.)
3. Stop Recording: Click the extension icon again and press “Stop Recording”
4. Download Script: Review the generated script and click “Download Script” to save it as a .scp file

Generated Script Requirements

Important: The generated scripts require Chrome for Testing to be installed on your system.

• Download and installation instructions: https://www.mjtnet.com/manuals/b/v15/topics/chromestart.htm
• Make sure to update the CHROMEDRIVER_EXE path in the generated script to match your installation

Beta Testing Notes

This is a beta version for testing purposes. Please report any issues or suggestions:

• Extension behavior problems
• Script generation errors
• UI/UX feedback
• Feature requests

This is early beta. And anyone who has ever dabbled with automating Chrome and websites will hopefully know how difficult it is to make one-size-fits-all rules. There are bound to be things this can’t automate. It might not always be able to find the best element selectors, or ones that are unique. So your mileage WILL vary. But we’ve tested a few thorny scenarios – frames, new tabs opening as well as forms and clicks and so far we’re happy with what it can do. Have a play. And drop your comments and feedback in the forums or drop us a line here.

Supported Actions

The extension currently records and generates scripts for:

• Element clicks (buttons, links, etc.)
• Text input (input fields, textareas)
• Form submissions
• Keyboard interactions
• Focus events

Note: The initial page URL is automatically included when recording starts. Subsequent page changes should result from user interactions (clicks, form submissions) rather than manual URL changes.

Script Output Format

Generated scripts use Macro Scheduler syntax with Chrome WebDriver commands:

ChromeStart>session_id
ChromeNavigate>session_id,url,https://example.com
ChromeFindElements>session_id,css selector,input[type='text'],elements
ChromeSetElementValue>session_id,elements_1,Hello World
ChromeElementAction>session_id,elements_1,click
ChromeQuit>session_id

Troubleshooting

Extension Not Loading

• Make sure Developer mode is enabled
• Verify all extension files are in the selected folder
• Check Chrome’s console for error messages (F12 → Console tab)

Recording Not Working

• Refresh the page after starting recording
• Make sure the extension has permission to access the website
• Check that you’re performing supported actions (clicks, typing, etc.)

Script Generation Issues

• Ensure you have recorded at least one action
• Verify the recorded events appear in the extension popup
• Try clearing and re-recording if the script appears empty

 Macro Scheduler Agent — an AI-powered web tool to help you write, improve, and troubleshoot Macro Scheduler scripts.

What can it do?

•  Explain a script — upload a script and get a plain English explanation, plus suggestions to improve it
•  Why doesn’t this work? — submit a script you’re having trouble with, and get ideas for what might be going wrong
•  How would I automate this? — upload screenshots and describe what you want to automate
•  Web form automation (experimental) — upload a CSV and a web form URL, and it will try to generate a script to fill out the form

Important caveats — this is Beta!

We’re calling this an experimental Beta for good reason:

It’s an AI-based tool — results will vary
It’s still learning — sometimes it will get things wrong
It may suggest improvements, but they’re not guaranteed to be optimal
For the Web Automation wizard in particular, success depends heavily on the structure of the form

Please treat this as a helpful assistant, not an infallible authority!
Always test any generated scripts before using them in production.

Who can use it?

Currently, access is limited to licensed Macro Scheduler users — it will check your email against our license database.
For now, it’s free to use for licensed users while we continue to develop and refine it.

Why are we building this?

Macro Scheduler users are an incredibly creative bunch, building automations for all kinds of applications and workflows.

We see the potential for AI to:

Help users learn the language faster
Speed up troubleshooting
Provide inspiration for better automation techniques
Bridge the gap for newer users

Try it out:
 https://agent.mjtnet.com/

We need your feedback!

If you try it out, we’d love to hear:

What worked well
What didn’t
What else you’d like to see it do

This will help us improve it and guide future development.

Head over to the forums here:

https://forum.mjtnet.com/topic/20710

Final note

Again — this is Beta, experimental, and still learning.
It won’t always get things right — but we think it can already be a useful assistant.

Give it a go — and happy scripting!

• Added: EDGEDRIVER_OPTIONS variable to specify Edge startup switches
• Added: CHROMEDRIVER_DOWNLOADPATH variable to specify Chrome download folder (experimental)

This version applies some internal improvements for the Chrome/Edge automation functions and in particular allows you to set startup switches for Edge, and also set a download folder for Chrome.

The CHROME_DOWNLOADPATH option is particularly useful if you need to automate a routine which involves downloading a file with Chrome. It will avoid asking for confirmation and the file will be automatically downloaded to the specified folder.

Registered Downloads/Upgrades | Trial Downloads

• Added: ONERROR (custom error routine) capture added for complex if statements
• Added: experimental TMSWebBrowser and TMSAcroPDF (requires Adobe Acrobat Reader to be installed) objects to dialogs
• Fixed: unable to get HTML property of HTMLViewer dialog object
• Fixed: GetProcessIds not returning empty array if process does not exist
• Fixed: GetWindowChildList missing from code builder

Registered Downloads/Upgrades | Trial Downloads

• Added: EdgeExecute function
• Added: RP_CAPTURESTDOUT and RP_STDOUT variables for capturing STDOUT from RunProgram process. Warning: using this will mean RunProgram will ALWAYS wait for the process to terminate, which may require user input in some cases.
• Added: LClick and RClick can now take multiplier like Press commands, e.g. LCLick * 2, RClick * 2
• Added: optional 5th param to DateDiff & TimeDiff commands to return whether date2/time2 is later or earlier than date1/time2
• Added: Between function to return text between two tokens
• Added: ^ (power) operator to Let command
• Added: [drive], [folder], [filename] keywords to EasyPattern regex mode.
• Added: Ability to block comment/uncomment with ctrl+/ in editor

Registered Downloads/Upgrades | Trial Downloads

The NHS trust was able to save significant time and up to £15,000 by using Macro Scheduler to perform the automation.

More details here.
Read the case study.

Last week we released Macro Scheduler maintenance update 15.0.20:

• Added: ChromeGetWindows, ChromeSwitchWindow, EdgeGetWindows, EdgeSwitchWindow functions
• Added: Copy Let assignment option to watchlist menu (creates Let>variable=value on clipboard)
• Fixed: edge case with some strings not being quoted properly in variable expressions
• Updated: changed PPI zoom cut-off for larger icons

Trial downloads | Registered Updates

But Macro Scheduler came to the rescue.

One simple automation script monitored a handful of web pages 24/7, refreshing every minute or so. It watched our local Supermarket looking for slots, and it monitored the white-goods stores waiting for any one of half-a-dozen freezers to be re-stocked.

A few days went by. No luck. Was this going to work? Would there ever be any slots? On day 6 I received a text on my phone – I’d been smart enough to use Zapier so Macro Scheduler would notify me via text wherever I may be.

A freezer had become available on the John Lewis website! We scurried over to the laptop and hurriedly clicked on the link. It’s no exaggeration to say our hearts were in our mouths. This was important! We didn’t even read the description. We just needed a freezer. Added it to our cart. Paid for it. Got the confirmation email. A few seconds later none were available again. We had successfully managed to purchase a freezer during the few minutes one online retailer had some.

Since then, over the past 8 weeks or so we used Macro Scheduler to tell us when those supermarket deliveries are available. They only pop up once or twice a day if we’re lucky – but when they do, we hear our little notification beep and off we run to the laptop and start shopping! It has been a Godsend, and it hasn’t failed us yet. Thanks to Macro Scheduler we top-up our little freezer every two weeks, and lockdown has been largely worry-free.

The process was simple. Here are some of the commands we used. IECreate, IENavigate to get us to the pages we were looking for and IEGetAllText helped us scrape the text from the page, then we used Position to see if the text we were looking for was, or wasn’t, on the page. All contained in a nice little loop, watching and waiting 24/7.

Of course there is also a great deal of financial uncertainty. Businesses and people everywhere are feeling the pinch, ourselves included.

Clearly though, the biggest challenge is being felt by our amazing health services, which are under incredible pressures.

Behind the scenes, healthcare IT departments are working against the clock, often with huge volumes of data. So it’s great to know that Macro Scheduler is reducing the burden during the current crisis.

Here’s what Tom, a Clinical Systems Developer at an NHS hospital in Northern England, told us last week:

“In a crisis situation, we needed a straightforward automation tool which could help us make quick changes to a wide range of systems – without time to write API code. We found that Macro Scheduler more than fit the bill: it rapidly enabled us to automate repetitive tasks and to free up needed resources – ultimately giving us the time to better support our clinical staff in fighting coronavirus. In particular we have been very impressed with its ability to easily integrate with Google Chrome – like many organisations a lot of our tools are web-based and our ability to build automation into these workflows is a real game-changer.”

If you work for a hospital on the front-line of coronavirus care and would benefit in using Macro Scheduler, or require additional licenses, please contact me using your official work email address, tell me what you need Macro Scheduler for and we will see how we can help.

We’ve worked closely with a few UK hospital trusts over the years. In particular, Bournemouth Hospital has used Macro Scheduler extensively to automate dozens of clinical and administrative processes within the trust. You will find a case study we did with them a few years ago here. Many times Macro Scheduler has been used to streamline processes that save the time of clinicians. And that can mean more patients get seen.

Clearly though, the biggest challenge is being felt by our amazing health service, which is under incredible pressures. So, where possible I’d like to offer any NHS establishment free use of Macro Scheduler while this crisis lasts. If you work for the NHS and would benefit in using Macro Scheduler, or require additional licenses, please contact me using your NHS email address, tell me what you need Macro Scheduler for and we will see how we can help.

We’ve worked closely with a few NHS trusts over the years. In particular, Bournemouth Hospital has used Macro Scheduler extensively to automate dozens of clinical and administrative processes within the trust. You will find a case study we did with them a few years ago here. Many times Macro Scheduler has been used to streamline processes that save the time of clinicians. And that can mean more patients get seen.

To do this, use the key codes for Edge and Chrome listed here.

For example:

ChromeSetElementValue>session_id,message_elements_1,First line
//Press enter on the element ... 
ChromeSetElementValue>session_id,message_elements_1,\uE006
ChromeSetElementValue>session_id,message_elements_1,Second line

Note that when sending keystrokes only one can be sent at a time.

Recently someone needed to scroll down inside a div, in order to force the page to fetch more data. Issuing a Page Down on the div element did the trick:

ChromeSetElementValue>session_id,div_elements_1,\uE00F

So, ChromeSetElementValue sends keys as well as sets values – perhaps it should have been called ChromeSendKeysToElement and just maybe we’ll add that as a mapping if it helps.

Of course you don’t have to use the new Chrome/Edge functions – you can still use UI methods and use SetFocus, SendText and/or Image Recognition to locate page elements.

Macro Scheduler is packed with features that help with automating desktop applications and simulating user input. But it also has great support for consuming web resources via HTTP requests, as well as built in functions for automating modern web browsers.

“Being able to move between GUI and API methods to handle our automation needs is priceless”

Find out how IT services company Cloud2T uses Macro Scheduler to bridge desktop and modern API driven cloud services. Read the case study here.

Switching Frames

The ChromeSwitchFrame and EdgeSwitchFrame functions allow you to specify a frame or iframe element, by index or element reference, to switch the “browsing context” to.

What this means is that any subsequent interactions will take place against elements within that frame. So a subsequent ChromeFindElements call will attempt to locate the specific element within the frame, rather than the parent page, and ChromeElementAction will act against the given element within that frame.

//Find the frame using xpath
ChromeFindElements>sessionID,xpath,//iframe[@src='/contact-form/formpage.html'],elements

//switch browsing context to this frame
ChromeSwitchFrame>session_id,element,elements_1,res

If xpath doesn’t mean anything to you see my recent post Using Macro Scheduler 15’s Chrome Functions which includes an explanation of using Chrome’s Developer Tools to identify elements.

At some point you may need to switch the browsing context back to the parent frame. To do this you call ChromeSwitchFrame/EdgeSwitchFrame again with a null index. Subsequent calls to the Chrome/Edge functions will then act against the parent frame.

ChromeSwitchFrame>session_id,index,null,res

Traversing Frames

Since each time you switch frames you change the context to that frame, calling ChromeSwitchFrame or EdgeSwitchFrame again (on a valid frame element within) will switch the context down another level.

//Find the frame using xpath
ChromeFindElements>sessionID,xpath,//iframe[@src='/contact-form/formpage.html'],elements
ChromeSwitchFrame>session_id,element,elements_1,res

//Switch to the next frame down *within the current frame*
ChromeSwitchFrame>session_id,index,0,res

Differences between Edge and Chrome

The Edge and Chrome functions work in the same way and are almost identical. There’s one major difference when it comes to switching frames. When specifying an element (rather than index) ChromeSwitchFrame requires the element ID, whereas EdgeSwitchFrame requires the full element object. As well as an array of element IDs, EdgeFindElements returns a second array of the objects:

EdgeFindElements>sessionID,xpath,//iframe[@src='/contact-form/formpage.html'],FrameElements

This returns two arrays prefixed with the name passed as the return var (TheElements): FrameElements_1 … FrameElements_n and FrameElements_objects_1 … FrameElements_objects_n. For EdgeSwitchFrame use the second _objects array:

//switch to the frame
EdgeSwitchFrame>session_id,element,FrameElements_objects_1,res

More Help

View the Chrome Functions and Edge Functions topics in the Macro Scheduler Manual.

Full Example:

Let>CHROMEDRIVER_EXE=c:\chromedriver.exe

//start a Chrome session
ChromeStart>session_id

//navigate to google.com
ChromeNavigate>session_id,url,https://www.mjtnet.com/contact.htm

//Find the frame
ChromeFindElements>sessionID,xpath,//iframe[@src='/contact-form/formpage.html'],elements

//switch to the first frame (the one with the fields)
ChromeSwitchFrame>session_id,element,elements_1,res

//now anything we do is inside that frame so we should be able to get the name field and enter something
ChromeFindElements>session_id,id,name,inputs
ChromeSetElementValue>session_id,inputs_1,john doe

//Switch context back to parent
ChromeSwitchFrame>session_id,index,null,res

I wanted an example that wasn’t too involved but juicy enough to offer a few hurdles and demonstrate some features like xpath. I’ve set upon using Yahoo Finance to pull out the value of a stock symbol. Bear in mind that websites have a habit of changing so I can’t guarantee that the code in this article will work 6 months from now. But that shouldn’t matter much – it’s the principles of how to do this that matters most.

Before we begin make sure you are running Macro Scheduler 15.0.06 or above.

ChromeDriver

Before we can use the new Chrome functions we need to download the win32 version of ChromeDriver from: https://chromedriver.chromium.org

The zip file contains a single file: chromedriver.exe. Save this somewhere.

We need to tell the script where chromedriver.exe is. In my examples below I’ve got it in the root of drive C. So the first line of my script needs to be:

Let>CHROMEDRIVER_EXE=c:\chromedriver.exe

Start a Chrome Session

Now, we can start a Chrome session. To do this we use the ChromeStart function and give it a variable name that we want the session ID stored in. I’m using session_id. We’ll need this for the rest of the commands:

ChromeStart>session_id

Run your script and if your script is correctly pointing at ChromeDriver.exe you should see an empty Chrome window appear.

Navigating

To navigate to Yahoo add the ChromeNavigate command, passing the session_id to it:

ChromeNavigate>session_id,url,https://finance.yahoo.com/

Close the Chrome browser window (you don’t have to but running your script is going to start another) and run your script again.  This time you should see it navigate to Yahoo and show something like this:

Using Developer Tools

So the first thing we need to do is get past that “I agree” button. This is where Chrome’s Developer Tools comes in to help us find the element and the attributes we can use to identify it.

Right click on the “I agree” button and select “Inspect” at the bottom of the popup menu.  Chrome’s Developer Tools should appear. Usually at the bottom, but if you’ve used it before you may have changed the layout. It should appear in ‘Elements’ view and the highlighted element should be the “I agree” button:

Sometimes, I’ve found that the first time I select “Inspect”, if Developer Tools wasn’t already open, the element I want isn’t the highlighted one. Usually right clicking on the element and selecting Inspect a second time does the trick.

Another way to identify the element once Developer Tools is already open is to click the element selector button which you see at top left in the screenshot above. Then move the mouse to the “I agree” button and click.

Once you’ve got the right element selected look for an attribute which we could use to identify it:

<button type="submit" class="btn primary" name="agree" value="agree">I agree</button>

Ideally we want something unique.That isn’t always possible and I’ll talk about what we can do in those cases later. Here we’re in luck. The element has a name – “agree”. We can use this to get a reference to the element so that we can then ‘click’ it:

ChromeFindElements>session_id,name,agree,agree_elements

Notice how we’re passing the session ID again (we want to make sure we’re referring to the Chrome window we started). The second parameter is the “Strategy” we want to use to identify the element. ‘Name’ is an available strategy – find the element by name. The third parameter is the strategy value. For ‘Name’ it’s the name itself which in this case is “agree”. Finally we give the command a variable name we’d like to store the located element IDs in.

Valid ‘strategies’ you can use are:

id, name, class name, css selector, link text, partial link text, tag name, xpath

Clicking on the Element

ChromeFindElements returns an array of matching elements. In this case the array should have only one item because there’s only one matching element. So the item we want is the first one: agree_elements_1.

Let’s use that to click on the button using the ChromeElementAction command:

ChromeElementAction>session_id,agree_elements_1,click

The script so far:

Let>CHROMEDRIVER_EXE=c:\chromedriver.exe
ChromeStart>session_id
ChromeNavigate>session_id,url,https://finance.yahoo.com/
ChromeFindElements>session_id,name,agree,agree_elements
ChromeElementAction>session_id,agree_elements_1,click

Close your browser window and re-run the script. Hopefully you’ll sail right through that I agree box.

ChromeDriver should wait for events to complete and pages to load before firing new events, but if you have any issues you may need to slow things down a touch. E.g. stick a Wait>1 before the click.

Sending the Stock Symbol

We now need to find that input box, enter something and submit it. Using the same ‘Identify’ technique as described above you should find that the input element has its “id” attribute set to “yfin-usr-qry”:

So we’ll use that:

ChromeFindElements>session_id,id,yfin-usr-qry,input_elements

I’ve used input_elements as my array name for the found elements. We now want to enter some text. Let’s search for Microsoft which is stock symbol “MSFT”. To do this we’ll use the ChromeSetElementValue command. There’s only one matching element again so as above we use the first match input_elements_1:

ChromeSetElementValue>session_id,input_elements_1,MSFT
Wait>1

Notice this time I have put a wait afterwards. The next step is to ‘submit’ the field. I found that submitting it without the wait didn’t allow enough time for the entry to ‘take’. There could be some background processing going on which needs time to finish. Remember, as with most automation, we’re automating something that was designed for a user, and Robots run faster than users, so sometimes need slowing down!

We will now use the ChromeElementAction command again, this time with the submit action:

ChromeElementAction>session_id,input_elements_1,submit

Instead of doing this we could have found the search button and issued a ‘click’ on that. But that would require another ChromeFindElements which in this case is unnecessary. We can ‘submit’ the input directly.

Extracting The Stock Value

Rerun the script and you should end up looking at the Microsoft stock info which we want to extract.

Tip: rerunning the script from the top every time isn’t ideal. We’ve got the Chrome window open so the session is still active. So what you could do if you just want to run and test a few commands is grab the session ID from the watch list and assign it with a Let statement placed just before the commands you want to test. E.g:

Let>session_id=b6976cfec0326dcce35ad3674c3ed90e
ChromeFindElements>session_id,id,yfin-usr-qry,input_elements
ChromeSetElementValue>session_id,input_elements_1,MSFT

This is where things get a little more interesting. Use the inspect element tool to locate the element as above. You’ll see it’s a span element. You might also notice the class keeps changing. This site is very dynamic, updating as the stock value changes. In this instance we aren’t lucky enough to have an id, or a name. But notice those custom ‘data-reactid’ attributes.  You’ll see that they all have different values, and the one we want is “34”.  Let’s see if we can use that.

Now, ‘data-reactid’ is a custom attribute. It’s not standard html, and there’s no ‘strategy’ called that. So we’re going to use something called ‘xpath’. xpath is incredibly powerful and can help us find pretty much anything. There’s a great tutorial on xpath here.

We need to find a ‘span’ element with attribute data-reactid which is set to “34”. In xpath we can do this with:

//span[@data-reactid='34']

The // means find nodes regardless of where they are – we don’t need to provide a path. The @ symbol is used to specify an attribute. And we’re giving it a value. We’re saying find a span element with attribute data-reactid set to value “34” and we don’t care where it is.

So we can use this in the ChromeFindElements command as follows:

ChromeFindElements>session_id,xpath,//span[@data-reactid='34'],info_elements

Now, before we continue we should confirm whether or not this is the ONLY span tag with this attribute and value. We could do that either by searching the source using Chrome’s element inspector, or, I think easier, just debug the code to see what we get back. Stick a breakpoint just after this line, run the script and then look at the watch list. You’ll see there are two:

Now, we’re going to need to extract them to see which is the right one. We’re going to use the ChromeGetElementData command:

ChromeGetElementData>session_id,info_elements_1,text,stockValue

If you step through this command and look at the value of stockValue in the watch list, you’ll notice that info_elements_1 is not the one we want. We want the second one:

ChromeGetElementData>session_id,info_elements_2,text,stockValue
MessageModal>Value is %stockValue%

So there we have it. We’ve started Chrome, navigated to Yahoo Finance, clicked ‘I agree’, searched for MSFT and extracted the stock value.  We might want to close the Chrome window at the end:

ChromeQuit>session_id

Here’s the full script:

Let>CHROMEDRIVER_EXE=c:\chromedriver.exe

ChromeQuit>session_id

Using Edge instead of Chrome?

The Edge commands work in exactly the same way as Chrome. And finding elements in Edge is done in exactly the same way. So you should be able to adapt the above code to work with Edge very easily. The main difference is that Edge is a bit more picky when it comes to installing the correct version of Edge Driver.  And if you have an older ‘legacy’ version of Edge you will need to install Microsoft Web Driver instead of MS Edge Driver.  The manual explains how.

Conclusion

The Chrome and Edge functions are incredibly powerful and finding elements using Chrome’s, or Edge’s, Developers Tools is quick and easy. There’s also a lot more that you can do, such as grab the entire source of the page. I hope this has been useful. Let me know in the comments below how you are using these functions.

You’ll find more info in the manual. See Chrome Functions and Edge Functions.

If you have any questions find me on the forums or drop us a line.

As well as lots of small internal improvements, Macro Scheduler 15 brings native functions for automating the Chrome and Microsoft Edge browsers. We’ve also added some new Excel functions, including one that allows you to run any VBA code you like, making the native Excel functions infinitely extendable.

It was also time for a visual refresh…

Modern Web Browser Automation

With Macro Scheduler 15 we’ve introduced two sets of new web browser automation commands. One for Microsoft Edge and another for Google Chrome.

These functions use the new WebDriver interface, and connect to Chrome and Edge via Google’s ChromeDriver and Microsoft’s WebDriver or MS Edge Driver components.

Here’s a short video of Chrome being controlled with these new commands:

For more info see the help topics: Chrome Functions, Edge Functions.

Enhanced Excel Automation

More Excel functions has been a popular request. So we added some. The challenge though, is how to know when to stop. Microsoft’s Excel VBA is pretty unlimited. There’s no way we could wrap every possible function into a native Macro Scheduler one, so we needed a solution.

Well, for years now we’ve been able to convert Excel VBA into VBScript which can be run inside Macro Scheduler. But converting VBA to VBScript can be challenging. Instead, we thought it would be great if you could just pass any valid VBA directly into Excel. So now you can!

//run pure VBA code to set the color
XLRunCode>xlH,ActiveSheet.Range("B12").Interior.Color = vbRed

//could be an entire block of code - let's create a bar chart 
LabelToVar>vba_code,theCode
XLRunCode>xlH,theCode

/*
vba_code:
  Range("A1:B11").Select
  ActiveSheet.Shapes.AddChart2(201, xlColumnClustered).Select
  ActiveChart.SetSourceData Source:=Range("Sheet1!$A$1:$B$11")
  ActiveSheet.Shapes("Chart 1").IncrementLeft +50
  ActiveSheet.Shapes("Chart 1").IncrementTop -30
*/

You should be able to record a macro in Excel and then copy/paste the code it produces into Macro Scheduler like the above.

Downloads & Upgrades

Licensed Downloads/Upgrades | Trial Version | New Licenses

If you have a subscription visit your personal link sent to you in your welcome email.

The optional arguments x and y can be used to specify return variables which will store the position of the image found. This is useful as it means as well as waiting for a screen image you can interact with it without using a subsequent FindImagePos call.

Here’s a usage example :

//with position returned
WaitScreenImage>%SCRIPT_DIR%\save.bmp,0.7,CCOEFF,XArr,YArr
MouseMove>XArr_0,YArr_0

Yes, you can. It may not be obvious from the documentation but with XLSetCell you can output any expression accepted by Excel. It doesn’t have to be a literal value.

You might set a literal value with something like this:

XLSetCell>xlH,Sheet1,2,2,560,result

In Excel you insert a function by starting the input with the ‘=’ sign, so we can do the same with XLSetCell:

XLSetCell>xlH,Sheet1,20,2,=SUM(B1:B19),result

In the same way we can force the cell to text format by preceding the input with an apostrophe:

XLSetCell>xlH,Sheet1,2,2,'560,result

These formats are standard Excel features. All we’re doing here is passing a value to Excel that it understands. But you may not have realised you can do this with Macro Scheduler’s native functions.

Coming Soon – More functions & run ANY VBA code!

A few people have requested more native XL functions. We’re working on it.

For example, a new function to set the cell colour:

RGB>50,150,50,color1
XLSetCellColor>xlH,Sheet1,13,2,color1

But how about being able to run ANY valid Excel VBA you like?

XLRunVBA>xlH,ActiveSheet.Range("B12").Interior.Color = vbRed

It could be a whole block of code:

LabelToVar>vba_code,theCode
XLRunVBA>xlH,theCode

/*
vba_code:
  Range("A1:B11").Select
  ActiveSheet.Shapes.AddChart2(201, xlColumnClustered).Select
  ActiveChart.SetSourceData Source:=Range("Sheet1!$A$1:$B$11")
  ActiveSheet.Shapes("Chart 1").IncrementLeft +50
  ActiveSheet.Shapes("Chart 1").IncrementTop -30
*/

These features are in development. Watch them in action here:

The sky is the limit!

Note: At time of writing these functions do NOT exist in the current version. These are in development. Their names and syntax may change. Keep an eye out for updates.

Be the first to get these new features by making sure your maintenance or subscription us up to date