# AdOps — full corpus > Every English page of https://adops.id as one Markdown document. AdOps is a rule-automation > platform for Meta (Facebook) Ads: advertisers define conditions matched against Meta > Insights and actions applied to their campaigns, and a server-side engine evaluates > them on a schedule and records what it did. Generated 2026-09-12. Canonical index: https://adops.id/llms.txt Each section below carries its own canonical URL and last-updated date. When quoting a passage, attribute it to the URL given in that section rather than to this file. AdOps is an independent product and is not affiliated with, endorsed by, or sponsored by Meta Platforms, Inc. --- ## Feature — Rule automation Source: https://adops.id/features/rule-automation/ Last updated: 2026-08-20 Conditions on live Meta metrics paired with actions the engine executes on your campaigns, with an execution log behind every run. **Key facts** - Dispatch interval: Every 10 seconds (Cron sweep with overlap prevention, so one tick never re-enters a sweep already running) - Comparison operators: 6 (greater than, less than, greater than or equal, less than or equal, equal, not equal) - Targeting levels: 2 (Campaigns and ad sets) - Pre-filter fields: 3 (campaign.id, campaign.name, campaign.effective_status) - Queue fan-out: 1 job per ad account (Enqueued onto a Redis-backed BullMQ queue named facebook_queue) - Entity fetch retries: 3 total attempts (Waits 1 second, then 2 seconds, before skipping that ad account) AdOps automates Meta Ads through rules you write yourself. A rule pairs conditions on live campaign metrics with an action AdOps executes against Meta's Graph API. Each rule targets campaigns or ad sets, combines its conditions with AND or OR, and writes an evidence row for every campaign it evaluated, whether or not anything changed. ## What is an AdOps rule made of? A rule carries a name, the ad accounts it covers, a level, a set of pre-filters, a schedule, and a list of tasks. The rule builder hints that you select up to 5 ad accounts per rule. A task is the working unit. Each one holds a single action, its own condition set, and an optional cooldown. Because tasks live in an array, one rule can encode a whole playbook instead of forcing you to create three rules that fight each other. A rule sits in `DRAFT` until you set it live, and only `ACTIVE` rules are ever picked up by the dispatcher. ## How do conditions combine? Every condition is four things: a metric, a reporting period, an operator, and a value. AdOps ships 45 Meta Ads metrics and 11 reporting periods, so `Purchase ROAS` over `Last 7 days` is one condition and `Spend` over `Today` is another. Six operators are available on each condition. | Operator | Symbol | Menu label | | --- | --- | --- | | `GREATER_THAN` | `>` | greater than | | `LESS_THAN` | `<` | less than | | `GREATER_THAN_EQUAL` | `>=` | greater than equal | | `LESS_THAN_EQUAL` | `<=` | less than equal | | `EQUAL` | `=` | equal | | `NOT_EQUAL` | `!=` | not equal | The conditions inside one task are combined by a single group operator, `AND` or `OR`, which you toggle by clicking it. A condition's right-hand side is normally a number, but switching its compare mode to `metric` lets you test one metric against another, each with its own reporting period. ## Which campaigns does a rule touch? Two things decide that. First the level, which is either `campaign` or `adset`. Second the pre-filters, which run before any metric is read. | Pre-filter field | Operators | Values | | --- | --- | --- | | `campaign.id` | equal, not equal | a campaign ID | | `campaign.name` | contains, does not contain | free text | | `campaign.effective_status` | is, is not | `ACTIVE`, `PAUSED` | As you change the level or the filters, the builder calls the estimate endpoint after a 500 ms debounce and shows an `Estimated match: N Campaigns` readout, with a per-account breakdown on hover. You see the blast radius before the rule is live. ## What happens between the tick and the action? The engine is split into a producer and a worker so that the part deciding what to run is not the part allowed to change anything. 1. A cron sweep fires every 10 seconds and selects every `ACTIVE` rule whose next execution time has passed and whose date window is open. The cron is configured with overlap prevention, so a slow sweep is never re-entered by the following tick. 2. The producer pulls matching entities from the Meta Graph API, 1000 per page, following Meta's own paging cursors. An ad account whose fetch fails is retried up to 3 total attempts, waiting 1 second and then 2 seconds, then skipped rather than blocking the rest. 3. One job per ad account is enqueued onto a Redis-backed BullMQ queue named `facebook_queue`. 4. The worker groups the rule's conditions by reporting period, unions the Meta Insights fields those periods need, and issues them as a single Graph batch request. Every Insights call is sent with `use_unified_attribution_setting=true`, so the numbers the rule judges are the numbers your ad set's attribution window reports. 5. Conditions are evaluated, actions are executed, and results are persisted as one `rule_result` per campaign per task plus a `rule_benchmark` roll-up for the batch. Batch progress is reported back to the queue as a whole percentage after each campaign finishes, so a run in flight shows a real figure rather than a spinner. ## What are the honest limits? The 10-second tick is how often AdOps looks for due work, not a promise about end-to-end latency. A sweep processes due rules one after another, and a large account with many pages of campaigns takes as long as Meta takes to answer. Treat the check interval as the floor on how often a rule can be considered, not as a service level. The dispatcher's blast radius is worth stating plainly, because it is verifiable rather than aspirational. That process only issues GET requests to Meta and writes two scheduling timestamps to its own database. It never calls a Meta write endpoint, so a bad deploy of the dispatcher cannot alter a campaign. ## Where do you start if you do not want a blank rule? AdOps ships 10 rule templates across 4 categories, tagged budget, status, naming or monitoring. Opening the Templates modal shows each template's task count and a preview of every action, frequency, value and condition it contains before you import it. Importing drops those tasks into the rule you are editing, where they behave like tasks you wrote by hand. --- ## Feature — Metrics library Source: https://adops.id/features/metrics-library/ Last updated: 2026-08-20 Forty-five Meta Ads metrics in six categories, eleven reporting periods per condition, and metric-versus-metric comparison. **Key facts** - Metrics available: 45 (Selectable in any rule condition) - Categories: 6 (conversion 16, cost_efficiency 15, engagement 7, time_based 3, core_performance 2, custom 2) - Reporting periods: 11 (From Today through Lifetime) - Period-capable metrics: 39 of 45 (6 metrics are point in time and take no lookback window) - Dayparting metrics: 2 (Time greater than and Time less than, both weekday aware) - Calculation strategies: 7 (direct, nested_array, custom_calculation, direct_api_call, separate_api_call, time_condition, time_difference) AdOps gives a rule condition 45 Meta Ads metrics to read, organised into 6 categories and evaluated over any of 11 reporting periods. Thirty-nine of those metrics accept a lookback window; the other six are point-in-time values such as Daily Budget and Hours since creation. A condition can also compare one metric against another metric rather than a fixed number. ## What are the six metric categories? | Category | Metrics | What it covers | | --- | --- | --- | | conversion | 16 | Purchase, lead, cart, checkout, registration and subscription counts and values | | cost_efficiency | 15 | Cost per action, CPC, CPM and the two ROAS ratios | | engagement | 7 | Impressions, clicks, link clicks, CTR variants, landing page views, content views | | time_based | 3 | Hours since creation and the two time-of-day conditions | | core_performance | 2 | Spend and Daily Budget | | custom | 2 | Remaining budget and Lifetime budget | ## What is the full metric list? Each row is the label you pick in the builder and the metric key AdOps stores on the condition. | Category | Metric | Key | | --- | --- | --- | | core_performance | Spend | `spend` | | core_performance | Daily Budget | `daily_budget` | | conversion | Purchases | `actions.omni_purchase` | | conversion | Purchase Value | `action_values.omni_purchase` | | conversion | Website Purchases | `actions.offsite_conversion.fb_pixel_purchase` | | conversion | Website purchase value | `action_values.offsite_conversion.fb_pixel_purchase` | | conversion | Adds to cart | `actions.omni_add_to_cart` | | conversion | Adds to cart value | `action_values.omni_add_to_cart` | | conversion | Checkout initiated | `actions.omni_initiated_checkout` | | conversion | Checkout initiated value | `action_values.omni_initiated_checkout` | | conversion | Adds of payment info | `actions.add_payment_info` | | conversion | Add of payment info value | `action_values.add_payment_info` | | conversion | Leads | `actions.lead` | | conversion | Leads value | `action_values.lead` | | conversion | Registration completed | `actions.omni_complete_registration` | | conversion | Registration completed value | `action_values.omni_complete_registration` | | conversion | Subscription | `conversions.subscribe_total` | | conversion | Subscription value | `conversion_values.subscribe_total` | | cost_efficiency | Purchase ROAS | `purchase_roas.omni_purchase` | | cost_efficiency | Website Purchases ROAS | `website_purchase_roas.offsite_conversion.fb_pixel_purchase` | | cost_efficiency | Cost per Purchase | `cost_per_action_type.omni_purchase` | | cost_efficiency | Cost per Website Purchase | `offsite_conversion.fb_pixel_purchase` | | cost_efficiency | Cost per add to cart | `cost_per_action_type.omni_add_to_cart` | | cost_efficiency | Cost per checkout initiated | `cost_per_action_type.omni_initiated_checkout` | | cost_efficiency | Cost per add payment info | `cost_per_action_type.add_payment_info` | | cost_efficiency | Cost per lead | `cost_per_action_type.lead` | | cost_efficiency | Cost per registration completed | `cost_per_action_type.omni_complete_registration` | | cost_efficiency | Cost per content view | `cost_per_action_type.omni_view_content` | | cost_efficiency | Cost per landing page view | `cost_per_action_type.landing_page_view` | | cost_efficiency | Cost per subscribe | `cost_per_conversion.subscribe_total` | | cost_efficiency | CPC | `cpc` | | cost_efficiency | CPC (link) | `cost_per_action_type.inline_link_click` | | cost_efficiency | CPM | `cpm` | | engagement | Impressions | `impressions` | | engagement | Clicks | `clicks` | | engagement | Link clicks | `inline_link_clicks` | | engagement | CTR | `ctr` | | engagement | CTR (link clicks) | `inline_link_click_ctr` | | engagement | Landing page views | `actions.landing_page_view` | | engagement | Content views | `actions.omni_view_content` | | time_based | Hours since creation | `created_time` | | time_based | Time greater than | `time_greater_than` | | time_based | Time less than | `time_less_than` | | custom | Remaining budget | `custom.budget_remaining` | | custom | Lifetime budget | `custom.lifetime_budget` | ## Which reporting period should a condition use? Eleven windows are available per condition: `today`, `yesterday`, `custom_last_3_days` (last 3 days including today), `last_3d`, `custom_last_7_days` (last 7 days including today), `last_7d`, `last_14d`, `last_30d`, `this_month`, `last_month` and `maximum` (lifetime). The two `custom_` windows are rewritten locally into an explicit Meta date range; the rest are passed through as Meta date presets. Because the period lives on the condition rather than the rule, one task can weigh a 30-day trend against today's spike. A pause rule that reads `Purchase ROAS` over `last_7d` and `Spend` over `today` in the same task is normal, and both windows are fetched in the same Meta Graph batch request. ## How does metric-versus-metric comparison work? Each condition carries a compare mode of `value` or `metric`. In `value` mode the right-hand side is the number you typed. In `metric` mode it is a second metric key with its own period, defaulting to today, and your typed number becomes a multiplier on it. That turns a currency threshold into a relationship. Instead of pausing at a hardcoded cost figure that goes stale after every price change, a rule can test spend against revenue for the same campaign. The effective threshold the engine computed is written back onto the saved result, so the log shows both the metric it read and the number it compared against. The compared side has the full vocabulary, not a reduced one. It accepts a custom metric backed by Google Sheets, the live daily budget, remaining and lifetime budget, and any dotted Meta action-type breakdown, each with its own period. ## What sits behind a metric in the catalogue? A metric is a stored document, not a hardcoded string. It carries an id, a display name, a category, a description, a data type of `number` or `hour`, one of 6 units, whether it supports a period, whether it supports weekdays, the Meta API field and nested key, one of 7 calculation strategies, and the exact list of comparison operators that metric allows. The same catalogue is served to the rule builder and injected into the AI rule builder's prompt on every generation, so the two never drift apart. --- ## Feature — Automation actions Source: https://adops.id/features/automation-actions/ Last updated: 2026-08-20 Eleven executable actions across lifecycle, budget and naming, each with its own parameters and an optional cooldown. **Key facts** - Executable actions: 11 (5 General, 3 Budget, 3 Name and text) - Budget value types: 3 (fixed amount, percentage, custom metric) - Dynamic name tokens: 6 (date, time, metric with period, campaign field, custom metric by id) - Name placement modes: 3 (TEXT, APPEND, OVERWRITE) - Action frequency options: 11 (15 minutes through once in a lifetime) - Actions accepting a frequency: 5 (Notify, Duplicate, Increase budget, Decrease budget, Set budget) AdOps can execute 11 actions on the campaigns a rule matches, grouped in the action picker as General, Budget, and Name or text. Every action is written to Meta through one instrumented wrapper, and budget and name actions record the value before and the value after on the result row for that campaign. ## What are the 11 actions? | Group | Action | Key | What it does | | --- | --- | --- | --- | | General | Notify | `notify` | Marks the condition as met on this campaign | | General | Start | `start_campaign` | Writes status `ACTIVE` | | General | Pause | `pause_campaign` | Writes status `PAUSED` | | General | Delete | `delete_campaign` | Writes status `DELETED` | | General | Duplicate | `duplicate_campaign` | Submits a deep copy of the campaign | | Budget | Increase budget | `increase_budget_campaign` | Raises the daily budget, capped at a maximum | | Budget | Decrease budget | `decrease_budget_campaign` | Lowers the daily budget, floored at a minimum | | Budget | Set budget | `set_budget_campaign` | Writes an absolute daily budget | | Name and text | Add to name | `add_name_campaign` | Appends a rendered template to the name | | Name and text | Remove from name | `remove_name_campaign` | Strips a substring from the name | | Name and text | Replace text in name | `replace_name_campaign` | Swaps one substring for another | Duplicate is worth a line of its own. It posts an async batch to Meta asking for a deep copy of the campaign under a generated job name, so Meta clones the whole structure rather than AdOps rebuilding it field by field. ## How do budget changes work? A budget action carries an amount, a cap, and a value type. The value type is `value` for a fixed amount, `percent` for a percentage of the current daily budget, or `custom_metric` to pull the number from a Google Sheets custom metric. Two details make this safe enough to leave running. First, AdOps re-reads `daily_budget` from Meta immediately before a budget action executes, so a change made in Ads Manager five minutes earlier cannot cause a write based on a stale figure. Second, the projected budget is floored to an integer and clamped: when an increase would exceed the maximum cap, AdOps writes exactly the cap, and when a decrease would fall under the minimum, it writes exactly the minimum. Set budget skips the arithmetic and writes the absolute figure you supplied. ## What can go into a campaign name? Name actions also re-read the live campaign name from Meta before writing. Add to name then builds its new text from a multi-line template where each brace-wrapped line is expanded at execution time. | Token | Expands to | | --- | --- | | `{date}` | The execution date | | `{time}` | The execution time | | `{metric\|\|}` | A live Insights value for that metric and period | | `{metric\|}` | A field read straight off the campaign object | | `{metric\|custom_metric\|}` | A computed custom metric | | `{custom_metric\|}` | A computed custom metric | Parts are joined with a separator you supply, and the result is placed by one of three modes. `TEXT` appends the rendered string as-is. `APPEND` adds it after the bot separator, a marker AdOps writes so its own section of the name stays distinct from the part a human wrote. `OVERWRITE` replaces everything after that marker, which is what keeps a nightly performance tag from stacking up forever. Remove from name and Replace text in name are the cleanup pair: one strips a substring, the other swaps it, and both record the old and new name. ## How do action cooldowns stop a rule thrashing? Each task can carry an action frequency, which is a cooldown on that action for that campaign, entirely separate from how often the rule is evaluated. A rule can be checked every 15 minutes and still raise a given campaign's budget only once every 2 hours. Eleven options are available: 15 minutes, 30 minutes, 1 hour, 2 hours, 3 hours, 6 hours, 12 hours, once a day, once in 2 days, once in 3 days, and once in a lifetime. Day-based cooldowns snap to midnight, and once in a lifetime sets the next permitted execution to the year 2100, which is how a tag-once or duplicate-once rule is expressed. Five of the 11 actions accept a frequency: Notify, Duplicate, Increase budget, Decrease budget and Set budget. When a cooldown blocks an action, AdOps does not stay silent. It writes an explicit skipped result carrying the reason `next_execute_not_reached`, the time the cooldown expires, and a step recording that the evaluation was skipped. The log answers why nothing happened instead of leaving a gap. ## What is recorded when an action runs? Every one of the 11 writes to Meta goes through a single wrapper that logs the request URL, the request body and Meta's response. A failure pushes the function name, the message, the stack, the exact request body and Meta's error response into a deduplicated error log, so a recurring API fault appears once with an occurrence count rather than as thousands of identical lines. Budget and name actions additionally stamp a before value and an after value onto the campaign's result row, which is what the Value Changes block in the log detail renders as Before and After. --- ## Feature — Custom metrics Source: https://adops.id/features/custom-metrics/ Last updated: 2026-08-20 A named metric bound to a Google Sheet, resolved at evaluation time, usable in conditions, budget values and campaign names. **Key facts** - Data source: Google Sheets (The only custom metric source type offered in the builder) - Fields per metric: 4 (Spreadsheet ID, sheet name, column ID, value column) - In-memory cache window: 2 minutes (Measured from the last access, keyed by spreadsheet ID and sheet name) - Fetch order: 3 layers (CSV export first, Google Sheets API next, MongoDB mirror last) - CSV download timeout: 30 seconds (Applied to the direct CSV export request) - Parallel sheet reads: 3 per chunk (Batch fetches run three spreadsheets at a time) AdOps custom metrics let a rule compare Meta's numbers against yours. A custom metric names a Google spreadsheet ID, a sheet name, a lookup column and a value column, and AdOps resolves it at evaluation time by finding the row whose lookup column matches the campaign and reading its value column. The result behaves like any other metric. ## Why put a number in a spreadsheet at all? Because some of the numbers that should govern a campaign never appear in Ads Manager. Margin after cost of goods. Stock on hand. A target ROAS that differs by SKU because the gross margin differs by SKU. A media buyer who maintains those figures already maintains them in a sheet. The alternative is hardcoding a threshold into every rule and re-editing every rule when the number changes. A custom metric moves that number out of the rule and into the sheet, where the person who owns it can change it without touching automation. ## What does a custom metric look like? Creating one takes a name, an optional description, and four binding fields. | Field | Example | What it is | | --- | --- | --- | | Google Spreadsheet ID | the id in the sheet URL | Which spreadsheet to open | | Sheet Name | `Sheet1` | Which tab inside it | | Column ID | `Date` | The lookup column matched against the campaign | | Value Column | `Revenue` | The column whose number is returned | The builder places the hint that the spreadsheet ID is found in the spreadsheet URL, and the data source type select currently offers Google Sheets. When you save, AdOps opens the sheet and confirms that both named columns exist. If either is missing you get a red Google Sheets Validation Failed modal listing every problem and a how-to-fix checklist, rather than a rule that silently evaluates against nothing at 3 a.m. ## The worked example: a target ROAS per SKU Keep a sheet your buyer owns. One row per campaign, keyed by campaign ID in the lookup column, with the target ROAS for the SKU that campaign sells in the value column. Then write one rule for the whole account. Set a condition on `Purchase ROAS` over `Last 7 days`, switch its compare mode to `metric`, and point the compared side at the custom metric. The threshold is no longer a number you typed. It is whatever the buyer put in the sheet this morning, per campaign. Pair it with a Pause action and a name tag, and one rule now enforces per-SKU economics across an account where every SKU has a different break-even. When the merchandising team drops a price, they edit a cell, and the automation follows. The same metric can drive a budget change directly. A budget action's value type accepts `custom_metric`, so the amount written to Meta can come from a column that already holds the number your finance team agreed to. ## How does AdOps read the sheet without hammering Google? Three layers, in order. 1. **CSV export.** AdOps hits Google's direct CSV export endpoint with a 30-second timeout and parses it with a quote-aware parser. That parser tracks quoting state, handles commas inside quoted cells and escaped doubled quotes, trims header names, skips blank lines, and drops any row whose column count does not match the header. Real back-office sheets contain currency, addresses and product names with commas in them, and a naive comma split shifts every value one column left. 2. **Google Sheets API.** Permission and not-found errors are surfaced immediately rather than retried; other failures fall through to the slower API download. 3. **MongoDB mirror.** Every successful fetch is written to a `google_sheets` collection. If Google is unreachable entirely, the engine serves the last known rows from that mirror. On top of that sits an in-memory cache keyed by spreadsheet and sheet name. A hit within 2 minutes of the last access is served from memory, so hundreds of campaigns in one batch share a single spreadsheet read. Batch fetches run 3 sheets in parallel per chunk. Be aware of what that cache window actually means. The 2 minutes is measured from the last access, not from the last fetch. Under continuous access, which is exactly the large-batch case, the same snapshot can be served for longer than 2 minutes. Edit the sheet before a run, not in the middle of one, and treat the value as the number your team last agreed rather than a live feed. --- ## Feature — AI rule builder Source: https://adops.id/features/ai-rule-builder/ Last updated: 2026-08-20 A plain-language goal becomes draft rule tasks in the normal editor, tagged as AI generated and scored 0 to 100 for confidence. **Key facts** - Confidence score range: 0 to 100 (Returned with the generated tasks and shown on each task card) - Metric grammar size: 45 metrics (Injected into the system prompt from the live catalogue on every request) - Progress stages shown: 6 (From Analyzing your goals to Finalizing recommendations, capped at 95 percent until the response lands) - Request timeout: 30 seconds (HTTP timeout from the management API to the AI service) - Extended thinking budget: 10,000 tokens (Default thinking budget on the AI service, configurable by environment) - Output validation: None beyond JSON parsing (The draft is for you to review before the rule goes live) The AdOps AI rule builder turns a plain-language goal into draft rule tasks. AdOps injects its live 45-metric catalogue into the prompt so the model works from the real grammar, then appends the returned tasks to the rule you are editing with a confidence score from 0 to 100. The draft is a starting point you review, not an approved rule. ## What does the AI rule builder actually do? You open the Generate with AI modal from the rule form and describe the outcome you want. The modal carries example goals to calibrate the detail level, and a staged progress bar narrates six steps while the request runs, from Analyzing your goals through Finalizing recommendations. The modal locks while a generation is in flight so a half-written rule cannot be closed out from under you. Behind that, AdOps builds a system prompt from the metric catalogue stored in its database, sends it with your text to the AI service, and reads the tasks and confidence score off the response. ## Why is the metric catalogue in the prompt? Because a model asked to write rules for a system it cannot see will invent field names. AdOps avoids that by serialising its current catalogue on every request: each of the 45 metrics with its id, display name, category, unit, whether it supports a lookback period, its Meta API field and the exact operators it allows. The prompt states the constraint plainly, requiring the model to use only metric ids that exist in the supplied schema and only the operators listed for each metric. Because the catalogue is a database collection rather than a hardcoded list, deactivating a metric removes it from the next generation with no prompt maintenance. The AI service itself runs on a Claude model through LangChain with extended thinking enabled and a default budget of 10,000 thinking tokens, so the model reasons through the schema before emitting JSON rather than answering in one pass. Model name, token ceiling and thinking budget are all environment settings. ## What the AI rule builder does not do This is the part worth reading twice. AdOps does not validate the model's output against the metric grammar. The response has its code fences stripped and is parsed as JSON; if parsing fails the raw text is returned instead. There is no schema check confirming that a returned metric id exists, that an operator is permitted for that metric, or that a period is valid for it. A generated rule is a draft, and the reason it lands in the ordinary editor is so that you can read every condition before setting it live. The model's reasoning trace is captured by the service and stored, but it is not rendered in the interface. What you see is the tasks and the confidence score. The confidence score is the model's own estimate. It is a useful triage signal for deciding which drafts to read carefully, and it is not a prediction of campaign outcomes. ## How does a generated rule reach the editor? Generated tasks are not a separate artifact living in a preview pane. They are built into the same task list the rule form uses for hand-written tasks, with the same action picker, the same action frequency control, the same condition rows and the same value fields. Each generated task renders with an AI Generated badge and a confidence chip showing the score as a percentage, and it stays editable. Change a threshold, swap the period, delete a condition, add one of your own. When you save, it is simply a rule. The practical workflow is short: describe the goal, read every condition the draft produced, correct the thresholds against your own economics, save as draft, then set live once the estimated match count looks right. ## What gets logged? Every generation writes an AI log row before the call and updates it after, storing the request, the response body, the response time in milliseconds, the confidence score and a status. Generations made while editing an existing rule are attributed to that rule, so the log can be filtered to one rule's generation history. That log is queryable per user, newest first, 10 rows per page by default. It answers what was asked, what came back, how long it took and how confident the model claimed to be. --- ## Feature — Scheduling and dayparting Source: https://adops.id/features/scheduling-and-dayparting/ Last updated: 2026-08-20 A check interval or a weekly timetable decides when a rule runs; time conditions decide which hours and weekdays it may act on. **Key facts** - Scheduling modes: 2 (Weekly timetable or a fixed check interval in minutes) - Check interval options: 10 (15 and 30 minutes, then 1, 2, 3, 6, 12, 24, 36 and 72 hours) - Default check interval: 60 minutes (Applied when a rule carries no explicit interval) - Timetable grid: 24 hours by 7 days (Plus a Week column that toggles an hour across every day) - Time picker range: 12:00 AM to 11:00 PM (24 hourly options on time_greater_than and time_less_than) - Timetable forward scan: Up to 7 days (When no slot remains today the producer rolls forward day by day) AdOps controls timing in two layers. The schedule decides when a rule becomes due, either as a check interval between 15 minutes and 72 hours or as a weekly timetable of days and hours. Time conditions decide whether an action may fire once the rule is running, comparing the current hour and weekday against values you set. ## Which scheduling mode should a rule use? Interval mode is the default shape and answers the question how often. Ten intervals are selectable: 15 minutes, 30 minutes, then 1, 2, 3, 6, 12, 24, 36 and 72 hours. A rule that somehow carries no explicit interval falls back to 60 minutes. Timetable mode answers the question when instead. The builder shows a grid with columns Week, Su, Mo, Tu, We, Th, Fr and Sa against 24 hour rows, and you click cells to activate them. The Week column toggles that hour across all seven days at once, which turns a daily 06:00 run into one click rather than seven. When a timetable rule finishes, the producer looks for the next active slot after the current time. If none remains today it rolls forward day by day, up to 7 days ahead, so a rule whose only slot is Sunday at 22:00 simply becomes due next Sunday. Either mode can be fenced with an optional date range. The picker defaults to today through 7 days out and will not accept a start date in the past. On a saved rule, an info alert shows the exact Next Scheduled Execution timestamp, so you never have to infer when it will next fire. ## How is dayparting expressed? Not as a separate settings panel. Dayparting in AdOps is a condition like any other, which means it combines with performance conditions in the same task under the same AND or OR operator. Two metrics carry it: | Metric | Key | Behaviour | | --- | --- | --- | | Time greater than | `time_greater_than` | Passes when the current hour is later than the chosen hour | | Time less than | `time_less_than` | Passes when the current hour is earlier than the chosen hour | Each takes an hour from a 24-option picker labelled 12:00 AM through 11:00 PM, and each can carry a day-of-week multi-select running Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday. If today's weekday is not in that list, the condition fails and nothing fires. Both are point-in-time metrics resolved without a Meta Insights call, alongside daily budget, remaining budget, lifetime budget, hours since creation and custom metrics. Adding a dayparting condition costs no extra Meta request. ## What does a business-hours rule look like? Combine the two time conditions to bracket a window. A task with `Time greater than` 09:00 AM and `Time less than` 06:00 PM, both restricted to Monday through Friday, and both joined by AND to a performance condition, will only act during the working week when someone is around to notice. That pattern matters most on aggressive actions. Scaling a budget at 03:00 on a Sunday because a small hour of data looked good is how automation loses trust. Fencing the action to hours a human reviews is cheap and it is one condition. ## The night budget reset The classic pattern runs in the opposite direction: let a daytime rule scale winners, then put the budget back before the next day starts. The shape is one rule with a Set budget action, a time condition placing it late in the day, and whatever pre-filters scope it to the campaigns your scaling rule touches. Because Set budget writes an absolute figure rather than a delta, the baseline is restored exactly, no matter how many increases fired during the day. Two supporting details make it reliable. Set budget accepts an action frequency, so you can cap it at once a day and know it will not fight a scaling rule that runs every 15 minutes. And AdOps re-reads the campaign's live daily budget from Meta immediately before writing, so the change is applied against the real current value. AdOps ships Night Budget Reset as one of its 10 rule templates, in the budget category, so the shape can be imported and edited rather than assembled from scratch. ## What is worth knowing about timing accuracy? The dispatcher checks for due work every 10 seconds, which is how quickly a rule becomes eligible after its interval elapses. It is not a guarantee about completion time: a sweep processes due rules one after another, and a rule covering many ad accounts takes as long as Meta takes to answer. Treat the interval as a floor on frequency. If a rule must act inside a tight window, give it a time condition that defines the window explicitly rather than relying on the schedule alone to land there. --- ## Feature — Execution logs Source: https://adops.id/features/execution-logs/ Last updated: 2026-08-20 Batch records, per-campaign per-task results, condition-level pass and fail evidence, and before and after values for every change. **Key facts** - Execution badges: 3 (Executed, Not Executed, Skipped, plus Pass or Fail per condition) - Recorded per result: Action, parameters, level, ad account (Plus batch id, task id, campaign snapshot and next execution time) - Execution step names: 4 (execution_skipped, insights fetch, condition calculation, condition check) - Slow execution threshold: 10 seconds (Renders red in the log detail; over 5 seconds renders amber) - Batch statuses: 2 (RUNNING while the batch is in flight, DONE when it ends) - Cooldown skip reason: next_execute_not_reached (Written with the time the cooldown expires) Every AdOps rule run leaves evidence. AdOps writes one batch record per run and one result row per campaign per task, carrying an Executed, Not Executed or Skipped badge, the action's parameters, each condition's pass or fail with the value read, before and after values on changes, the execution time and the next scheduled execution. ## Why does the log matter more than the feature list? Because automation that spends money is only worth running if you can answer two questions afterwards: what did it do, and why. A rules engine without evidence asks you to trust it. A rules engine with per-condition evidence lets you check it, and checking is what makes it safe to widen the rule to more accounts. The log is also where a rule gets debugged. A threshold that never fires and a threshold that fires on every campaign look identical from the outside. In the log they look completely different, because the actual value the engine read is printed next to the expected value on every condition. ## What does a batch record hold? Rule Logs lists execution batches with four columns: Execution Time, Ad Account, Applied Items and Affected Tasks. Applied items renders as a badge, and affected tasks renders green when something happened and grey when nothing did, so a month of runs can be scanned in a few seconds. Behind each row sits a benchmark document keyed on the batch id, carrying the rule, the ad account, the start time, the number of applied items, a running execute count and a status of `RUNNING` or `DONE`. The record is written as an upsert on the batch id, so a job that the queue redelivers reuses the same row rather than leaving duplicate half-finished audit lines. Beside the table, a Rule details card shows the rule name, its list of actions, its schedule rendered either as a run interval or a per-day timetable, and who last updated it. ## What does the detail view show per campaign? Opening a batch shows every campaign it evaluated. For each campaign, one card per task. The card header carries the action icon and label, one of three badges, and the timing. **Executed** means the action ran. **Not Executed** means the conditions did not pass. **Skipped** means a cooldown blocked the evaluation before it began. The card body has two columns. **Action Details** prints the parameters the action actually used. For a name action that is the mode, the separator and the text. For a budget action that is the increase value, the maximum budget cap and the value type. For a replace action it is the find text and the replacement. Below them sit the level badge, the ad account and the executed-at time. **Condition Evaluations** prints each condition as the metric label with its reporting period, a green Pass or red Fail badge, and the sentence Actual value, operator, Expected value. Where the condition used a custom metric, AdOps resolves the stored id back into the metric's real name, so the log reads in the language you named things in rather than as a database id. When an action changed something, a Value Changes block shows Before in red and After in green. Budget and name actions record this pair; the three lifecycle actions record the status they wrote rather than a before and after. ## How do you find a run that was slow? Every result carries a total execution time, colour graded in the detail view: green under 5 seconds, amber from 5, red past 10. Administrators additionally see an Execution Steps timeline, a numbered list of the internal stages with the elapsed seconds and a pass or fail chip for each. Four step names appear: the skipped marker written when a cooldown blocked the run, the batched Meta Insights fetch, one entry per condition calculation, and the final condition check. Reading that list tells you whether a slow run was slow because Meta was slow or because the rule asked for too much. The Benchmark page collects both angles. A Queue Progress tab lists batches in flight with start date, rule name, ad account and a progress bar reading executed against total. A Slow Rule tab filters executions by a minimum execution time, defaulting to 10 seconds, over a date range, and prints per-execution timing, the initial and new values of the action, the per-step breakdown in seconds and every condition's pass or fail. ## What if you only want to see what changed? Use the Activity Log. It returns only results where an action really ran, enriched with the rule name, an event name combining the action and the level, the affected campaign as an ID and name badge, and the time of the change. A six-field filter panel narrows it by event name, ad account, rule name, entity ID, entity name and action, and the filter pill shows a dot whenever a filter is active. Clicking a row opens the same evidence in a modal: the affected campaign, the rule, the action, the ad account, the time, and each condition's pass or fail with the value read, plus a link into the full logs. --- ## Feature — ROAS dashboard Source: https://adops.id/features/roas-dashboard/ Last updated: 2026-08-20 Two ROAS cards, a monthly budget meter, a spend breakdown, a campaign leaderboard and an account comparison across four periods. **Key facts** - ROAS precision: 3 decimals (On the two ROAS cards; campaign and account rows show 2 decimals) - ROAS bands: 3 (Profitable at 1.0 and above, Moderate at 0.5 and above, Low below that) - Dashboard periods: 4 (Today, Last 7 days, Last 30 days, This month, defaulting to Last 7 days) - Cache lifetime: 1 hour (Per user and per period, expired automatically by a database TTL index) - Accounts in the spend breakdown: Top 5 (The remainder is summarised as plus N more accounts) - Budget utilisation thresholds: 80 and 100 percent (The utilisation bar turns amber then red) The AdOps dashboard answers how the account is doing before you open a single rule. It leads with Purchase ROAS and Aggregated ROAS, each shown to 3 decimals with an x suffix, a trend arrow and a Profitable, Moderate or Low badge, then breaks spend down by ad account, ranks campaigns, and compares accounts against each other. ## What are the two ROAS cards? Purchase ROAS and Aggregated ROAS sit side by side. Each card carries an icon, the period it covers, a trend arrow with a percentage, the value to 3 decimals with an `x` suffix, and a status badge. | Value | Badge | | --- | --- | | 1.0 and above | Profitable | | 0.5 and above | Moderate | | Below 0.5 | Low | | No data for the period | No data | The trend arrow has three states: up in green, down in red, and neutral. The No data state matters more than it sounds. A dashboard that renders a missing figure as 0.000 invites a rule to be written against a number that does not exist. Both cards prefer Meta's own attributed ratios. Purchase ROAS is read from Meta's `purchase_roas` field and the website variant from `website_purchase_roas`, so the number carries Meta's attribution modelling rather than a recalculation from raw values. Only when those fields are absent does AdOps fall back to summing conversion values, de-duplicating umbrella purchase totals against their sub-types so a sale is not counted twice. Aggregated ROAS spans 7 conversion action types rather than purchases alone. ## What does the Monthly Budget card do? It puts spend against a ceiling. The card shows the spend figure, a progress bar, the number of days left in the month, and how many of your ad accounts are active out of the total, with a warning triangle when spend has passed the limit. The limit comes from the monthly ad-budget band you chose during onboarding, which AdOps converts into a numeric Rupiah figure. Money is formatted the Indonesian way throughout, with Rp and the rb, jt and M suffixes for thousands, millions and billions. ## How is spend broken down? The Spend Breakdown card runs the full width below the cards. It shows Total Spend, a Budget Utilization bar that turns amber at 80 percent and red at 100, and a ranked Account and Spend list of the top 5 accounts, each with a coloured share bar and its percentage of total. Anything beyond fifth place is summarised as a plus N more accounts line rather than dropped silently. ## Which campaigns are winning? Campaign Performance shows counts of active and paused campaigns, then two tabs. Top Performing lists campaigns at a ROAS of 1 and above; Underperforming lists campaigns below 1 that are still spending, which is the set worth acting on. Each row shows the campaign name, its ad account, spend, revenue and ROAS to 2 decimals, colour coded green, amber or red. Account Comparison answers the same question one level up. It headlines the account count, highlights a Best Performer with a crown and a Needs Attention account, then prints a four-column table of Account, Spend, Revenue and ROAS with the best row badged. ## How do the periods and the cache work? Four periods sit in the header as pills: Today, Last 7 days, Last 30 days and This month. The dashboard opens on Last 7 days. Every metric is cached per user and per period for 1 hour, stored in the database with a TTL index that expires the entry automatically and a unique index per user and cache key. That is why the dashboard loads instantly on the second visit rather than re-querying Meta for every widget. Caching is only acceptable if the interface admits it, so the header carries a live or cached indicator with the last update time, and a Refresh button that re-requests every widget with a refresh flag instead of serving the cached copy. All five widgets load in parallel with independent spinners, so a slow account does not hold up the rest of the page. ## Which accounts are counted? Only the ones you turned on. Ad accounts discovered from Meta are stored inactive until you activate them, and the active flag is the single switch scoping everything downstream: the month-to-date spend refresh, both ROAS cards, the spend breakdown, the campaign leaderboard and the account comparison all read active accounts only. That makes the dashboard a deliberate view rather than an automatic one. An agency running twenty accounts and automating four sees the four. --- ## Documentation — Anatomy of a rule Source: https://adops.id/docs/anatomy-of-a-rule/ Last updated: 2026-08-20 The four cards of the rule builder and the fields each one writes — name, accounts, filters, tasks and schedule. **Key facts** - Cards in the rule builder: 4 (Basic Information, Filter Configuration, Tasks & Conditions, Schedule Configuration) - Actions per task: exactly 1 (a rule holds as many tasks as you need, each with its own conditions) - Rule levels: Campaigns or Ad sets (the level sets the Insights read level; actions are executed against campaigns) - Pre-filter fields: 3 (Campaign ID, Campaign Name and Campaign Status) - Rule statuses: DRAFT and ACTIVE (only ACTIVE rules are picked up by the execution engine) An AdOps rule is one document with five moving parts: a name and the ad accounts it covers, pre-filters that narrow which campaigns are in scope, a level, a list of tasks that each pair a condition set with one action, and a schedule. The builder writes all five from a single page under the header **Create Rule**. ## Card 1 — Basic Information Three fields. **Rule Name** carries the hint "Choose a descriptive name for your automation rule" and the placeholder "e.g., Pause underperforming campaigns". Name rules after what they do; the name is what the Rule Logs sidebar, the Activity Log and the bulk bar all show you. **Ad Accounts** is a set of removable chips plus a **+** button, hinted "Select up to 5 ad accounts you want to manage". **Notifications** carries the hint "Get alerts about triggered actions via email" and holds an Email Address, a Recipient Name (placeholder "e.g., Marketing Team") and a Channel Type of Email. ## Card 2 — Filter Configuration This card decides which campaigns the rule even looks at, before any metric is read. A level button toggles between **Campaigns** and **Ad sets**. Beside it, a **+** button adds a filter chip on one of three fields: | Field | Operators | Values | | --- | --- | --- | | Campaign ID | equal, not equal | a campaign id | | Campaign Name | contains, does not contain | free text | | Campaign Status | is, is not | ACTIVE or PAUSED | Each chip renders as ` ` and opens an inline editor when clicked. Underneath, a live readout shows **Estimated match: N Campaigns**, recalculated 500 milliseconds after any change, with a per-ad-account breakdown in its tooltip. Before you attach accounts it reads "Select ad accounts to see affected items". Use it. It is the only place in the product that tells you the blast radius before you save. ## Card 3 — Tasks & Conditions The toolbar holds **Templates**, **Add Task** and **Generate with AI**. Each task card shows the action icon, the action name with the word "campaign" swapped for your chosen level, a one-line summary such as "Increase budget for all campaigns", copy and trash buttons, an **AND/OR** pill, and a table of conditions. Every condition row is four pickers and an input: metric, period, operator, value — plus a **Compare With** cog and a remove button. The stored shape is plain JSON: ```json { "level": "campaign", "status": "ACTIVE", "tasks": [ { "action": "increase_budget_campaign", "action_frequency": "2_hours", "action_value": { "value_1": 100000, "value_2": 1000000, "value_3": "value" }, "condition": { "operator": "AND", "conditions": [ { "metric_key": "purchase_roas.omni_purchase", "period": "today", "operator": "GREATER_THAN", "value": "3", "compare": "value" }, { "metric_key": "spend", "period": "today", "operator": "GREATER_THAN", "value": "0", "compare": "value" } ] } } ] } ``` For every campaign in scope, the engine walks the tasks in order and evaluates each task's own conditions before running that task's own action. One rule can therefore encode a whole playbook — scale on good ROAS, pause on bad ROAS, tag either way — and each task is logged separately with its own `task_id`. ## Card 4 — Schedule Configuration Either **Run every ``** or **Run on spesific days and time**, optionally bounded by **Run within a date range**. On a saved rule an info alert reports the **Next Scheduled Execution**. See [Scheduling a rule](/docs/scheduling-a-rule/) for the full detail. ## Draft or live The header has two buttons: **Save as Draft** stores the rule with status `DRAFT`, and **Set Live** stores it as `ACTIVE`. Only ACTIVE rules are selected by the execution engine, so a draft is a safe place to leave work in progress. Editing an existing live rule turns the primary button into **Update Rule**. --- ## Documentation — Billing and invoices Source: https://adops.id/docs/billing-and-invoices/ Last updated: 2026-08-20 The trial, the Invoices page, how an invoice is paid, and what a suspended account can still do. **Key facts** - Free trial: 14 days (starts when the signup email is confirmed) - Invoice currency: Indonesian Rupiah - Invoice statuses stored: PAID and PENDING (OVERDUE is derived when an unpaid invoice passes its due date) - Payment link validity: 1440 minutes (24 hours from the moment the link is created) - Active period granted on payment: 1 month (the account status is set to ACTIVE) AdOps billing runs on invoices denominated in Indonesian Rupiah and paid through the Duitku payment gateway. A new account gets a 14-day trial that starts the moment the signup email is confirmed. After that, each billing cycle produces an invoice you can view, pay and download from the **Invoices** page under Billing. ## The Invoices page The table has six columns — **Invoice #**, **Invoice Date**, **Due Date**, **Amount**, **Status** and **Actions** — with filter pills for **All invoices**, **Pending**, **Paid** and **Overdue**, a search box hinted "Search by invoice number", and a Sort by menu offering Invoice Date, Due Date, Amount and Status. Two statuses are stored: **PAID**, shown with a green tick, and **PENDING**, shown with an amber clock. **OVERDUE** is derived — when an unpaid invoice passes its due date the row is highlighted, the due date turns red with an Overdue badge, and the status renders as OVERDUE. Each row's Actions cell has an eye button that opens the invoice. Unpaid rows also get a credit-card button that opens the invoice's payment link in a new tab. Selecting rows raises a bulk bar with **Send Reminders** and **Download**. With no invoices the page reads **No invoices found**. If your account is suspended, a red **Account Suspended - Payment Required** alert sits at the top of the page with the invoice number, due date and amount, and a large **Pay Now** button. ## The invoice itself Opening an invoice shows a printable block headed **Adops.id** with the invoice date, a **From** column (Adops.id, support@adops.id), a **To** column with your full name and username, and a right-hand column carrying **Invoice #``**, **Payment Due: ``** and a status badge — amber for PENDING, green otherwise. Below that, a Product / Description / Subtotal table lists the subscription plan and its monthly amount, followed by a Subtotal and Total in Rupiah. Two buttons sit at the foot: **Generate PDF**, which builds the file in your browser and saves it as `invoice-.pdf`, and — on PENDING invoices only — **Submit Payment**, which opens the payment link. ## Paying The payment link is hosted by Duitku and is valid for 1440 minutes, which is 24 hours from the moment it is created. If the link has expired, reopen the invoice to get a fresh one rather than reusing an old tab. After you pay, AdOps returns you to a payment status page that shows one of three states: a **Processing Your Payment** spinner while the result settles, a success state with your Order ID and a **Login to Dashboard** button, or a failure state whose message is tailored to the reason — timeout, cancelled, insufficient funds, expired or declined — with **Try Payment Again** and **Contact Support** buttons. A successful payment marks the invoice PAID, sets the account status to ACTIVE and grants an active period of one month. ## What suspension actually blocks A suspended account keeps all of its data. What it loses is access. The app shell shows a red **Account Suspended - Outstanding Payment Required** banner with the invoice number, the amount, how many days it is overdue, and **Pay Now** and **View Invoices** buttons. Behind that, five screens render under a **Feature Locked** overlay: Rules, Custom Metrics, Ad Accounts, Activity and Integrations. The overlay names the invoice and the amount due and offers **Pay Now to Unlock** and **View Invoice Details**. Users with the ADMIN role are exempt from the lock; ordinary users are not. ## Practical notes Amounts are formatted Indonesian-style, so a figure may read `Rp 1.5jt` in a list and in full on the invoice. Invoice numbers are the search key on the list page and the filename of the PDF, so use them when you contact support at support@adops.id. If an invoice shows as unpaid after you paid it, open it and check its status badge before paying again — the payment record is keyed on the gateway's payment reference, so re-opening the invoice is the right first step rather than starting a second payment. --- ## Documentation — Connect your Meta account Source: https://adops.id/docs/connect-meta-account/ Last updated: 2026-08-20 How the Integrations screen connects, verifies, displays and disconnects a Meta Ads account. **Key facts** - Where you connect: Integrations, section "Ad platforms" (a single Meta Ads card with a Connected or Not Connected status dot) - What AdOps verifies: the token against Graph /me (it reads id, name, email and the large profile picture) - Details shown once connected: Account ID, Connected, Last Verified - What Disconnect removes: the stored token plus every synced ad-account record - Platforms marked Coming Soon: TikTok Ads, Google Ads, Snapchat Ads Connect Meta Ads to AdOps from the **Integrations** screen. AdOps verifies the access token against the Meta Graph API `/me` endpoint before storing anything, then shows the connected Facebook profile with its Account ID, Connected date and Last Verified date. Only Meta Ads can be connected in the current release. ## Where is the connection screen? Open **Integrations** from the left sidebar. The page has one section heading, **Ad platforms**, and one card, **Meta Ads**, with a status dot reading either **Connected** or **Not Connected**. The same flow runs during onboarding. The **Connect ad platform** screen lists Meta Ads as the only enabled option; TikTok Ads, Google Ads and Snapchat Ads each carry a grey **Coming Soon** badge and cannot be pressed. A **Connect later** link skips the step. ## What happens when you press Connect? AdOps hands you off to Meta, then returns to a full-screen interstitial headed **Verifying Facebook Access Token** with the line "Please wait while we verify your Facebook credentials..." and an indeterminate progress bar. Behind that screen AdOps calls the Graph API `/me` endpoint asking for `id`, `name`, `email` and the large profile picture. A token that Meta rejects is not stored. The result appears as a full-screen overlay — a green tick or a red cross with Meta's message — for three seconds, then you land back on Integrations. ## What does the connected card show? Once the token verifies, the Meta Ads card displays your Facebook profile picture, name and email, plus three labelled rows: | Row | What it is | | --- | --- | | Account ID | The Facebook user id AdOps verified | | Connected | When the token was first stored | | Last Verified | The last time AdOps re-checked the token against Graph | ## How do I disconnect? Press **Disconnect** (the unlink icon) on the card. AdOps asks "Are you sure you want to disconnect your Facebook account?" before doing anything. Confirming is a single operation that removes every ad-account record belonging to your user and clears the stored token, the connection flag and the Facebook metadata. Rules that referenced those accounts remain in your Rule List, but there is no longer a token behind them, so nothing executes until you reconnect and re-activate the accounts. ## The admin escape hatch Users with the ADMIN role see one extra control on the disconnected card: an OR divider and a **Use Access Token** button that reveals a token input with **Verify** and **Cancel**, labelled "Admin only: Directly input access token to bypass OAuth flow". It exists so support can onboard an account when the standard flow is blocked. Regular users never see it. ## After connecting Connecting Meta is not the same as giving AdOps permission to act. Every ad account discovered from Meta is stored **inactive**, and AdOps reads and writes only the accounts you switch on. Go to [Manage ad accounts](/docs/manage-ad-accounts/) next and activate the accounts you want automated. If your account is suspended for an unpaid invoice, Integrations renders behind the Feature Lock overlay reading "Feature Locked" with the feature name **Integrations**, and connecting is blocked until the invoice is settled. Meta and Facebook are trademarks of Meta Platforms, Inc. AdOps is an independent product and is not affiliated with Meta Platforms. --- ## Documentation — Metrics reference Source: https://adops.id/docs/metrics-reference/ Last updated: 2026-08-20 All 45 metrics a rule condition can use, their category, and whether each one accepts a lookback period. **Key facts** - Metrics available in a condition: 45 - Categories: 6 (conversion 16, cost_efficiency 15, engagement 7, time_based 3, core_performance 2, custom 2) - Metrics that accept a lookback period: 39 of 45 - Metrics accepting all six operators: 43 of 45 (Time greater than takes only GREATER_THAN, Time less than only LESS_THAN) - Extra metric source: custom metrics from Google Sheets (listed on their own tab in the metric picker) AdOps offers 45 metrics inside a rule condition, grouped into 6 categories: 16 conversion, 15 cost_efficiency, 7 engagement, 3 time_based, 2 core_performance and 2 custom. Thirty-nine of the 45 accept a lookback period; the remaining six are point-in-time readings taken at the moment the rule is evaluated. ## The full catalogue | Metric | Category | Lookback period | | --- | --- | --- | | Daily Budget | core_performance | No | | Spend | core_performance | Yes | | Add of payment info value | conversion | Yes | | Adds of payment info | conversion | Yes | | Adds to cart | conversion | Yes | | Adds to cart value | conversion | Yes | | Checkout initiated | conversion | Yes | | Checkout initiated value | conversion | Yes | | Leads | conversion | Yes | | Leads value | conversion | Yes | | Purchase Value | conversion | Yes | | Purchases | conversion | Yes | | Registration completed | conversion | Yes | | Registration completed value | conversion | Yes | | Subscription | conversion | Yes | | Subscription value | conversion | Yes | | Website purchase value | conversion | Yes | | Website Purchases | conversion | Yes | | Cost per add payment info | cost_efficiency | Yes | | Cost per add to cart | cost_efficiency | Yes | | Cost per checkout initiated | cost_efficiency | Yes | | Cost per content view | cost_efficiency | Yes | | Cost per landing page view | cost_efficiency | Yes | | Cost per lead | cost_efficiency | Yes | | Cost per Purchase | cost_efficiency | Yes | | Cost per registration completed | cost_efficiency | Yes | | Cost per subscribe | cost_efficiency | Yes | | Cost per Website Purchase | cost_efficiency | Yes | | CPC | cost_efficiency | Yes | | CPC (link) | cost_efficiency | Yes | | CPM | cost_efficiency | Yes | | Purchase ROAS | cost_efficiency | Yes | | Website Purchases ROAS | cost_efficiency | Yes | | Clicks | engagement | Yes | | Content views | engagement | Yes | | CTR | engagement | Yes | | CTR (link clicks) | engagement | Yes | | Impressions | engagement | Yes | | Landing page views | engagement | Yes | | Link clicks | engagement | Yes | | Hours since creation | time_based | No | | Time greater than | time_based | No | | Time less than | time_based | No | | Lifetime budget | custom | No | | Remaining budget | custom | No | ## How to read the categories **core_performance** holds the two figures every rule eventually touches: Spend and Daily Budget. Almost every safe rule includes a Spend condition, because it is what keeps a rule off campaigns with no data. **conversion** counts events and their values — purchases, leads, add-to-cart, checkout, registration, subscription, and the payment-info step — each in both a count form and a value form. **cost_efficiency** holds the per-result costs and the two ROAS figures. If you optimise on cost per result in Ads Manager, this is the section you will live in. **engagement** holds the upper-funnel counts and rates: impressions, clicks, link clicks, CTR, CTR (link clicks), landing page views and content views. **time_based** and **custom** are the six metrics without a period. Hours since creation is the campaign's age in whole hours, rounded up. Time greater than and Time less than compare the current hour and also accept a day-of-week selection. Lifetime budget and Remaining budget are read straight off the campaign object, and AdOps only issues that extra read when a rule actually asks for one of them. ## Choosing a metric Three habits keep rules honest. Pair every ratio with a volume floor. Purchase ROAS on a campaign with two conversions is noise; `Purchase ROAS < 1.5 AND Spend > 200000` is a decision. Match the period to the decision. A pause rule reading Today will act on a slow morning. Reading Last 7 days smooths that out but reacts a day late to a genuine collapse. Prefer the metric your team already reports on. Purchases and Website Purchases are different Meta breakdowns, and the number in your rule should be the number in the conversation. ## Beyond the 45 Anywhere a metric is chosen — a condition, a compared metric, a budget value or a name shortcode — the picker also offers a **Custom metrics** tab holding metrics you define yourself from a Google Sheet. See [Custom metrics from Google Sheets](/docs/custom-metrics-google-sheets/). --- ## Documentation — Reading execution logs Source: https://adops.id/docs/reading-execution-logs/ Last updated: 2026-08-20 How Rule Logs, the log detail view and the Activity Log record what a rule did, and how to read the evidence. **Key facts** - Execution badges: Executed, Not Executed, Skipped - Rule Logs columns: 4 (Execution Time, Ad Account, Applied Items, Affected Tasks) - Evidence per condition: Pass or Fail plus the actual value (shown as "Actual Expected ") - Slow-run colouring: over 10 seconds is red (over 5 seconds is amber in the log detail) - Log cleanup: daily at 00:00 (execution results older than 3 days are removed) Every AdOps run writes two things: one batch record for the run, and one result per campaign per task. The Rule Logs page lists the batches, the batch detail shows each campaign's tasks with an Executed, Not Executed or Skipped badge, and every condition is stored with the actual value the engine read and a Pass or Fail badge. ## Opening the log for a rule From the Rule List, open a rule's three-dot menu and choose **Logs**. The page is headed **Rule Logs** with a back arrow to the rule. The table has four columns — **Execution Time**, **Ad Account**, **Applied Items** and **Affected Tasks**. Applied items render as a blue badge; affected tasks render green when the count is above zero and grey when it is zero. The whole row is a link into that batch. When there is nothing yet the page reads **No rule logs found**. On the right, a **Rule details** card repeats what the rule is: its name linking back to the editor, **Actions in rule: N** with the action list beneath, a Schedule section reading either "Runs every N minutes" or the per-day timetable from Sun to Sat, and **Updated by `` (`