Configuration Summary
{{ metrics.documentCount }} {{ metrics.documentCount === 1 ? 'document' : 'documents' }} {{ metrics.totalKeys.toLocaleString() }} keys {{ metrics.totalScalars.toLocaleString() }} scalars Depth {{ metrics.maxDepth }} Preview trimmed
{{ type }}
{{ warn }}
HCL content
Use 0 to disable wrapping.
Field Value Copy
{{ row.label }} {{ row.value }} 
{{ normalizedHcl }}
{{ normalizedYaml }}
{{ iniText }}
{{ envText }}
{{ propertiesText }}
Document Path Type Preview Copy
Doc {{ row.docIndex }} {{ row.path || '(root)' }} {{ formatTypeLabel(row.type) }} {{ row.preview }}
Path Types Docs Example
{{ row.path }} {{ row.types }} {{ row.docs }} {{ row.example }}
Tags: Data Format , Devops , Devtools
Export to PDF Fullscreen
:

HashiCorp configuration language files describe infrastructure resources in plain text using blocks and attributes. They allow teams to capture cloud setups as code that can be shared and versioned. Over time these files grow in size and nesting so it becomes difficult to see what is actually configured.

Configuration conversion here turns that text into structured summaries that are easier to scan and compare. You add your configuration once and the same content appears as metrics, tables, and alternative text representations. This makes it simpler to review keys, values, and depth across different environments or modules.

During a quick change review you might paste a storage module and immediately see which buckets exist, how many tags are present, and how deep the nesting goes. You can then move between summaries to confirm that required fields are present everywhere and that naming patterns stay consistent. Remember that these views describe the configuration only and do not replace provider validation or security checks.

Configuration snapshots are most useful when you use the same settings every time and run them against committed versions rather than temporary experiments. For extra privacy avoid pasting secrets and prefer redacted or test values in any exported reports.

Technical Details

HashiCorp Configuration Language (HCL) input is parsed into one or more documents, each represented as a tree of objects, arrays, and scalar values. The parser recognises blocks and attributes and turns them into nested keys and values without evaluating expressions or contacting any external services.

Each document is scanned to count total nested keys, scalar values, and maximum depth, and to gather a small sample of example values. The summary badges and overview table reflect these counts so you can estimate how complex each piece of configuration is before digging into individual paths.

From the parsed tree the converter produces several consistent representations, including configurable YAML, JSON with adjustable spacing, INI sections, dot style properties lines, and environment variable assignments. A flattened path table lists every discovered location with its document index, data type, and a truncated preview of the stored value.

The schema view aggregates all paths across documents, tracks which data types appear at each path, counts the number of documents that use it, and keeps a representative example. This makes it easy to spot optional fields, type drift between environments, and structural differences after refactors.

Core processing follows a simple sequence:

  1. Normalise newline sequences in the pasted or loaded HCL text.
  2. Call an HCL parser implementation to obtain a JavaScript object or array representation.
  3. Walk each document recursively to collect counts, sample scalar values, and depth statistics.
  4. Compute document summaries and global metrics from these traversal results.
  5. Use a YAML formatter to emit each document with the selected indent, wrapping, and key ordering options.
  6. Serialise documents to JSON with optional spacing, handling BigInt values and circular references safely.
  7. Flatten every node into path rows, then build environment, properties, INI, overview, paths, and schema outputs.
Parameter Meaning Unit/Datatype Typical range Sensitivity Notes
documentCount Number of parsed documents detected in the input. Integer 1–many Higher values mean more work per recompute. Shown as the leading badge in the summary header.
totalKeys Total nested keys across all documents. Integer 0–100 000+ Scales traversal cost almost linearly. Displayed as a secondary badge and used in overview rows.
totalScalars Total scalar values, including strings, numbers, booleans, and nulls. Integer 0–100 000+ Indicates how many concrete values are present. Used to compute density and sample value previews.
maxDepth Maximum nesting depth found in any document. Integer 1–50 Deep structures can be harder to reason about. Reported as a badge and in per document overview rows.
path Flattened location of a value within a document. String Short for top levels, longer for deep nests. Changes when you switch path style settings. Emitted in paths, schema, env, properties, and INI exports.
env_prefix Prefix applied to generated environment variable names. String Empty or a few characters. Controls grouping of environment variables per service. Normalised to include a trailing underscore when non empty.
max_preview_paths Number of flattened paths shown in the paths preview table. Integer 50–2000 Higher values increase UI work but not export coverage. Exports still include every discovered path even when preview is trimmed.

Units and precision are straightforward. Numbers are stored using JavaScript numeric types or strings, BigInt values are kept as safe integers when possible or converted to strings, and no extra rounding logic is added beyond the parser and serialiser behaviour. Summary counts use locale aware formatting for display, while the underlying values remain plain integers.

Previews aim to be informative but compact. Scalar values are truncated after roughly one hundred twenty characters, binary buffers are converted to base64 text and shortened, and complex objects that cannot be shown inline are serialised to minimal JSON snippets. Environment, INI, and properties outputs reuse the full underlying values, not the truncated previews.

