Convert JSON to Go Struct Online Tool – Step‑by‑Step How‑To Guide

Let me be honest: wrestling with JSON that you need to turn into Go structs can feel like trying to translate a foreign language without a dictionary.

And you’ve probably spent minutes—maybe even hours—copy‑pasting snippets, guessing field types, and then watching the compiler throw a hundred errors.

Sound familiar? If you’re nodding, you’re not alone. Many devs hit this snag when juggling APIs, config files, or third‑party services that hand back JSON payloads.

The good news? There’s a simple, free way to let the machine do the heavy lifting—just drop your JSON into a convert json to go struct online tool and watch clean, ready‑to‑use Go code appear in seconds.

Why does this matter? Because every minute you spend manually mapping fields is a minute you aren’t building features that actually move your product forward.

Plus, an online converter eliminates the guesswork around Go’s strict typing. It’ll infer ints, strings, slices, even nested structs, so you get a type‑safe skeleton that compiles right out of the box.

Imagine you’re integrating a payment gateway that returns a massive JSON receipt. Instead of scrolling through endless key‑value pairs, you paste the payload, click “Convert,” and instantly receive a Go struct you can drop into your codebase.

So, if you’ve ever felt stuck in that loop of copy‑paste‑debug‑repeat, stick with me. In the next sections we’ll walk through how to use the tool step by step, troubleshoot common hiccups, and even tweak the generated structs for optimal performance.

The best part? It’s completely web‑based, so there’s nothing to install, no license to manage, and it works on any OS—whether you’re on Windows, macOS, or a Linux server. Just open your browser, paste the JSON, and let the service handle the rest.

Ready to turn that intimidating JSON blob into clean, idiomatic Go code with zero friction? Let’s dive in and see the tool in action.

TL;DR

If you’ve ever wasted hours hand‑crafting Go structs from messy JSON, the free convert json to go struct online tool lets you paste a payload and instantly get clean, type‑safe code.

That speed means you can focus on building features instead of debugging, and because it runs in any browser, there’s no install or license hassle—just copy, convert, and keep coding.

Step 1: Choose a Reliable Online Converter

Okay, you’ve already felt the pain of staring at a massive JSON receipt and wondering if there’s a shortcut. The first thing you need to do is pick a tool that won’t waste your time or dump garbage code on you. In other words, find a reliable online converter that understands Go’s strict typing and gives you clean, ready‑to‑paste structs.

So, how do you know a converter is trustworthy? Look for three signs: it’s web‑based (no messy installers), it handles nested objects gracefully, and it respects Go conventions like camel‑case field names and proper `omitempty` tags. If the site feels slick but vague about how it parses JSON, that’s a red flag.

Here’s a quick checklist you can copy‑paste into a note:

• Free, no registration required – you shouldn’t have to sign up just to paste a snippet.
• Shows a live preview of the generated struct as you type.
• Offers options to tweak field naming (snake_case vs. CamelCase).
• Provides a download button or copy‑to‑clipboard shortcut.

Does any tool you’ve used tick all those boxes? If not, you’re probably still missing out on a smoother workflow.

One service that checks every item on that list is SwapCode’s Free AI Code Converter. It’s built for developers who need instant, accurate conversions across more than a hundred languages, and the Go output is no exception. You just drop your JSON, hit Convert, and the page instantly renders a struct that compiles without tweaks.

Now, let’s walk through the actual selection process, step by step.

1. Test the UI with a tiny payload

Before you trust the tool with a massive payment‑gateway response, paste a tiny JSON sample like {"id":123,"name":"Alice"}. If the converter instantly returns:

type AutoGenerated struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

you’ve got a good sign. A laggy interface or a “Processing…” spinner that never finishes usually means the backend is under‑engineered.

2. Verify handling of arrays and nested objects

Take a more complex example: a list of orders, each with a line‑item array. Paste it in and make sure the tool nests structs correctly, like []Order containing []LineItem. If you see flat, duplicated fields, walk away – that tool won’t preserve the hierarchy you need.

3. Check for Go‑specific niceties

Good converters automatically add the json:"field_name" tag, respect pointer semantics for optional fields, and include omitempty where appropriate. Scan the output for those tags; they save you from manual clean‑up later.

4. Look for exportable code

