This feature allows you to run a temporary flow, assembled in memory, without previously creating and saving a flow in Dablio Robô. JSON can be sent via the page URL itself or via a JavaScript event CustomEvent.

It is recommended for integrations between systems, internal panels, ERPs, quick action links, indirect webhooks, pages that need to trigger local automations in the browser and scenarios where the flow is dynamically generated by an external application.

Parameters available in the URL

How to encode JSON to Base64URL

The parameters dablioroboWorkflow, dablioroboCommands and dablioroboData must be sent as Base64URL to avoid problems with quotes, accents, curly braces, slashes, spaces and special characters within the URL.

function toBase64Url(obj) {
  const json = JSON.stringify(obj);
  const utf8 = new TextEncoder().encode(json);
  let binary = '';

  utf8.forEach(byte => {
    binary += String.fromCharCode(byte);
  });

  return btoa(binary)
    .replace(/\+/g, '-')
    .replace(/\//g, '_')
    .replace(/=+$/g, '');
}

const workflowBase64 = toBase64Url(workflowJson);
const commandsBase64 = toBase64Url(commandsJson);

Example 1 — Send complete workflow via URL

In this format you send the entire workflow, similar to a flow exported by Dablio Robô. The stream will not be saved to local storage.

{
  "nome": "Consulta rápida no Google",
  "ativo": true,
  "blockDelay": 500,
  "startBlockId": "start",
  "trigger": {
    "tipo": "manual",
    "config": {}
  },
  "blocks": [
    {
      "id": "start",
      "type": "trigger",
      "config": []
    },
    {
      "id": "abrir_google",
      "type": "new-tab",
      "config": {
        "ativo": true,
        "url": "https://www.google.com",
        "criarNa": "janelaAtual",
        "aguardarCarregamento": true,
        "definirAbaAtiva": true
      }
    },
    {
      "id": "digitar_busca",
      "type": "forms",
      "config": {
        "ativo": true,
        "seletor": "textarea[name='q'], input[name='q']",
        "aguardarSeletor": true,
        "tempoAguardarSeletor": 15000,
        "acao": "text",
        "valor": "Dablio Group",
        "limparCampo": true
      }
    },
    {
      "id": "enviar_form",
      "type": "forms",
      "config": {
        "ativo": true,
        "seletor": "form[action*='/search']",
        "aguardarSeletor": true,
        "tempoAguardarSeletor": 10000,
        "acao": "submit"
      }
    }
  ],
  "connections": [
    {
      "from": { "blockId": "start", "port": "default" },
      "to": { "blockId": "abrir_google", "port": "in" }
    },
    {
      "from": { "blockId": "abrir_google", "port": "default" },
      "to": { "blockId": "digitar_busca", "port": "in" }
    },
    {
      "from": { "blockId": "digitar_busca", "port": "default" },
      "to": { "blockId": "enviar_form", "port": "in" }
    }
  ]
}

https://www.google.com/?dablioroboWorkflow=BASE64URL_DO_WORKFLOW&runToken=SUA_SENHA&dablioroboOnce=1&dablioroboNow=1

Example 2 — Send sequential commands via URL

In this format you only send a list of commands. The robot automatically assembles the starting block, intermediate blocks and sequential connections.

[
  {
    "type": "open",
    "url": "https://www.google.com",
    "wait": true
  },
  {
    "type": "type",
    "selector": "textarea[name='q'], input[name='q']",
    "value": "Dablio Group",
    "wait": true,
    "clear": true
  },
  {
    "type": "submit",
    "selector": "form[action*='/search']",
    "wait": true
  },
  {
    "type": "click",
    "selector": "h3",
    "wait": true
  }
]

https://www.google.com/?dablioroboCommands=BASE64URL_DOS_COMANDOS&runToken=SUA_SENHA&dablioroboOnce=1&dablioroboNow=1

Aliases accepted in short commands

Send variables along with the flow

Use dablioroboData to send initial data for the run. This data enters the context of the flow and can be consumed by blocks as variables.

https://www.google.com/?dablioroboWorkflow=BASE64URL_DO_WORKFLOW&dablioroboData=BASE64URL_DAS_VARIAVEIS&runToken=SUA_SENHA&dablioroboOnce=1&dablioroboNow=1

Example 3 — Execute temporary workflow via CustomEvent

Use this format when the page is already open and you want to trigger automation via JavaScript, without reloading the URL.

window.dispatchEvent(new CustomEvent('dabliorobo:execute-workflow', {
  detail: {
    runToken: 'SUA_SENHA',
    workflow: {
      nome: 'Fluxo temporário via evento',
      ativo: true,
      blockDelay: 500,
      startBlockId: 'start',
      trigger: {
        tipo: 'manual',
        config: {}
      },
      blocks: [
        {
          id: 'start',
          type: 'trigger',
          config: []
        },
        {
          id: 'aguardar_1s',
          type: 'delay',
          config: {
            ativo: true,
            tempoMs: 1000
          }
        }
      ],
      connections: [
        {
          from: { blockId: 'start', port: 'default' },
          to: { blockId: 'aguardar_1s', port: 'in' }
        }
      ]
    },
    data: {
      cliente: '123',
      origem: 'meu-sistema'
    }
  }
}));

Example 4 — Execute commands via CustomEvent

window.dispatchEvent(new CustomEvent('dabliorobo:execute-workflow', {
  detail: {
    runToken: 'SUA_SENHA',
    commands: [
      {
        type: 'open',
        url: 'https://www.google.com',
        wait: true
      },
      {
        type: 'type',
        selector: "textarea[name='q'], input[name='q']",
        value: 'Dablio Group',
        wait: true,
        clear: true
      },
      {
        type: 'submit',
        selector: "form[action*='/search']",
        wait: true
      }
    ],
    data: {
      origem: 'custom-event'
    }
  }
}));

Capture execution feedback

After receiving the request, the content script returns the result via the event dabliorobo:execute-workflow:result. This return informs whether the flow was received, whether it was started and what the error was in case of blocking.

window.addEventListener('dabliorobo:execute-workflow:result', function (event) {
  console.log('Resultado Dablio Robô:', event.detail);

  if (event.detail.ok) {
    console.log('Fluxo recebido e iniciado:', event.detail.instanceId);
  } else {
    console.error('Falha ao iniciar fluxo:', event.detail.error);
  }
});

Security validation with runToken

Main blocking errors

The block Trigger It is the mandatory starting point of any flow. It defines when and how the flow will start. Each flow must have exactly one Trigger.

Defines how and when the flow starts. Supports manual triggering, by interval, day of the week, when visiting a website, on a specific date/time, when opening the browser, by context menu or keyboard shortcut.

// Disparar pelo ID do fluxo
window.dispatchEvent(new CustomEvent('dabliorobo:execute-workflow', {
  detail: { id: 'workflow-id' }
}));

// Passar variáveis para o fluxo
window.dispatchEvent(new CustomEvent('dabliorobo:execute-workflow', {
  detail: {
    id: 'workflow-id',
    data: {
      variables: {
        nome: 'João Silva',
        busca: 'produto XYZ'
      }
    }
  }
}));

Calls another flow as a subroutine. The child flow automatically receives the variables and tables from the parent and, after completing, the parent continues normally along the default path.

Runs another workflow from this point. Automatically shares variables, tables and the target tab between the parent and child flow.

Checks in real time if another flow is running at this moment. Useful for avoiding parallel executions or waiting for a concurrent stream to finish.

Checks whether a specific flow is currently running. Returns true (running) or false (stopped).

Stops the execution of the current flow or other flows in progress. It can terminate with Success status or throw an Error to activate failure handling blocks.

Stops the execution of the current flow or other flows in progress. It may terminate successfully or throw an error.

Pauses execution for the configured time before advancing to the next block. Essential for waiting for loads, page animations and time windows between actions.

Pauses flow execution for a configured time in milliseconds before advancing to the next block.

Exports data collected by the flow to local files. Supports data tables, individual variables and custom content, with multiple output formats.

Exports collected data (tables, variables, or custom text) to a local file in various formats.

Makes HTTP/HTTPS requests to external APIs. Supports all REST verbs, authentication via headers, multiple body formats and response types.

Makes an HTTP request to APIs or external services. Supports all methods, custom headers, body types and receives the response as JSON, text or Base64.

Authorization: Bearer {{meuToken}}
Content-Type: application/json
X-Api-Key: minha-chave-secreta

{
  "status": 200,
  "data": {
    "nome": "Lista de preços",
    "valores": [
      { "id": 1, "preco": 4000 },
      { "id": 2, "preco": 24000 }
    ]
  }
}

[
  ["campo", "valor"],
  ["arquivo", "C:\\Downloads\\documento.pdf"],
  ["imagem", "https://exemplo.com/foto.png"]
]

{
  "nome": "{{nomeCliente}}",
  "email": "{{emailCliente}}",
  "total": {{valorTotal}}
}

Reads or writes data to the system clipboard (Ctrl+C/Ctrl+V). Useful for transferring data between the stream and the operating system.

Copies text to the system clipboard or reads the current content copied by the user.

Waits for all previous connected blocks to finish before continuing. Useful for synchronizing parallel streams.

Visually groups other blocks within a container to organize and structure the flow. It does not perform any action by itself.

Visual notepad. Does not perform any actions during the flow. It is used exclusively to document and organize the canvas.

Displays visual alerts to the user: as native Windows notifications (corner of the screen) or as floating popups within the active page in the browser.

Displays a notification to the user on the Windows operating system and/or as an HTML popup within the active page, with different visual styles.

Plays an audible alert to attract the user's attention during or after performing tasks. Useful when the stream runs in the background.

Plays an audible alert for a set time. Useful for signaling completion of important tasks or events.

Displays a semi-transparent overlay with loading indicator over the page, preventing the user from clicking or interacting while the robot works.

Displays a lock screen with loading indicator to prevent user interaction while the flow is running.

Displays an interactive modal window within the page. It can be simple (information with OK) or a mini-form with text fields, selects and multiple action buttons.

Displays a dialog box on the screen and waits for user action. Supports multiple response buttons, text fields, selects and checkboxes.

Defines which browser tab will be the target of the next blocks. Changes the execution context to the tab found by the configured criteria.

Focuses on a specific tab and defines it as the target for all future blocks in the flow.

Opens a new tab in the browser with the configured URL and offers full control over window, identification and loading behavior.

Opens a new tab in the browser with advanced window controls, page identification and waiting for complete loading.

Switches the execution focus to another tab already open in the browser, identified by URL, title, index or relative position.

Switch focus to another tab based on URL, title, index, relative position or saved page.

Opens a new browser window, separate from the current tabs. Supports private/incognito mode, popups without address bar and custom dimensions.

Opens a new browser window with advanced options: private/incognito mode, type, initial state and custom dimensions.

Navigates to the previous page in the active tab's history, equivalent to the browser's back button.

Returns to the previous page in the active tab, equivalent to the browser's back button.

Navigates to the next page in the active tab's history (only if it exists), equivalent to the browser's Next button.

Advances to the next page in the active tab, equivalent to the browser's Next button.

Closes specific tabs or windows while streaming. It supports multiple selection criteria and can close more than one tab at once.

Closes tabs or windows by criteria: active tab, visible tab, window, by URL, title, index or saved page. Supports multiple close.

Captures screen images in 4 modes: visible area of the page, full page with scroll, specific element or complete element with a height greater than the screen.

Takes a screenshot of the visible area, full page, specific element, or full element with scroll.

Pauses the flow waiting for a specific browser or page event: tab open/close, click, typing, form submission, scroll and more.

Pauses the flow until a specific event occurs in the browser or on a page element.

Configures a proxy server for all browser navigation, useful for bypassing geographic restrictions or rotating IPs in scraping automations.

Configure a Proxy server (HTTP/HTTPS/SOCKS4/SOCKS5) for the entire browser connection or remove the current configuration.

Changes the execution context into a <iframe> on the page. Required when the element you want to interact with is inside an inline frame.

Changes the execution focus to a specific iFrame on the page or back to the main page.

Controls how the browser window or specific page elements are displayed, useful for screenshots and systems that require full screen.

Changes the display mode: window (normal/maximized/minimized/full screen), full page or expands a specific element.

Reloads one or more browser tabs, equivalent to F5. Useful for updating data in dashboards or after modifications that require reloading.

Reloads one or more tabs by criteria: active tab, visible, by title, index or URL.

Captures the URL and/or title of open tabs and saves them in flow variables for later use.

Gets the URL and/or title of one or more open tabs and saves it in variables.

Manages browser cookies for specific websites: reads values, creates/updates or removes session cookies.

Reads, creates, updates or removes cookies from the current website.

Intercepts and manages file downloads: it can wait for a download to start, download directly via URL or extract media (images, videos, audios) from page elements.

Wait for a download to start, download file via direct URL or extract media (img, audio, video) from page elements.

Clicks on page elements using CSS or XPath selectors. The most used block in web automations.

Click on one or more elements on the page using the CSS or XPath selector, with support for waiting for the element to appear.

Extracts content from page elements: plain text, internal HTML, or form field values. Saves it to a variable for use in subsequent blocks.

Extracts text, internal HTML, or values from page elements. Supports multiple elements (returns array).

The most versatile block for interacting with forms: fill in text fields, select options, mark checkboxes, click on radio buttons and can extract all data from a form at once.

Interact with forms: fill in text fields, select options from lists, mark checkboxes and radio buttons, or extract data from the form.

Scrolls the page or an element with scrollbar to a specific position or to display an element on the screen.

Scrolls the page or a specific element horizontally and/or vertically, with scrolling support for smooth preview and animation.

Reads, sets, or removes HTML attributes from any element. Covers from standard attributes (href, src, class) to custom data attributes (data-id, data-value).

Reads, sets or removes HTML attributes from elements such as href, src, class, style, data-id and any other custom attributes.

Injects and executes JavaScript directly into the page (MAIN world context) or service worker. It has full access to the DOM, flow variables and extension APIs.

Executes JavaScript on the page (page context) or in the background (service worker). Use 'return' to save the result in a stream variable.

// Lê variável do fluxo
const usuario = vars.nomeUsuario;

// Manipula DOM
document.querySelector('#campo-login').value = usuario;

// Faz uma requisição assíncrona
const resp = await fetch('/api/verificar?user=' + usuario);
const dados = await resp.json();

// Salva resultado no fluxo
vars.usuarioAtivo = dados.ativo;

// Retorna para variável configurada
return dados.ultimoAcesso;

// Ler variável do fluxo
const cliente = vars.nomeCliente;

// Modificar DOM da página
document.querySelector('#campo-busca').value = cliente;

// Fazer requisição assíncrona (await funciona normalmente)
const resp = await fetch('https://api.exemplo.com/dados?q=' + cliente);
const dados = await resp.json();

// Gravar resultado de volta no fluxo
vars.totalResultados = dados.total;

// Retornar valor para a variável configurada no bloco
return dados.items[0].nome;

Triggers DOM events on page elements, simulating interactions that other blocks do not cover. Essential for systems that only respond to native JavaScript events.

Triggers DOM events on page elements: mouse, keyboard, form, clipboard, touch and others, with advanced modifier and coordinate options.

Simulates hovering over a page element (mouseover/hover), revealing dropdown menus, tooltips and content that only appear with the cursor over the element.

Simulates hovering the mouse over a page element (mouseover/hover event), useful for displaying menus, tooltips and dynamic content.

Simulates the action of dragging and dropping page elements. Useful for interfaces with Kanban boards, list ordering, sliders and editing tools.

Simulates dragging an element from point A to point B with position, speed and button press settings.

Upload files into fields input[type=file], bypassing the limitation that the browser does not allow direct automation of the operating system's file selector.

Uploads files via URL/Base64, local folder, absolute path or simulates click for the user to select manually.

Simulates key presses and keyboard shortcuts, or types complete text key by key with configurable timing.

Press a keyboard shortcut (e.g. CTRL+S) or type text key by key, with optional focus on the target element.

Injects custom HTML, CSS, and JavaScript directly into the page in a position relative to the target element. Allows you to visually extend any website without modifying its code.

Inserts HTML, CSS and JavaScript code into the page at a specific position in relation to the target element.

<div style='position:fixed;bottom:20px;right:20px;z-index:9999;background:#1a6eff;color:white;padding:12px 20px;border-radius:8px;cursor:pointer;font-family:sans-serif;box-shadow:0 4px 20px rgba(26,110,255,0.4)' onclick='window.__dablioExportar()'>&#128190; Exportar Dados</div>
<script>
window.__dablioExportar = function(){
  window.dispatchEvent(new CustomEvent('dablio-export'));
};
</script>

Checks whether an element is present in the page's DOM, with configurable multiple retries before completing. Return exists or fallback.

Checks whether an element exists on the page with multiple attempts before going through the success or fallback port.

Read the attribute href of a link element and navigates to the destination — more robust than clicking directly as it does not rely on the link's CSS or JavaScript behaviors.

Reads the href attribute of an element and navigates to the link in the same tab, new tab, or new window.

Checks the existence of a file in a local folder before trying to process it, preventing errors in flows that depend on external files.

Checks whether a file exists in a selected local folder. Supports search by exact name, base name or regular expression.

Decision block that compares two values and directs the flow to the path True or False.

Compares two values and directs the flow along the True or False path. Supports literal values, variables, element texts, HTML attributes and JavaScript code.

Iterates over all elements found by a selector, executing the internal blocks for each. The equivalent of forEach in web automation.

Cycles through all occurrences of a CSS/XPath selector executing the inner blocks for each element found.

/* Se o identificador do loop for "linha" */
[wRobo-loop="linha_0"]              /* primeiro elemento */
[wRobo-loop="linha_0"] td:nth-child(2)  /* segunda coluna do primeiro elemento */
[wRobo-loop="linha_0"] .btn-acao    /* botão dentro do primeiro elemento */

Repeats internal blocks a fixed number of times. The equivalent of a loop for(i=0; i<N; i++).

Repeats internal blocks a set number of times.

/* URL na Nova aba (loopIndex começa em 0, então somamos 1) */
https://site.com/produtos?pagina={{loopIndex + 1}}

/* Ou inicialize uma variável separada e use Incrementar Variável */
https://site.com/produtos?pagina={{pagina}}

Iterates over lists of data: variable arrays, numeric ranges, or custom JSON data. The current item is accessible via the configured variable.

Iterates through a list (variable array, sequential numbers, or JSON data) repeating the internal blocks for each item.

Immediately breaks the nearest loop (Repeat Tasks, Traverse Data, or Traverse Elements) and continues the flow after the loop block.

Immediately stops the nearest loop or repetition (Repeat tasks, Cycle through data, or Cycle through elements).

The most straightforward variable creation block: sets the value of a variable, adds data to a stream table, or reads contents from files.

Populates variables, stream tables, or local storage tables. Accepts manual text, variables and file contents.

Transforms and extracts data from existing variables: string slicing, extraction by content type and regular expressions.

Creates, updates, or extracts parts of content into a new variable. Supports text/data slicing, extraction by type and regular expressions.

Increments or decrements a numeric value of a variable by a configured amount. The simplest block for creating counters.

Increments or decrements the numerical value of a variable by a given value.

/* Antes do loop: Inserir dados */
Variável: pagina
Valor: 1

/* URL na Nova aba */
https://site.com/lista?page={{pagina}}

/* Dentro do loop: Incrementar variável */
Variável: pagina
Incremento: 1

Removes a variable from stream memory. Useful for freeing up space in long streams or ensuring variables don't carry values ​​from previous iterations.

Removes a variable or data from memory during flow execution.

Performs mathematical calculations with support for specialized functions for Brazilian business scenarios, including currency formatting in Real (BRL).

Performs mathematical calculations with standard operators and specialized functions, including Brazilian currency conversion.