Field Type Min Max Step/Pattern Error text
HCL content Textarea n/a n/a Any HCL text, including multiple documents. Shows “HCL parse error …” or “No HCL blocks detected.” on failure.
JSON spacing Select 0 8 Zero means minified, positive values pretty print. No explicit error, values are silently clamped.
YAML indent Number 1 8 Controls indentation width in spaces. Invalid entries fall back to a default of two spaces.
Line width Number 0 240 Zero disables wrapping, other values set wrap column. Out of range values snap back inside the allowed bounds.
Sort keys Toggle n/a n/a Alphabetises object keys in YAML when enabled. No error, affects ordering only.
Force quotes Toggle n/a n/a Quotes every scalar in YAML using the selected style. No validation beyond the YAML formatter itself.
Path style Select n/a n/a Choose dot notation with indexes or slash separated segments. Changes output paths, not the underlying data.
Max preview paths Number 50 2000 Limits how many flattened paths appear in the table preview. Higher values may slow scrolling but export all paths regardless.
ENV prefix Text 0 n/a Optional prefix added in front of environment variable keys. Trimmed and normalised, empty value means no prefix.
Uppercase env Toggle n/a n/a When enabled, converts generated environment keys to uppercase. Does not change the underlying values.

Input and output formats stay consistent across views. The main input accepts pasted HCL text or dropped configuration files, and the resulting documents are exposed as YAML, JSON, INI, environment assignments, Java style properties, overview tables, flattened path tables, and schema tables. Copy actions place plain text on the clipboard, while downloads save text or comma separated files using your browser.

Assumptions and limitations to keep in mind:

  • The HCL parser must support the dialect you use Heads-up otherwise you may see parse errors or missing fields.
  • Expressions and interpolations are not evaluated Heads-up so they appear as plain scalar values in outputs.
  • Flattened paths keep the key order produced by the parser and are not additionally sorted.
  • Metrics and summaries describe structure only and cannot guarantee runtime behaviour, permissions, or service availability.
  • Preview tables show only up to the configured path limit Heads-up although exports still include every discovered path.
  • Environment, properties, and INI outputs can produce long keys for deeply nested structures and verbose module layouts.
  • Multiple documents from the same input are handled independently but still share the global summary metrics and type badges.
  • Downloads rely on browser features; strict content policies or extensions may block file saving or clipboard access.
  • Very large configurations with many thousands of keys increase traversal time and can make path tables slower to scroll.

Common edge cases and error sources:

  • Misbalanced braces or missing quotation marks causing an HCL parse error with a message shown at the top of the card.
  • Input that is actually JSON or YAML rather than HCL producing a “No HCL blocks detected.” warning after parsing.
  • Failure to load the HCL parser scripts leading to the “HCL parser unavailable. Please reload.” message.
  • Dropping a binary or unsupported file type that cannot be read, resulting in “Unable to read the dropped file.”.
  • YAML formatting failures when the formatter cannot serialise unusual values, producing a “Failed to format YAML …” alert.
  • Extremely long scalar values being truncated in previews after about one hundred twenty characters.
  • Binary data detected as Uint8Array being converted to base64 text and shortened before display.
  • Circular references in the parsed structure being replaced with the literal “[Circular]” marker in JSON output.
  • Unusual characters in keys leading to quoted or escaped paths that differ noticeably from the original HCL text.
  • Environment keys colliding when different paths normalise to the same uppercased name, especially with a short prefix.
  • Switching between dot and slash path styles across runs, which makes comparing exported tables more difficult.
  • Very large numbers that exceed the safe integer range being converted to strings instead of precise numeric JSON values.

HCL content is parsed and transformed entirely in the browser; no data is transmitted or stored server side. Avoid including secrets, personal data, or production credentials in shared exports to stay aligned with common privacy and security guidance.

Step-by-Step Guide

HashiCorp configuration language conversion and inspection follows a short flow from raw text to structured views that are easy to compare.

  1. Paste or drop your configuration into the main input under HCL content.
  2. Open the advanced options and choose your preferred JSON spacing and YAML indent.
  3. Adjust the Path style and Max preview paths if you want different flattened views.
  4. Set an ENV prefix or toggle uppercase keys to shape generated environment variable names.
  5. Wait for parsing to complete; if an error banner appears treat it as a syntax hint and correct the input.
  6. Explore the tabs for overview, formats, paths, and schema, copying or downloading the outputs you need.

For example you might paste a shared storage module and then send a colleague straight to the paths and schema tabs so they can see every bucket, tag, and region field without reading the full configuration file.

After a few runs the sequence becomes a quick checklist for each change review, helping you move from raw text to repeatable checks in a consistent way.

Keep the same path style and JSON spacing settings across a project so exported tables remain comparable.
Use a distinct ENV prefix per service or application area to separate environment variables in shared deployment shells.
Lower the maximum preview paths when exploring huge configurations so the interface stays responsive while you scroll.
Pro tip: capture a small set of representative modules and rerun them after every major refactor to spot structural changes quickly.