Remember, Go only serializes exported (capitalized) fields. If the tool leaves everything lowercase, you’ll spend an extra half hour fixing it. The right converter capitalizes field names out of the box.

5. Try the copy‑to‑clipboard button

When you’re in a hurry, a single click that copies the entire struct to your clipboard is pure gold. If the site forces you to manually select the text, that’s a minor annoyance but still workable. Anything that adds friction, however, is a sign the tool wasn’t built with busy devs in mind.

6. Read community feedback

Even the best‑designed tools get real‑world polish from user comments. A quick glance at the tool’s reviews or a developer forum thread can reveal hidden bugs – like mishandling of large integers or dropping fields with null values.

Once you’ve run through these six mini‑tests, you should have a clear picture of whether the online converter is reliable enough for production‑grade code. If it passes, you’ve just saved yourself hours of manual struct‑crafting.

And that’s it – the first step is simply choosing the right tool. It feels small, but it’s the foundation for everything that follows. With a trustworthy converter in hand, the rest of the workflow – tweaking, integrating, debugging – becomes a breeze.

Step 2: Paste Your JSON and Set Options

Now that you’ve picked a trustworthy converter, the next move is the moment of truth: dropping your raw JSON into the textarea and tweaking the few options that keep the output clean.

The interface is deliberately minimal. You see a big box labeled “JSON input”, a couple of toggle switches, and a “Convert” button. Paste the entire payload—whether it’s a three‑line config or a massive webhook response—exactly as you received it. No need to strip whitespace; the tool will handle it. If your JSON is a bit hard to read, run it through the Code Formatter & Beautifier first so the converter gets a clean, indented payload.

Why do the options matter? Most converters let you decide how to treat ambiguous types. For example, a numeric field that sometimes arrives as a string (think IDs that are quoted in some APIs) can be forced into a Go string type. Likewise, you can ask the generator to add omitempty tags automatically, which saves you from manually editing the struct later.

Here’s a concrete example. Imagine you receive a payment receipt from a gateway that looks like this:

{
  "id": "rcpt_1",
  "amount": "1500",
  "currency": "USD",
  "customer": {
    "id": "cust_99",
    "email": "[email protected]"
  },
  "line_items": [
    {"description": "Product A", "price": 500},
    {"description": "Product B", "price": 1000}
  ]
}

If you leave the default settings, the tool might infer the amount field as float64. But your business logic expects an integer number of cents. Flip the “Force numbers to int” toggle, hit Convert, and the output will read:

type Receipt struct {
    ID        string    `json:"id"`
    Amount    int       `json:"amount,omitempty"`
    Currency  string    `json:"currency"`
    Customer  Customer  `json:"customer"`
    LineItems []LineItem `json:"line_items"`
}

type Customer struct {
    ID    string `json:"id"`
    Email string `json:"email"`
}

type LineItem struct {
    Description string `json:"description"`
    Price       int    `json:"price"`
}

Notice the added json:"amount,omitempty" tag—this is the optional‑field shortcut we mentioned earlier. With the tag in place, any zero value will be omitted from the marshaled JSON, keeping responses lean.

Real‑world tip: when working with nested objects, enable the “Generate nested structs” option. Without it you’d get a flat map of interface{} which defeats the type‑safety Go is known for. Enabling the option yields separate Customer and LineItem structs, exactly like the manual example we showed in Step 1.

If your JSON contains fields you never want to expose—say internal IDs or debug flags—use the “Exclude fields by name” box. Type the field names separated by commas and the converter will add the json:"-" tag for you. This mirrors the practice discussed on Stack Overflow, where developers use json:"-" to hide fields from the encoder (see discussion).

After you click Convert, the tool presents the Go code in a second pane. Before you copy it, run a quick sanity check: the preview usually includes a button to “Copy with import”. Click it, then paste into a tiny test file like main.go that unmarshals the original JSON into the new struct. If the program compiles without errors, you’ve nailed the conversion.

A common pitfall is forgetting to set the “Use pointers for optional fields” option. When a field may be omitted in some responses, using a pointer (e.g., *string) together with omitempty lets you differentiate between “zero value” and “not present”. This is exactly the approach recommended by Go’s own JSON package documentation (see answer).

Actionable checklist for this step:

• Paste the full JSON payload, keep original formatting.
• Choose “Force numbers to int” if you need integer cents.
• Turn on “Generate nested structs” for any objects or arrays.
• Add fields to “Exclude fields” to automatically get json:"-".
• Enable “Use pointers for optional fields” when you need nil distinction.
• Click “Convert”, copy the code, run a compile test.

Once the struct passes compilation, save it in a dedicated models package. Running gofmt or the built‑in formatter keeps the code tidy, and you’re ready for the next phase: customizing tags or adding validation logic.

And that’s it—you’ve turned a raw JSON blob into ready‑to‑use Go types, all with a few clicks and a handful of sensible options.

Step 3: Generate the Go Struct and Review Code

Alright, you’ve just hit “Convert” and the tool spits out a Go struct. That moment feels like magic, but the real work starts when you actually compile the code.

First thing’s first: copy the generated snippet with the handy “Copy with import” button and paste it into a tiny test file – say, main.go.

In that file you’ll import the standard encoding/json package, declare a variable of the new type, and call json.Unmarshal on the original payload. If the compiler smiles, you’re golden.

But what if you see errors about mismatched types or missing fields? That usually means the converter guessed a wrong Go type – perhaps it treated a numeric ID as float64 when you need an int or a string.

Here’s a quick checklist to run through before you even hit go run :

• Paste the full JSON payload, keep original formatting.
• Choose “Force numbers to int” if you need integer cents.
• Turn on “Generate nested structs” for any objects or arrays.
• Add fields to “Exclude fields” to automatically get json:”-“.
• Enable “Use pointers for optional fields” when you need nil distinction.
• Run go vet or go build to catch compile‑time issues.
• Use gofmt or your editor’s formatter to keep the file tidy.

Once the struct passes compilation, move it into a dedicated models package. Keeping your types isolated makes the rest of the codebase cleaner and avoids import cycles.

Now comes the review part. Open the generated file and skim each field tag. You’ll often see json:”field_name” without omitempty. If a field is truly optional, add omitempty or switch the type to a pointer – *string or *int – so you can tell the difference between “zero value” and “not present”. This trick is championed by the Go community and saves you a lot of hidden bugs as discussed on the Go forum.

Another handy habit is to run a simple round‑trip test: marshal the struct back to JSON and compare it with the original payload. If they match (ignoring field order), you’ve got a faithful representation.

If you spot fields that never get used in your app – debug flags, internal timestamps – consider stripping them out or tagging them with json:”-“. That keeps the JSON you send to other services lightweight.

For those stubborn edge‑cases where the online tool can’t infer the right type, you can manually tweak the struct after copying it. Adding a time.Time field for ISO timestamps or a []byte for raw blobs is straightforward once you understand the basics.

And when you’re done, give the code one more pass with our Free AI Code Debugger to catch any lingering issues like unused imports or mismatched struct tags. It’s a quick safety net before you commit the file.

If your API uses snake_case keys but you prefer camelCase fields, simply edit the struct tags to map each field – e.g., AmountCents `json:”amount_cents”`. You can also add validation tags from packages like go-playground/validator to enforce required fields right after unmarshaling.

Finally, commit the models package to your repo, run go test if you have tests that unmarshal real responses, and you’re ready to move on to adding validation tags or custom unmarshaling logic.

Step 4: Validate and Refine the Generated Struct

Okay, you’ve got a Go struct that looks like it came straight out of the Free AI Code Generator. The next question is: does it actually work with the real JSON your service sends?

First thing you’ll want to do is a quick round‑trip test. Take the original payload, unmarshal it into the new type, then marshal it back to JSON. If the two strings match (ignoring whitespace and field order), you’ve got a solid baseline.

Automate the sanity check

Write a tiny Go program – think 20 lines – that does exactly that. Here’s a skeleton:

package main
import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "log"
)

func main() {
    data, _ := ioutil.ReadFile("sample.json")
    var rec Receipt // replace with your struct name
    if err := json.Unmarshal(data, &rec); err != nil { log.Fatal(err) }
    out, _ := json.Marshal(rec)
    fmt.Printf("Match? %v\n", string(data) == string(out))
}

Run it with go run. If you see true, you’re golden. If not, note which fields diverge – that’s your clue where the generator guessed wrong.

Spot the sneaky mismatches

Common culprits:

• Numbers that sometimes appear as strings (IDs that are quoted in some responses). The tool might have typed them as float64. Switch to string or use *int with a custom UnmarshalJSON if you need both.
• Timestamp strings that should be time.Time. The round‑trip will give you a raw string back, so replace the field type and add a time.RFC3339 layout parser.
• Optional nested objects that are sometimes omitted. If the struct has a plain struct field, the unmarshaler will create an empty struct instead of nil. Changing the type to a pointer (e.g., *Customer) lets you differentiate “missing” from “empty”.

Those tweaks are easy once you know what to look for.

Leverage validation tags

After the struct compiles, sprinkle in validation tags from go-playground/validator (or any validator you prefer). For instance, add validate:"required,email" on an Email field. When you unmarshal, run validator.New().Struct(rec) to catch missing or malformed data before your business logic touches it.

Why bother? A lot of bugs creep in when a field silently defaults to zero – like Amount: 0 when the API actually omitted the amount. Validation makes those cases scream early.

Real‑world example: payment receipt

Imagine a webhook from a payment processor that sometimes omits the discount_code field. Your initial struct might look like:

type Receipt struct {
    ID          string `json:"id"`
    AmountCents int    `json:"amount_cents"`
    DiscountCode string `json:"discount_code"`
}

After the round‑trip, you notice the JSON sometimes has no discount_code key. The field ends up as an empty string, which your downstream logic treats as a valid code. Change it to a pointer:

DiscountCode *string `json:"discount_code,omitempty"`

Now you can check if r.DiscountCode != nil and avoid false positives.

Run a static analysis sweep

Before you commit, run go vet and golint (or your IDE’s built‑in linter). Look for:

• Unused imports – the converter sometimes adds fmt even if you never use it.
• Struct tags that don’t match the JSON key (typos like json:"amout").
• Fields with the - tag that you actually need later.

If you spot any, clean them up now. A tidy file saves weeks of “why isn’t my API call working?” later.

Document the decisions

Open a short comment block at the top of the file. Explain why you chose pointers for certain fields, why you added omitempty, and any custom UnmarshalJSON implementations. Future teammates will thank you when they see a line like:

// DiscountCode is a pointer because the webhook may omit the field entirely.

That little note cuts the guessing game in half.

External perspective

Developers often start with a schema generator, then iterate. A Stack Overflow discussion on JSON schema generators highlights the same loop: generate, test, refine. The pattern holds for Go structs too – generate fast, then validate rigorously.

Finally, push the models package to your repo, add a unit test that runs the round‑trip on a representative sample, and you’re ready for the next step: adding business‑level validation or custom unmarshaling logic.

Take a breath – you’ve turned a raw JSON blob into a reliable, test‑covered Go model. That’s the kind of low‑friction workflow that lets you focus on building features instead of chasing type errors.

Step 5: Compare Top Online Converters

Now that you’ve got a struct that compiles, the real decision is which converter you’ll keep in your toolbox. There are a handful of free services that promise “convert json to go struct online tool,” but they differ in accuracy, privacy, and extra niceties.

First, ask yourself what matters most. Do you need rock‑solid type inference for a payment webhook? Or are you just cleaning up a one‑off config file? Your answer will guide the checklist we’re about to walk through.

What to look for in a good converter

Accurate type inference. A solid tool will read numbers and emit int or float64 correctly, strings stay strings, and booleans become bool. Mis‑labeling a numeric ID as a string adds friction later when you start writing business logic.

Nested struct generation. JSON rarely stays flat. The best converters turn each nested object into its own Go struct and wire the parent fields accordingly. That keeps your codebase tidy and mirrors the real data hierarchy.

Privacy guarantees. You’re often pasting sensitive payloads—think API keys or PII. Look for HTTPS‑only sites that promise no server‑side storage. Anything that logs your data is a red flag.

Customizable options. Toggles like “force numbers to int,” “add omitempty tags,” or “use pointers for optional fields” let you shape the output without manual edits.

Below is a quick side‑by‑side comparison of the most popular free converters we’ve seen in the wild.

Converter	Type Inference	Nested Structs	Privacy
SwapCode Free AI Code Converter	Accurate (int, float64, string)	Generates separate structs automatically	HTTPS, no data retained on server
JSON to Go conversion tool	Handles arrays, numbers, booleans	Creates hierarchy without flattening	Client‑side processing only
Generic online tool (unnamed)	Often guesses strings for numbers	Flattens into map[string]interface{}	May store logs on backend

