Autofill

Autofill helps editors turn text-based notes, product details, briefs, or source copy into complete Craft entries. Add an Autofill field to an entry type, configure the fields it should populate, and editors can generate structured suggestions directly from the entry edit screen.

The plugin is designed around reviewable AI output. Autofill builds a structured prompt from your field configuration, asks the selected AI model for JSON suggestions, normalizes those suggestions for Craft fields, and lets editors review values before applying them.

A typical setup has three parts: a global AI model configuration, an Autofill field attached to an entry type, and generation rows that tell Autofill which fields to fill.

Autofill model configurations live in the plugin settings. These rows tell Autofill which provider, API key, model, and reasoning effort to use when generating suggestions.

You can create multiple model configurations for different editorial workflows. For example, one field can use a fast drafting model while another uses a more careful model for long-form or structured content.

Model Config Rows

Each model config row includes an internal label, provider, API key environment variable, model ID, optional reasoning effort, and enabled state.

The first enabled row is used as the default model configuration. Individual Autofill fields can either use that default or select a specific model config.

API Key Environment Variables

Store API keys as environment variables and reference them in the API Key Env column, for example $OPENAI_API_KEY. Autofill resolves the environment variable on the server before making requests.

This keeps secrets out of project config and avoids exposing keys to editors in the control panel.

Model IDs and Reasoning

The Model ID controls which OpenAI model Autofill uses. When the model list can be loaded from OpenAI, the settings page shows available models; otherwise, you can enter a model ID manually.

Reasoning effort can be left at the default or set to Low, Medium, or High for models that support reasoning controls.

Test Mode

When Test Mode is enabled, editors can generate a prompt preview and manually paste a JSON response for parsing. This is useful for checking prompts, response shape, and review behavior without spending live API calls.

When Test Mode is disabled, the Autofill button sends a live AI request and opens the suggestion review flow.

An Autofill field is the reusable profile that controls what editors can generate from an entry edit screen. It connects an entry type, an optional model configuration, shared instructions, and one or more generation rows.

Most projects will create one Autofill field per editorial workflow. For example, a product entry type might have one Autofill field that drafts product summaries, SEO text, and structured details from text-based source notes.

Editors use Autofill directly from the entry edit screen. The field gives them a focused way to turn text-based source material into structured field suggestions without leaving the entry.

The basic workflow is simple: add any needed source material, click the Autofill action, review the generated suggestions, then apply the values that should be saved to the entry.

Workflow With a Prompt Box

When the prompt box is shown, editors can add notes, instructions, source copy, product details, or other text-based context before clicking the Autofill action.

This is useful when the editor has new information that is not already stored on the entry, or when they need to steer the generated suggestions for a specific update.

Workflow Without a Prompt Box

When the prompt box is hidden, the editor experience is even simpler. Editors click the Autofill action and rely on the field configuration, global prompt, context rows, and existing entry values to guide generation.

This works well for repeatable workflows where admins want tighter control over how fields are filled and do not want editors writing their own instructions.

Reviewing Suggestions

The review modal shows generated suggestions one at a time. Each suggestion is rendered with an editor that matches the target field type as closely as possible, so editors can adjust values before applying them.

Rows marked as requiring approval appear in the review flow. This gives editors a chance to confirm the content, make small edits, or skip values that are not right for the entry.

Applying Suggestions

Suggestions are applied server-side and saved back to the entry. Because of that, the entry must already exist before generated values can be applied.

If an entry has not been saved yet, save it first, then run Autofill again. This gives Autofill an entry ID to update when suggestions are accepted.

Autofill uses field adapters to understand Craft fields, build useful prompt instructions, normalize AI responses, and apply generated values back to entries.

Supported fields appear in the target field and context field dropdowns after you choose an entry type scope for the Autofill field.

Native Entry Fields

• Title
• Slug
• Post Date
• Expiration Date
• Enabled

Supported Fields

• Plain Text
• Lightswitch
• Number
• Date
• Time
• Dropdown
• Checkboxes
• Multi-select
• Radio Buttons
• Color
• Country
• Button Group
• Icon
• JSON
• Range
• Money
• Email
• CKEditor
• SEOmatic
• Addresses (Pro edition only)
• Links (Pro edition only)
• Tables (Pro edition only)
• Categories (Pro edition only)
• Tags (Pro edition only)
• Entries (Pro edition only)

For relationship-style Pro fields, Autofill can include candidate options in the prompt so the model can suggest matching related elements. Some field types include extra settings to keep those candidate lists focused.

Autofill is available in Lite and Pro editions. The core workflow is the same in both editions: configure an AI model, create an Autofill field, add prompts, and let editors generate reviewable field suggestions.

Lite Edition

The Lite edition is intended for focused workflows and smaller setups.

• One Autofill field
• AI model configuration
• Editor-facing Autofill workflow
• Prompt box and no-prompt-box field workflows
• Support for native entry fields
• Support for common scalar, choice, date, content, SEO, and utility fields

Pro Edition

Autofill Pro is for larger editorial workflows, automation, and richer field layouts.

• Unlimited Autofill fields
• Access to the Autofill console endpoint allowing bulk calls
• Everything included in the Lite edition
• Additional supported field types: Addresses, Links, Tables, Categories, Tags, and Entries

Choosing an Edition

Use the Lite edition when you need one Autofill workflow for a single entry type or focused use case. Or if you just want to try out the plugins core functionality to see if it actually improves productivity. Use Pro when you need multiple Autofill fields, relationship-style fields, richer field support, or API access.