Features

Parses HashiCorp Configuration Language into structured documents with per document metrics and sample values.
Exports equivalent configuration as YAML, JSON, INI, environment assignments, and Java style properties without changing the underlying structure.
Builds a flattened path preview with document index, data type, and value snippets for every discovered location.
Generates a schema summary that lists all paths, the types seen there, document coverage, and an example value.
Offers configurable YAML indentation, line wrapping, key sorting, and quoting options to match your preferred style.
Provides one click copy and download actions for each view, including CSV exports for overview, paths, and schema tables.

FAQ

Is my configuration data stored?

Parsing and conversion happen entirely in your browser using client side code. The tool does not send configuration content to a server or keep a history of your past runs.

Avoid pasting secrets or personal data into any view that you intend to share or export.
How accurate is the HCL conversion?

The converter relies on an HCL parser implementation to understand blocks and attributes. It preserves scalar values as they are parsed and does not evaluate expressions or provider specific functions, so configuration shape is reliable even when runtime behaviour is not.

If the parser does not support a feature it will surface as an error or missing field.
What formats can I export to?

You can export the parsed configuration as YAML, JSON, INI, environment variable assignments, and Java style properties, plus CSV tables for overview, flattened paths, and schema summaries. All exports are derived from the same parsed documents so they remain consistent.

CSV exports use simple comma separated rows, so values containing commas may need manual cleanup in spreadsheets.
Why do I see an HCL parse error?

A parse error usually means the input contains syntax issues such as missing braces, quotes, or unexpected characters. It can also appear when non HCL content is pasted into the box. Correct the structure, or load the sample configuration and compare it to your own file.

The exact parser message is shown in the alert to help you narrow down the problem.
Does it work without a network connection?

Once the page and its scripts have loaded, parsing and conversion run locally in your browser and do not need additional requests. If required parser or formatter scripts fail to load or are blocked, you will see an error such as “HCL parser unavailable. Please reload.” and will need to refresh when connectivity is restored.

Keeping a cached copy of the page improves resilience, but script hosting is controlled by the surrounding site.
Is there any cost or licence requirement?

The component itself does not enforce sign ups, payments, or quotas. Any pricing, licence terms, or usage limits come from the platform or product where this converter is embedded, so consult that documentation for definitive guidance.

Always review the terms of the service that is hosting the tool.
How do I inspect an HCL schema?

Paste your configuration, wait for parsing, then open the schema tab. Each row shows a flattened path, the data types seen there, how many documents include it, and an example value. This gives you a quick structural inventory across modules or environments.

Use CSV export from the schema view if you want to review or annotate paths in a spreadsheet.
What does a borderline path mean?

A borderline path is one that appears in some documents but not others or carries different data types across environments. Treat those paths as optional or unstable and review them manually before relying on them in automation or templating logic.

Schema counts help you see how widely each path is used so you can prioritise clean up.

Troubleshooting

  • No output appears after you paste content: check that the input is not empty and that it contains at least one valid HCL block.
  • An HCL parse error message appears: look for missing braces, commas, or quotation marks, or compare your file to the sample configuration.
  • You see “HCL parser unavailable”: required scripts may have failed to load or been blocked by network or content security settings.
  • The YAML tab stays empty while others work: the YAML formatter may have encountered an error; reload the page to reinitialise it.
  • Copied values look wrong in a spreadsheet: CSV exports do not escape commas, so cells containing commas may need manual fixes.
  • Environment variables do not match expectations: review the path style, ENV prefix, and uppercase toggle before regenerating outputs.
  • Path tables feel sluggish when scrolling: lower the maximum preview paths value or filter your configuration before pasting it.
  • Downloads do not start: browser pop up blockers, download settings, or strict policies can prevent saving files from the page.

Advanced Tips

  • Keep a consistent path style across projects so exported tables line up cleanly in reviews and spreadsheets.
  • Use separate ENV prefixes for staging, testing, and production so generated environment variables never collide across deployments.
  • Treat the overview metrics as a quick heuristic for spotting unusually deep or dense modules that may warrant extra scrutiny.
  • Keep preview limits moderate for huge configurations, and rely on CSV exports when you need complete path coverage.
  • Use properties exports when integrating with frameworks that expect dot notation configuration files rather than environment variables.
  • Combine schema coverage with document counts to prioritise which modules to standardise first during refactors or migrations.

Glossary

HashiCorp Configuration Language (HCL)
A text based configuration language used to describe infrastructure resources and their relationships.
Document
One parsed HCL structure treated as a standalone configuration unit in summaries and outputs.
Block
A named configuration section containing attributes and nested blocks, such as a resource definition.
Attribute
A key and value pair attached to a block, often representing a single configuration property.
Scalar value
A simple value such as a string, number, boolean, or null rather than an object or array.
Path
A flattened representation of where a value sits inside a document, built from keys and indexes.
ENV prefix
Optional text placed before generated environment variable names to group related values.
Preview limit
The maximum number of flattened paths shown in the paths table before further rows are trimmed.