Notice how SwapCode’s converter checks the boxes for inference, nesting, and privacy. That’s why we recommend it as the go‑to choice for most developers.

But you might wonder, “What if I need to polish the output after conversion?” That’s where the Free AI Code Optimizer comes in. Run the generated structs through the optimizer to clean up imports, fix unused variables, and apply your preferred formatting style—all in one click.

Here’s a practical workflow you can copy‑paste into your own checklist:

• Paste the JSON into the converter.
• Enable “Force numbers to int” if you work with monetary values.
• Turn on “Generate nested structs” to keep the hierarchy.
• Check the privacy notice—make sure the site uses HTTPS and doesn’t store data.
• Copy the Go code, run a quick go run sanity test.
• If the code looks good, feed it into the Code Optimizer for a final tidy‑up.

After you’ve run through that loop a couple of times, you’ll develop a feel for which converter feels fastest for your particular use case. Some teams love the minimal UI of SwapCode, while others appreciate the client‑side guarantee of the JSON to Go tool.

One last tip: keep a short comment block at the top of each generated file that notes which converter you used and which options you toggled. Future teammates (or your future self) will thank you when they see something like:

// Generated with SwapCode Free AI Code Converter – force int, omitempty, pointers for optional fields.

That tiny note cuts down the guessing game and makes onboarding smoother. In short, comparing converters isn’t just a “nice‑to‑have” step; it’s the bridge between a one‑off conversion and a repeatable, reliable workflow that saves you minutes—sometimes hours—on every project.

Conclusion

We’ve walked through every step of turning a raw JSON blob into clean Go code, so you shouldn’t feel like you’re stuck in a loop of copy‑paste‑debug forever.

Remember the moment you first pasted that payload and watched the tool spit out structs? That instant payoff is the real reason we love a good convert json to go struct online tool – it hands you a type‑safe skeleton in seconds, letting you get back to building features.

Key takeaways: enable the options that match your data (force numbers to int, generate nested structs, use pointers for optional fields), run a quick sanity test, and sprinkle in omitempty or pointer tags where it makes sense. A short comment at the top of the file documenting the converter and options saves future teammates a lot of head‑scratching.

So, what’s the next move? Grab the next JSON snippet you’ve been avoiding, drop it into the converter, and let the workflow become a habit. The more you iterate, the faster you’ll develop an intuition for the right toggles.

In short, a reliable online converter turns a tedious chore into a repeatable, low‑friction step in your development pipeline. Give it a spin today and watch your productivity climb.

FAQ

What exactly does a “convert json to go struct online tool” do for me?

In plain terms, the tool reads a raw JSON payload, figures out the right Go types for every key, and spits out ready‑to‑copy struct definitions. You don’t have to guess whether a field is an int, a string, or a slice – the converter handles that in seconds. It’s especially handy when you’re dealing with nested objects or large API responses, because you get a type‑safe skeleton without the usual copy‑paste‑debug cycle.

Is the conversion really accurate, or will I end up fixing a lot of types later?

Most modern converters, including the free SwapCode version, use Go’s built‑in JSON rules to infer types, so you get correct int, float64, bool, and string mappings right away. The occasional edge case – like a numeric ID that sometimes arrives quoted as a string – can be solved by toggling “force numbers to int” or “use pointers for optional fields.” In practice you’ll only need to tweak a handful of fields, not rewrite the whole struct.

Can I keep my data private while using an online converter?

Yes, reputable services run the conversion entirely in the browser or over HTTPS without storing your payload. SwapCode’s converter processes the JSON on its server for speed but promises no logs or persistent storage, and the connection is encrypted. If you’re extra cautious, you can run the tool locally by opening the page, pasting your JSON, and watching the result appear before any network round‑trip.

Do I need to install anything to use the tool?

Not at all. All you need is a modern web browser. The interface is a single page with a large text area, a few checkboxes for options like “generate nested structs” or “add omitempty tags,” and a Convert button. Because it’s web‑based, you can bookmark the URL, use it on any OS, and even fire it up from a corporate laptop that blocks installations.

How do I handle optional fields that sometimes disappear from the JSON?