Autofill Pro includes a console workflow, control panel page, and extensible queue service for running an Autofill field across one or more existing entries. This is useful when you want to backfill content, refresh generated fields, or apply the same Autofill profile to a batch of entries.

Bulk Autofill uses the same field configuration, model configuration, prompts, and field adapters as the editor workflow. The important difference is that bulk runs apply normalized suggestions automatically, so it should be used carefully.

Bulk Calls from Control Panel

You can call on as many entries as you would like right from the craft control panel. Just pick the Autofill field you would like to call and the entries you would like to call it on to run an individual job for each. You can also optionally add a prompt to be passed to those runs as well as the site id for multi site support

Console Command

./craft autofill/bulk/run --field-slug=autofillProfile --entry-ids=10,11,12

You can identify the Autofill field by field handle or field ID:

• --field-slug: the Autofill field handle
• --field-id: the Autofill field ID

Options

• --entry-ids: comma-separated entry IDs to process
• --site-id: optional site ID
• --user-prompt: optional text-based input to include in the generated prompt

What Happens

For each entry, Autofill builds the prompt, sends the request to the selected model, normalizes the generated suggestions, applies each suggestion to the entry, and saves the entry.

Because bulk runs do not pause for editor review, test the Autofill field on a small number of entries first. Use Test Mode and request logs to confirm the prompts and responses look right before running a larger batch.

Queue Service Extension

If you would like to extend autofill and call on a fields functionality in a more extensible way the service can be called from other plugins. For one of the sites I manage for example, it was desirable to call an autofill field after and entry is saved and enabled for the first time. This seemed quite niche to the sites that I work on so it was not added to the core plugin functionality. However it the sites you work with have a niche requirement, accessing the fields looks like this:

// Save Autofill plugin into variable.
$autofill = Craft::$app->getPlugins()->getPlugin('autofill');

// Stop if Autofill is not installed or enabled.
if (!$autofill || !method_exists($autofill, 'getBulkAutofillService')) {
    return;
}

// Get the bulk service into a variable.
$bulkAutofillService = $autofill->getBulkAutofillService();

// Queue a job for a specific Autofill field.
try {
    $bulkAutofillService->queueForEntry(
        $fieldId, // The field ID of the specific Autofill field.
        null, // Optional field handle/slug. Use null when passing a field ID.
        (int)$entry->id, // An entry ID with that field.
        (int)$entry->siteId, // Site ID.
        '', // Optional user prompt.
        'my-plugin' // Source label for logs/debugging.
    );
} catch (\Throwable $exception) {
    Craft::warning(sprintf(
        'Could not queue Autofill field %d for entry %d: %s',
        $fieldId,
        (int)$entry->id,
        $exception->getMessage()
    ), __METHOD__);
}

Test Mode is a debugging tool for admins and implementers. It helps you see what Autofill is sending to AI and how Autofill handles the response before you rely on the live editor workflow.

Use Test Mode when a field is not generating the kind of suggestions you expect, when you are tuning prompts, or when you want to understand how context fields and current entry values are included.

Prompt Preview

In Test Mode, clicking Generate builds the prompt preview instead of sending a live AI request. The preview shows the global prompt, editor input, context fields, generation rows, field contracts, and expected response format.

This is useful when you want to confirm that the model is receiving the right instructions and enough context to fill the configured fields.

Prompt Writing Tips

Autofill works best when the field prompts are specific. The model needs clear instructions about what each field is for, what style to use, and what kind of value should be returned.

• Use the Global Prompt for shared rules like brand voice, audience, formatting, compliance guidance, or SEO direction.
• Keep generation row prompts focused on one field at a time.
• Tell the model what good output looks like: length, tone, format, allowed values, or examples.
• Use context rows for source-of-truth fields that should guide the generated values.
• Use Test Mode when a prompt is unclear, too broad, or producing inconsistent results.

If a generated result is not useful, the prompt preview is usually the best first place to look. It shows whether Autofill is giving the model enough context and whether the row instructions are clear enough for the field being filled.

Testing a Response

Test Mode includes a response input where you can paste JSON and click Parse + Start Review. This lets you test whether Autofill can match fields, normalize values, and open the review flow with the response shape you expect.

The response should be valid JSON, either as a suggestions array or as an object with a suggestions or result array. Each suggestion should include a fieldName and value.

When to Use Test Mode

• Checking what prompt Autofill sends to AI
• Tuning global prompts or row prompts
• Confirming context fields are included correctly
• Debugging unexpected or invalid AI responses
• Testing field matching and review behavior without making live generation part of the editor workflow

Test Mode is not meant to be the everyday editor experience. Once setup is working, disable Test Mode so editors see the normal Autofill workflow.

Autofill records AI request details so admins and developers can understand what happened during a generation run. Request logs are useful when you need to compare prompts, inspect responses, understand failures, or review token usage and latency.

What Gets Logged

• Autofill field ID
• Entry ID and site ID, when available
• User ID, when the request comes from a logged-in editor
• Provider and model configuration
• Model ID and reasoning effort
• Generated request prompt
• Request and response payload details
• Raw response text
• Success or failure state
• Error message, when available
• Latency and token usage
• Provider response ID

When to Check Logs

Check request logs when a generation fails, when the model returns unexpected values, when you need to tune prompts, or before running a larger Bulk Autofill job.

Logs are especially helpful alongside Test Mode: Test Mode shows what would be sent, while request logs show what was actually sent and returned during real generation.

Where to Check Logs

Logs are available in the craft admin page under 'Logs'