When a field is optional, enable the “use pointers for optional fields” toggle. The generator will then declare the field as *string, *int, etc., and add the omitempty tag automatically. In your Go code you can check for nil to know whether the API actually sent the value, which prevents silent zero‑value bugs that are hard to trace later.

What’s the best way to test the generated structs?

Copy the output into a tiny Go file, import ‘encoding/json’, and unmarshal the original JSON into the new type. If the program runs without panic and you can marshal the struct back to JSON that looks the same (ignoring whitespace), you’ve got a solid model. Adding a quick round‑trip test to your test suite is a habit that catches mismatches before they reach production.

Can I customize the generated code, like adding validation tags?

Absolutely. After the converter gives you the base struct, you can sprinkle in tags from libraries such as go‑playground/validator (e.g., `validate:”required,email”`). Because the output is plain Go code, you’re free to rename fields, adjust json tags, or insert custom UnmarshalJSON methods. Think of the tool as the first draft – you still have full control to polish it for your specific business rules.

Deep Dive: Advanced Customization of Go Structs

So you’ve got a clean struct from the converter, but you know the real world rarely fits a one‑size‑fits‑all model. That’s where the fun begins – shaping the generated code to match the quirks of your API and the expectations of your business logic.

Why go beyond the default?

Think about the last time you stared at a field that the tool marked as string but you actually need a time.Time. If you leave it as‑is, you’ll spend extra cycles parsing strings later. Adding the right type up front saves you from a hidden “gotcha” that can surface in production.

And it’s not just types. The default json:"field_name" tag is fine, but you might want omitempty, validation rules, or even custom marshaling logic to keep your payloads lean.

Custom tags for validation

Ever wish the struct could shout, “Hey, this email is required and must be valid”? That’s exactly what the go-playground/validator package does. After the converter spits out the skeleton, sprinkle a validate:"required,email" tag on the Email field. When you run validator.New().Struct(yourObj), any missing or malformed email aborts the flow before your business code even runs.

If you’re dealing with monetary values, a gt=0 rule prevents a zero‑cents transaction from slipping through unnoticed.

Pointer fields for real optionality

Remember the “use pointers for optional fields” toggle we mentioned earlier? It’s more than a convenience – it’s a safety net. A plain int can’t tell you whether the API omitted the field or sent a zero. A *int, on the other hand, lets you check if obj.Amount == nil and react accordingly.

Here’s a quick pattern: change DiscountCode string `json:"discount_code"` to DiscountCode *string `json:"discount_code,omitempty"`. Now you can differentiate “no discount offered” from “empty string discount”.

Embedding and method overrides

Sometimes you need a bit of behavior baked into the struct. Embedding a small helper struct gives you reusable methods without polluting every model. For example, embed a Timestamped struct that provides ParseCreated() and FormatCreated() helpers for any field named created_at.

If the default json.Unmarshal can’t handle a custom format – say a Unix timestamp that arrives as a string – implement a UnmarshalJSON method on that field’s type. The rest of your code stays clean, and you only write the conversion logic once.

Formatting and readability

Even the prettiest struct can look messy after a few manual tweaks. Run the final file through a formatter so the indentation, line breaks, and import order stay consistent across the repo. The Code Formatter & Beautifier does that in a click, keeping your codebase looking professional without any extra effort.

And don’t forget gofmt or your editor’s built‑in formatter as part of the CI pipeline – it catches stray tabs before they become a code‑review headache.

Practical checklist

• Review each field’s type – switch strings to time.Time or int where appropriate.
• Add omitempty or pointer types for fields that the API may omit.
• Sprinkle validation tags (required, email, gt=0) to catch bad data early.
• Implement custom UnmarshalJSON only for truly non‑standard formats.
• Embed reusable helper structs for common behavior (timestamps, pagination, etc.).
• Run the file through the formatter and add a short comment at the top documenting any non‑default decisions.

When you follow these steps, the struct you got from the “convert json to go struct online tool” becomes more than a static type definition – it turns into a robust, production‑ready model that shields you from subtle bugs and keeps your codebase tidy.

Give it a try on your next webhook payload. You’ll notice the difference the moment you skip a manual type‑cast or a hidden nil check. That’s the power of advanced customization: turning a quick conversion into a long‑term confidence boost.