writing custom fields

The web framework for perfectionists with deadlines.

Documentation

• ♥ Donate
• Toggle theme (current theme: auto) Toggle theme (current theme: light) Toggle theme (current theme: dark) Toggle Light / Dark / Auto color theme
• Getting Help
• Language: en
• Documentation version: 4.2

How to create custom model fields ¶

Introduction ¶.

The model reference documentation explains how to use Django’s standard field classes – CharField , DateField , etc. For many purposes, those classes are all you’ll need. Sometimes, though, the Django version won’t meet your precise requirements, or you’ll want to use a field that is entirely different from those shipped with Django.

Django’s built-in field types don’t cover every possible database column type – only the common types, such as VARCHAR and INTEGER . For more obscure column types, such as geographic polygons or even user-created types such as PostgreSQL custom types , you can define your own Django Field subclasses.

Alternatively, you may have a complex Python object that can somehow be serialized to fit into a standard database column type. This is another case where a Field subclass will help you use your object with your models.

Our example object ¶

Creating custom fields requires a bit of attention to detail. To make things easier to follow, we’ll use a consistent example throughout this document: wrapping a Python object representing the deal of cards in a hand of Bridge . Don’t worry, you don’t have to know how to play Bridge to follow this example. You only need to know that 52 cards are dealt out equally to four players, who are traditionally called north , east , south and west . Our class looks something like this:

This is an ordinary Python class, with nothing Django-specific about it. We’d like to be able to do things like this in our models (we assume the hand attribute on the model is an instance of Hand ):

We assign to and retrieve from the hand attribute in our model just like any other Python class. The trick is to tell Django how to handle saving and loading such an object.

In order to use the Hand class in our models, we do not have to change this class at all. This is ideal, because it means you can easily write model support for existing classes where you cannot change the source code.

You might only be wanting to take advantage of custom database column types and deal with the data as standard Python types in your models; strings, or floats, for example. This case is similar to our Hand example and we’ll note any differences as we go along.

Background theory ¶

Database storage ¶.

Let’s start with model fields. If you break it down, a model field provides a way to take a normal Python object – string, boolean, datetime , or something more complex like Hand – and convert it to and from a format that is useful when dealing with the database. (Such a format is also useful for serialization, but as we’ll see later, that is easier once you have the database side under control).

Fields in a model must somehow be converted to fit into an existing database column type. Different databases provide different sets of valid column types, but the rule is still the same: those are the only types you have to work with. Anything you want to store in the database must fit into one of those types.

Normally, you’re either writing a Django field to match a particular database column type, or you will need a way to convert your data to, say, a string.

For our Hand example, we could convert the card data to a string of 104 characters by concatenating all the cards together in a predetermined order – say, all the north cards first, then the east , south and west cards. So Hand objects can be saved to text or character columns in the database.

What does a field class do? ¶

All of Django’s fields (and when we say fields in this document, we always mean model fields and not form fields ) are subclasses of django.db.models.Field . Most of the information that Django records about a field is common to all fields – name, help text, uniqueness and so forth. Storing all that information is handled by Field . We’ll get into the precise details of what Field can do later on; for now, suffice it to say that everything descends from Field and then customizes key pieces of the class behavior.

It’s important to realize that a Django field class is not what is stored in your model attributes. The model attributes contain normal Python objects. The field classes you define in a model are actually stored in the Meta class when the model class is created (the precise details of how this is done are unimportant here). This is because the field classes aren’t necessary when you’re just creating and modifying attributes. Instead, they provide the machinery for converting between the attribute value and what is stored in the database or sent to the serializer .

Keep this in mind when creating your own custom fields. The Django Field subclass you write provides the machinery for converting between your Python instances and the database/serializer values in various ways (there are differences between storing a value and using a value for lookups, for example). If this sounds a bit tricky, don’t worry – it will become clearer in the examples below. Just remember that you will often end up creating two classes when you want a custom field:

• The first class is the Python object that your users will manipulate. They will assign it to the model attribute, they will read from it for displaying purposes, things like that. This is the Hand class in our example.
• The second class is the Field subclass. This is the class that knows how to convert your first class back and forth between its permanent storage form and the Python form.

Writing a field subclass ¶

When planning your Field subclass, first give some thought to which existing Field class your new field is most similar to. Can you subclass an existing Django field and save yourself some work? If not, you should subclass the Field class, from which everything is descended.

Initializing your new field is a matter of separating out any arguments that are specific to your case from the common arguments and passing the latter to the __init__() method of Field (or your parent class).

In our example, we’ll call our field HandField . (It’s a good idea to call your Field subclass <Something>Field , so it’s easily identifiable as a Field subclass.) It doesn’t behave like any existing field, so we’ll subclass directly from Field :

Our HandField accepts most of the standard field options (see the list below), but we ensure it has a fixed length, since it only needs to hold 52 card values plus their suits; 104 characters in total.

Many of Django’s model fields accept options that they don’t do anything with. For example, you can pass both editable and auto_now to a django.db.models.DateField and it will ignore the editable parameter ( auto_now being set implies editable=False ). No error is raised in this case.

This behavior simplifies the field classes, because they don’t need to check for options that aren’t necessary. They pass all the options to the parent class and then don’t use them later on. It’s up to you whether you want your fields to be more strict about the options they select, or to use the more permissive behavior of the current fields.

The Field.__init__() method takes the following parameters:

• verbose_name
• primary_key
• rel : Used for related fields (like ForeignKey ). For advanced use only.
• serialize : If False , the field will not be serialized when the model is passed to Django’s serializers . Defaults to True .
• unique_for_date
• unique_for_month
• unique_for_year
• db_tablespace : Only for index creation, if the backend supports tablespaces . You can usually ignore this option.
• auto_created : True if the field was automatically created, as for the OneToOneField used by model inheritance. For advanced use only.

All of the options without an explanation in the above list have the same meaning they do for normal Django fields. See the field documentation for examples and details.

Field deconstruction ¶

The counterpoint to writing your __init__() method is writing the deconstruct() method. It’s used during model migrations to tell Django how to take an instance of your new field and reduce it to a serialized form - in particular, what arguments to pass to __init__() to recreate it.

If you haven’t added any extra options on top of the field you inherited from, then there’s no need to write a new deconstruct() method. If, however, you’re changing the arguments passed in __init__() (like we are in HandField ), you’ll need to supplement the values being passed.

deconstruct() returns a tuple of four items: the field’s attribute name, the full import path of the field class, the positional arguments (as a list), and the keyword arguments (as a dict). Note this is different from the deconstruct() method for custom classes which returns a tuple of three things.

As a custom field author, you don’t need to care about the first two values; the base Field class has all the code to work out the field’s attribute name and import path. You do, however, have to care about the positional and keyword arguments, as these are likely the things you are changing.

For example, in our HandField class we’re always forcibly setting max_length in __init__() . The deconstruct() method on the base Field class will see this and try to return it in the keyword arguments; thus, we can drop it from the keyword arguments for readability:

If you add a new keyword argument, you need to write code in deconstruct() that puts its value into kwargs yourself. You should also omit the value from kwargs when it isn’t necessary to reconstruct the state of the field, such as when the default value is being used:

More complex examples are beyond the scope of this document, but remember - for any configuration of your Field instance, deconstruct() must return arguments that you can pass to __init__ to reconstruct that state.

Pay extra attention if you set new default values for arguments in the Field superclass; you want to make sure they’re always included, rather than disappearing if they take on the old default value.

In addition, try to avoid returning values as positional arguments; where possible, return values as keyword arguments for maximum future compatibility. If you change the names of things more often than their position in the constructor’s argument list, you might prefer positional, but bear in mind that people will be reconstructing your field from the serialized version for quite a while (possibly years), depending how long your migrations live for.

You can see the results of deconstruction by looking in migrations that include the field, and you can test deconstruction in unit tests by deconstructing and reconstructing the field:

Field attributes not affecting database column definition ¶

You can override Field.non_db_attrs to customize attributes of a field that don’t affect a column definition. It’s used during model migrations to detect no-op AlterField operations.

For example:

Changing a custom field’s base class ¶

You can’t change the base class of a custom field because Django won’t detect the change and make a migration for it. For example, if you start with:

and then decide that you want to use TextField instead, you can’t change the subclass like this:

Instead, you must create a new custom field class and update your models to reference it:

As discussed in removing fields , you must retain the original CustomCharField class as long as you have migrations that reference it.

Documenting your custom field ¶

As always, you should document your field type, so users will know what it is. In addition to providing a docstring for it, which is useful for developers, you can also allow users of the admin app to see a short description of the field type via the django.contrib.admindocs application. To do this provide descriptive text in a description class attribute of your custom field. In the above example, the description displayed by the admindocs application for a HandField will be ‘A hand of cards (bridge style)’.

In the django.contrib.admindocs display, the field description is interpolated with field.__dict__ which allows the description to incorporate arguments of the field. For example, the description for CharField is:

Useful methods ¶

Once you’ve created your Field subclass, you might consider overriding a few standard methods, depending on your field’s behavior. The list of methods below is in approximately decreasing order of importance, so start from the top.

Custom database types ¶

Say you’ve created a PostgreSQL custom type called mytype . You can subclass Field and implement the db_type() method, like so:

Once you have MytypeField , you can use it in any model, just like any other Field type:

If you aim to build a database-agnostic application, you should account for differences in database column types. For example, the date/time column type in PostgreSQL is called timestamp , while the same column in MySQL is called datetime . You can handle this in a db_type() method by checking the connection.vendor attribute. Current built-in vendor names are: sqlite , postgresql , mysql , and oracle .

The db_type() and rel_db_type() methods are called by Django when the framework constructs the CREATE TABLE statements for your application – that is, when you first create your tables. The methods are also called when constructing a WHERE clause that includes the model field – that is, when you retrieve data using QuerySet methods like get() , filter() , and exclude() and have the model field as an argument. They are not called at any other time, so it can afford to execute slightly complex code, such as the connection.settings_dict check in the above example.

Some database column types accept parameters, such as CHAR(25) , where the parameter 25 represents the maximum column length. In cases like these, it’s more flexible if the parameter is specified in the model rather than being hard-coded in the db_type() method. For example, it wouldn’t make much sense to have a CharMaxlength25Field , shown here:

The better way of doing this would be to make the parameter specifiable at run time – i.e., when the class is instantiated. To do that, implement Field.__init__() , like so:

Finally, if your column requires truly complex SQL setup, return None from db_type() . This will cause Django’s SQL creation code to skip over this field. You are then responsible for creating the column in the right table in some other way, but this gives you a way to tell Django to get out of the way.

The rel_db_type() method is called by fields such as ForeignKey and OneToOneField that point to another field to determine their database column data types. For example, if you have an UnsignedAutoField , you also need the foreign keys that point to that field to use the same data type:

Converting values to Python objects ¶

If your custom Field class deals with data structures that are more complex than strings, dates, integers, or floats, then you may need to override from_db_value() and to_python() .

If present for the field subclass, from_db_value() will be called in all circumstances when the data is loaded from the database, including in aggregates and values() calls.

to_python() is called by deserialization and during the clean() method used from forms.

As a general rule, to_python() should deal gracefully with any of the following arguments:

• An instance of the correct type (e.g., Hand in our ongoing example).
• None (if the field allows null=True )

In our HandField class, we’re storing the data as a VARCHAR field in the database, so we need to be able to process strings and None in the from_db_value() . In to_python() , we need to also handle Hand instances:

Notice that we always return a Hand instance from these methods. That’s the Python object type we want to store in the model’s attribute.

For to_python() , if anything goes wrong during value conversion, you should raise a ValidationError exception.

Converting Python objects to query values ¶

Since using a database requires conversion in both ways, if you override from_db_value() you also have to override get_prep_value() to convert Python objects back to query values.

If your custom field uses the CHAR , VARCHAR or TEXT types for MySQL, you must make sure that get_prep_value() always returns a string type. MySQL performs flexible and unexpected matching when a query is performed on these types and the provided value is an integer, which can cause queries to include unexpected objects in their results. This problem cannot occur if you always return a string type from get_prep_value() .

Converting query values to database values ¶

Some data types (for example, dates) need to be in a specific format before they can be used by a database backend. get_db_prep_value() is the method where those conversions should be made. The specific connection that will be used for the query is passed as the connection parameter. This allows you to use backend-specific conversion logic if it is required.

For example, Django uses the following method for its BinaryField :

In case your custom field needs a special conversion when being saved that is not the same as the conversion used for normal query parameters, you can override get_db_prep_save() .

Preprocessing values before saving ¶

If you want to preprocess the value just before saving, you can use pre_save() . For example, Django’s DateTimeField uses this method to set the attribute correctly in the case of auto_now or auto_now_add .

If you do override this method, you must return the value of the attribute at the end. You should also update the model’s attribute if you make any changes to the value so that code holding references to the model will always see the correct value.

Specifying the form field for a model field ¶

To customize the form field used by ModelForm , you can override formfield() .

The form field class can be specified via the form_class and choices_form_class arguments; the latter is used if the field has choices specified, the former otherwise. If these arguments are not provided, CharField or TypedChoiceField will be used.

All of the kwargs dictionary is passed directly to the form field’s __init__() method. Normally, all you need to do is set up a good default for the form_class (and maybe choices_form_class ) argument and then delegate further handling to the parent class. This might require you to write a custom form field (and even a form widget). See the forms documentation for information about this.

Continuing our ongoing example, we can write the formfield() method as:

This assumes we’ve imported a MyFormField field class (which has its own default widget). This document doesn’t cover the details of writing custom form fields.

Emulating built-in field types ¶

If you have created a db_type() method, you don’t need to worry about get_internal_type() – it won’t be used much. Sometimes, though, your database storage is similar in type to some other field, so you can use that other field’s logic to create the right column.

No matter which database backend we are using, this will mean that migrate and other SQL commands create the right column type for storing a string.

If get_internal_type() returns a string that is not known to Django for the database backend you are using – that is, it doesn’t appear in django.db.backends.<db_name>.base.DatabaseWrapper.data_types – the string will still be used by the serializer, but the default db_type() method will return None . See the documentation of db_type() for reasons why this might be useful. Putting a descriptive string in as the type of the field for the serializer is a useful idea if you’re ever going to be using the serializer output in some other place, outside of Django.

Converting field data for serialization ¶

To customize how the values are serialized by a serializer, you can override value_to_string() . Using value_from_object() is the best way to get the field’s value prior to serialization. For example, since HandField uses strings for its data storage anyway, we can reuse some existing conversion code:

Some general advice ¶

Writing a custom field can be a tricky process, particularly if you’re doing complex conversions between your Python types and your database and serialization formats. Here are a couple of tips to make things go more smoothly:

• Look at the existing Django fields (in django/db/models/fields/__init__.py ) for inspiration. Try to find a field that’s similar to what you want and extend it a little bit, instead of creating an entirely new field from scratch.
• Put a __str__() method on the class you’re wrapping up as a field. There are a lot of places where the default behavior of the field code is to call str() on the value. (In our examples in this document, value would be a Hand instance, not a HandField ). So if your __str__() method automatically converts to the string form of your Python object, you can save yourself a lot of work.

Writing a FileField subclass ¶

In addition to the above methods, fields that deal with files have a few other special requirements which must be taken into account. The majority of the mechanics provided by FileField , such as controlling database storage and retrieval, can remain unchanged, leaving subclasses to deal with the challenge of supporting a particular type of file.

Django provides a File class, which is used as a proxy to the file’s contents and operations. This can be subclassed to customize how the file is accessed, and what methods are available. It lives at django.db.models.fields.files , and its default behavior is explained in the file documentation .

Once a subclass of File is created, the new FileField subclass must be told to use it. To do so, assign the new File subclass to the special attr_class attribute of the FileField subclass.

A few suggestions ¶

In addition to the above details, there are a few guidelines which can greatly improve the efficiency and readability of the field’s code.

• The source for Django’s own ImageField (in django/db/models/fields/files.py ) is a great example of how to subclass FileField to support a particular type of file, as it incorporates all of the techniques described above.
• Cache file attributes wherever possible. Since files may be stored in remote storage systems, retrieving them may cost extra time, or even money, that isn’t always necessary. Once a file is retrieved to obtain some data about its content, cache as much of that data as possible to reduce the number of times the file must be retrieved on subsequent calls for that information.

Additional Information

Support django.

• Arrai Innovations Inc. donated to the Django Software Foundation to support Django development. Donate today!
• Our example object
• Database storage
• What does a field class do?
• Field deconstruction
• Field attributes not affecting database column definition
• Changing a custom field’s base class
• Documenting your custom field
• Custom database types
• Converting values to Python objects
• Converting Python objects to query values
• Converting query values to database values
• Preprocessing values before saving
• Specifying the form field for a model field
• Emulating built-in field types
• Converting field data for serialization
• Some general advice
• A few suggestions
• Prev: How to create custom django-admin commands
• Next: How to write custom lookups
• Table of contents
• General Index
• Python Module Index

You are here:

• How to create custom model fields

Getting help

Offline (Django 4.2): HTML | PDF | ePub Provided by Read the Docs .

Django Links

• About Django
• Getting Started with Django
• Team Organization
• Django Software Foundation
• Code of Conduct
• Diversity Statement

Get Involved

• Join a Group
• Contribute to Django
• Submit a Bug
• Report a Security Issue
• Getting Help FAQ
• #django IRC channel
• Django Discord
• Official Django Forum
• Fediverse (Mastodon)
• Django Users Mailing List
• Sponsor Django
• Official merchandise store
• Benevity Workplace Giving Program
• Hosting by In-kind donors
• Design by Threespot & andrevv

© 2005-2023 Django Software Foundation and individual contributors. Django is a registered trademark of the Django Software Foundation.

Writing Custom Field Extensions

Collecting input from the user is a very large part of the scaffolding process and Software Templates as a whole. Sometimes the built in components and fields just aren't good enough, and sometimes you want to enrich the form that the users sees with better inputs that fit better.

This is where Custom Field Extensions come in.

With them you can show your own React Components and use them to control the state of the JSON schema, as well as provide your own validation functions to validate the data too.

Creating a Field Extension ​

Field extensions are a way to combine an ID, a React Component and a validation function together in a modular way that you can then use to pass to the Scaffolder frontend plugin in your own App.tsx .

You can create your own Field Extension by using the createScaffolderFieldExtension API like below.

As an example, we will create a component that validates whether a string is in the Kebab-case pattern:

Once all these files are in place, you then need to provide your custom extension to the scaffolder plugin.

You do this in packages/app/src/App.tsx . You need to provide the customFieldExtensions as children to the ScaffolderPage .

Should look something like this instead:

Using the Custom Field Extension ​

Once it's been passed to the ScaffolderPage you should now be able to use the ui:field property in your templates to point it to the name of the customFieldExtension that you registered.

Something like this:

Access Data from other Fields ​

Custom fields extensions can read data from other fields in the form via the form context. This is something that we discourage due to the coupling that it creates, but is sometimes still the most sensible solution.

Previewing Custom Field Extensions ​

You can preview custom field extensions you write in the Backstage UI using the Custom Field Explorer (accessible via the /create/edit route by default):

In order to make your new custom field extension available in the explorer you will have to define a JSON schema that describes the input/output types on your field like in the following example:

We recommend using a library like zod to define your schema and the provided makeFieldSchemaFromZod helper utility function to generate both the JSON schema and type for your field props to preventing having to duplicate the definitions:

• Creating a Field Extension
• Using the Custom Field Extension
• Access Data from other Fields
• Previewing Custom Field Extensions

BuildThatWebsite

Getting Started with WordPress Custom Fields

Custom fields are one of the most powerful (yet underused) features in WordPress.

Custom fields allow you to store custom data in the database, access it from anywhere on your site, and build incredible dynamic sites that aren’t possible static HTML and website builders like Wix.

In this guide, I’ll teach you the everything you need to know in order to get started using custom fields in your own WordPress site.

We’ll cover:

• What are custom fields?
• How to add custom fields
• How to display custom field data
• Example uses

So why doesn’t everyone use Custom Fields?

• Custom can be confusing and intimidating for beginners
• There wasn’t an easy way to display custom field data (page builders make this easy )
• Your site is using custom fields, you just don’t realize it yet.

Ready? Let’s dive in.

What are Custom Fields?

Custom fields are a type of data in WordPress, known as Metadata. This custom field metadata can be attached to posts, custom post types and taxonomies.

Custom fields allow you to store pieces if the database that can be searched, displayed, queried, and updated anywhere.

Custom fields example: WooCommerce

Woocommerce is an e-commerce plugin for WordPress that lets you build your own online store. You can add products to your WooCommerce shop and store data about each product, including:

You define the price once via a custom field, then WooCommerce can display it in multiple locations on your site.

Even better, if you change the price, it will be instantly updated everywhere. This is one of the key advantages of using custom fields rather than just a simple text editor to create content.

Why use custom fields?

Custom fields are perfect for any type of data or content that fits any of these criteria:

Use custom fields if:

• Data is used in multiple locations on your site
• Data needs to be updated occasionally
• Data is standardized across multiple posts (listing template, directory site)

What can you build with custom fields?

Here are a few quick examples of sites or features that can only be built by using custom fields. They would be nearly impossible to maintain through manual updates.

• Directory site: G2, Capterra, Yelp
• Listing site: AirBnB, Zillow, Realtor.com, Indeed
• Affiliate site: Dynamically update product prices, features, links and logos
• Review Template: display review score, rating details and product attributes
• Dynamic Design: Change the color scheme of your post header on a per-page basis
• Dynamic asset loading: Load a CSS file if a custom field is set (e.g. FontAwesome)

And these are just a few examples. But you can see the power. Once you harness custom fields, you can build amazing, profitable sites incredibly quickly.

For example, sites like pluginforthat just scrape the WP Repository, store that data in custom fields, and display it on the front end. They get longtail search traffic and create zero original content.

Adding Custom Fields

There are several ways to add custom fields to WordPress. While WordPress does natively support simple text-based custom fields, we recommend using a custom fields plugin with an advanced API and more field types.

Methods to add custom fields to WordPress:

• Official: Built into WordPress (text only)
• Custom Fields API (recommended) : Multiple field types, easier to display, more powerful. There are plenty of free options like Pods, Carbon Fields and Advanced Custom Fields.

Default WordPress Custom Fields

WordPress ships with built-in custom field functionality. These fields are text-only and consist of only two things:

• Field Key – the name you use to query the field
• Field Value – Text data stored in the field

Here’s what custom meta fields look like on the back end:

Creating a field

By default, custom fields may be hidden in your WordPress editor. So first, you’ll need to make sure they’re set to display.

To enable custom fields in Gutenberg Editor:

• Click the 3-dots icon in the top right of your editor
• Select Panels
• Check the toggle to show custom fields.

Creating a new custom field

Scroll to the bottom of your editor (below the content) and you’ll see one or more meta boxes. One should be blank. You can add your own custom field name and text-based value, then click ‘Add Field’ to store it in the database.

Why you should use a Custom Fields Plugin instead

WordPress’s native custom fields have a lot of limitations compared to what you get with 3rd-party plugins (even free ones).

Here are just a few of the drawbacks of using built-in custom meta:

• Only supports simple text-based fields
• Must be created on a per-post basis (no bulk field creation)
• No field grouping
• No advanced field types (e.g. gallery, image, color picker, URL, repeater)
• No API for displaying field data (e.g. a shortcode)

3rd-party Plugins

The best way to get started with custom fields is by using a 3rd-party plugin. There are several excellent options, and many of them are completely free.

Why use a plugin to create custom fields:

• More Field Types: Get advanced field types
• Fields Groups & Bulk Creation: Organize fields into groups and connect them to specific posts by post type, category, taxonomy or other custom conditions.
• Display API: Easily display field data without PHP by using Shortcodes, Page Builders, or even Gutenberg Blocks.

Recommended Custom Field Plugins:

These are some of the best plugins for creating custom fields:

• Advanced Custom Fields : Tons of field types, easy field creation and grouping. Includes a shortcode to display field data, but has advanced integration with popular page builders and other plugins.
• Pods : Completely free alternative to ACF. Supports 15+ field types, shortcode-based templating, Gutenberg support, and page builder integration
• Crocoblock/ JetEngine : Complete dynamic data suite that makes it easy to create custom fields, custom post types and custom taxonomies. Integrates with Elementor & Gutenberg.
• Toolset : All-in-one suite for custom fields, custom post types, filtering, and more. Built around Gutenberg and is the most complete Gutenberg-based solution.

Displaying Custom Fields

The whole point of using custom fields is to either display them on the front end, or to query them when listing or filtering posts.

built-in custom fields require writing PHP to access them, but the 3rd-party custom fields plugins give you many different ways to display them on your site.

Page Builders

Page Builder support has been a game-changer for making custom fields accessible to non-developers.

Now you can access custom field data directly from your page builder’s UI, and use this data as content in many of your page builder’s widgets and blocks.

For the most part, this functionality is restricted to paid page builders (or the pro version of freemium plugins like Elementor.

List of page builders that support Custom Fields:

• Elementor Pro : ACF, Pods, Toolset and default custom fields
• Beaver Builder / Themer Pro: ACF, Pods, Toolset
• Oxygen Builder : ACF, Toolset, Pods, Carbon Fields
• Bricks Builder : ACF, Pods, Crocoblock, Meta Box

Pros & Cons of using page builders

• Premium page builders cost money
• Heavier pages may hurt page speed

All things considered, using a page builder is probably the best way to get started with custom fields, especially if you’re already using one anyway. You can build incredibly complex designs and templates with zero coding skills or design experience.

The only real negative is page builders tend to create larger page sizes than hand-written code, but I still manage fast (around 1-second) load times with Elementor pages.

Gutenberg Blocks

Now that Gutenberg has matured into a full-fledged page builder in its own right, it was only a matter of time before developers built custom field support into their Gutenberg blocks.

There are several ways to display custom fields using Gutenberg

Gutenberg API for Custom Field Plugins (Toolset, Crocoblock)

Some custom fields plugins have built a complete Gutenberg templating system into their plugin.

The best example of this is Toolset, which ships with more than 20 block types for displaying custom fields and even building complete page, post, and loop templates.

The entire templating system, which used to be built around shortcodes, was re-built from the ground up to integrate seamlessly with the Gutenberg Editor.

Crocoblock Jet Engine

Another good example of this is JetEngine from the crocoblock suite. It’s not as complete Gutenberg solution as you get from Toolset, but it’s still good enough for building simple templates and displaying JetEngine’s 15+ field types.

3rd-party blocks

Several developers have added custom field and dynamic content functionality into their own Gutenberg blocks. These integrations tend to be simpler, but still work well for basic field types like text, links, colors, etc.

Gutenberg plugins with custom field support:

• Generateblocks
• Stackable (pro)
• Kadence Blocks (pro)

Shortcodes and HTML templating (Pods, ACF)

Several custom fields plugins have their own display and templating system built around HTML and shortcodes.

This allows you to display custom field values, and even create complex loops or templates without writing any PHP. This functionality varies by plugin. Here’s a quick look at some popular options:

Shortcode Templating

Pods has a special shortcode that lets you built templates and display custom fields using what they call ‘magic tags’. You can even use simple loops and if/else logic with just shortcodes.

Learn more: Displaying Pods

Simple Shortcodes

Advanced Custom Fields has a basic shortcode that will retrieve the raw text value of any field. It’s not as useful or flexible as the pods shortcode (above), but it still works for all kinds of simple use cases.

For example, on one of my sites I built a simple widget using just HTML and the ACF shortcode to show the logo, name, and button for the product I was reviewing on the page.

The shortcode looks like this:

PHP is the old-school method of displaying custom fields, but it is the least beginner-friendly. However, it’s still the preferred method of skilled developers because you get full control over the code and logic when accessing field values.

For example, you can retrieve a field value and then modify (e.g. multiple two fields together) before displaying it on the front-end.

WordPress includes a built-in function get_post_meta() for accessing native custom fields, while 3rd-party custom fields plugins have their own functions for retrieving fields.

Here’s a simple example from Advanced Custom Fields:

What’s the best method for displaying custom fields?

Ultimately, the best method for displaying custom field values comes down to two things:

• Your skill level (can you code?)
• Your preferred tools

But when you’re first getting started with custom fields, a page builder like Elementor Pro will probably be your best option.

There are several advantages to using a page builder, especially for beginners. First, you can design visually and quickly. Secondly, you’re not going to break your site my misplacing a semicolon of forgetting to sanitize a field value.

And the fact that you can work so quickly means you can learn quickly, prototype quickly, and get something amazing built in hours rather than days or weeks.

Ways to use Custom Fields in your Site

There are four basic ways to use custom field values in your site:

• Display custom field values in your content
• Display custom values in your template(s)
• Query by custom fields (display posts that have a specific field set)
• Filter by values (filter posts by custom field values)

You can combine these techniques to create nearly any time of modern data-based website.

Below you’ll find examples of data-driven sites you could build using custom fields (in combination with other content types).

Custom Fields Examples in the Wild

To really understand the power of custom field (and what can be built with them) I want to take you through a few examples.

Note: Most of these sites are built with WordPress, using custom fields. However the final example (Airbnb) is an example of something you could build with custom fields.

Rental Cars Listing (Crocoblock)

RentGO is demo site built using the Crocoblock plugin suite . It really showcases the capabilities of dynamic data and custom fields, and makes extensive use of front-end display as well as search & filtering.

Here’s a screenshot of their listing template for a rental car, displaying custom field data like: passenger capacity, color, model, cargo size, fuel economy, transmission, drivetrain and more.

There’s also a listing template, where users can filter cars by custom field data to find the perfect match. Best of all, this was built with zero-code whatsoever, just Elementor Pro and Crocoblock.

Affiliate Site (Cloudwards)

Cloudwards is a high-traffic affiliate site in the privacy and data security niche. They use custom fields to store data about their affiliate partners, including cloud storage providers and VPNs.

They then query this data on the front end to display rankings of affiliate products in their posts.

For example, in the screenshot above we can see there are using multiple fields, including: product-logo, product-rating, features, monthly price, refund-policy and affiliate-link.

Cloudwards also uses the data to display in-content pricing data and even built dynamic head-to-head comparison tables. It’s a perfect example of how custom fields can bring in revenue.

And the best part, once you’ve set up the data and templating, it’s a huge time saver. For example, each comparison article is generated completely via code. It’s not written content.

Custom Theme Options

Custom Fields aren’t just for storing and displaying data. You can also use them entirely on the back-end of your site, for customization purposes.

For example, here are a few ways I use custom fields here at BTW and my other websites:

• Enqueuing Scripts: I’m a bit of a speed junkie, but I don’t like that to get in the way of user experience. So when I need a CSS or Javascript file for specific pages (e.g. FontAwesome) I just use a custom field (toggle or checkbox) to enqueue it for that post.
• Show/Hide Elements: On some review posts, I show a CTA widget in the sidebar. I have a simple script that checks if a custom field is toggled ‘on’. If not, the widget will be hidden.
• Dynamic Colors: Sections of my sites use different colors for the background of each hero section. I can change this with a color-picker custom field on that post, which gets loaded as a CSS variable on the front-end.
• Custom Archive Pages: If I want to override the default archive template (e.g. a category page) I can pull in different content using a ‘post object’ custom field, or add text (or other) custom fields to the existing template.

Next steps & Additional Resources

Now that you understand the basics of custom fields, it’s time to get your hands dirty and start building.

Here’s what you should do next:

• Install a custom fields plugin like ACF (free) on your site or local development server
• Pick a display method (page builders are the best way to start)
• Sketch a basic design for an element or page that could include custom fields
• Create and populate fields to match
• Create a template to display those fields (page builder, Gutenberg, or PHP)

Once you’ve mastered the basics, start brainstorming ideas for real-world uses of custom fields that you can build for your site. Like maybe a custom review widget or affiliate hero section .

Pretty soon, you’ll start seeing opportunities for custom fields and dynamic data everywhere.

Additional Reading

Here are some more resources on custom fields:

• Custom Fields 101 (WP Beginner)
• Beginners guide to custom fields (Themeisle)
• Beginners Guide to Advanced Custom Fields

ACF Tutorials:

• Ultimate Guide to ACF (Kinsta)

Official Plugin Documentations

• Advanced Custom Fields (very well documented)
• Pods.io (fragmented, but being rebuilt)
• Carbon Fields (excellent)

Leave a Comment Cancel reply

Save my name, email, and website in this browser for the next time I comment.

How to Insert Fields in Microsoft Word (Built-in or Custom)

Insert Fields in a Microsoft Word Document to Display Variable Content

by Avantix Learning Team | Updated January 10, 2021

Applies to: Microsoft ®  Word ®  2010, 2013, 2016, 2019 or 365 (Windows)

You can insert built-in or custom fields in Word documents to display variable content that will change when you update the fields. Some fields (like page numbers, merge fields or cross-references) are inserted automatically when you use Microsoft Word features. If you want to insert custom fields, you will need to create custom document properties.

By default, Word displays the result of a field rather than its field codes. You can right-click a field and select Toggle Field Codes to display field codes or field results.

Recommended article:   How to Hide Comments in Word (or Display Them)

Do you want to learn more about Microsoft Word?  Check out our virtual classroom or live classroom  Word courses >

If you are working with fields in Microsoft Word, you will be using quite a few function keys (such as F9). On some laptops, you will need to press the Fn key on your keyboard to enable your function keys. For example, instead of pressing F9 to update a field or fields, you would press Fn + F9.

Inserting built-in fields

To insert a field, click Quick Parts in the Text group on the Insert tab in the Ribbon. The Field command appears in the Quick Parts drop-down menu as follows:

Below is the Field dialog box in Microsoft Word with Page selected:

To insert a built-in field using the Field dialog box:

Navigate to the location in the Word document where you want to insert a field.

• Click the Insert tab in the Ribbon and then click Quick Parts in the Text group. A drop-down menu appears.
• Select Field. A dialog box appears.
• In the list of Field names, select a field. You can filter the list by clicking the down arrow in the Categories list and selecting a category first. Select All to display all fields.
• Under Field properties, select any properties or options you want.
• To view the codes for a field in the Field box, click Field Codes. For some fields, this button is clicked by default.
• Ensure that Preserve Formatting During Updates is checked so that formatting you apply is not removed when the fields are updated.
• Click OK. The field is inserted into the document.

Format the field results by applying text formatting to the field using the Home tab in the Ribbon.

You can view or hide all field codes in your document by pressing Alt + F9. Field codes appear between braces or curly brackets { } and you cannot type these braces. Be sure to hide the field codes again by pressing Alt + F9.

To edit a built-in field in the Field dialog box:

• Right-click the field and then click Edit Field. A dialog box appears.
• Change the field properties and options.

Understanding Word document properties

There are 3 different types of document properties in Word:

• Standard document properties (also called built-in document properties)
• Custom document properties
• Document library properties

Word documents contain a set of standard document properties such as Title, Author, Keywords and Comments. These properties are used to store metadata about your document. You cannot change the name of standard properties but you can edit the value of some of them (such as Title). Other standard properties that cannot be edited store data that is updated automatically (such as Size or Last Modified).

Document library properties are related to documents that are stored in a document library on a website or in a public folder (such as files in SharePoint).

In addition to the standard properties, you can create your own custom document properties. These properties can be created to store additional information in a document other than the standard document properties.  For example, custom document properties could be created for Product1, Product2, Product3, Sponsor, Project Manager, Cell Phone or Disclaimer. Each custom document property must be assigned a name, a data type and a value. The four data types are Text, Date, Number and Yes or No.

After you create custom document properties for your Word document, you can then insert them as custom fields.

Adding a custom document property

To add a custom document property:

• Open the Word document in which you want to add a custom document property.
• Click the File tab in the Ribbon and then click Info on the left. Info is usually selected by default.
• On the right side of screen, click Properties. A drop-down menu appears.
• Select Advanced Properties. A dialog box appears.
• Click the Custom tab in the dialog box.
• Type a name for the custom document property in the Name box. You can also choose one of the other properties that appear in the drop-down list.
• Select Text, Date, Number or Yes or No as the data type for the custom property.
• Enter a value for the property in the Value box.
• Click Add. The custom property appears in the list at the bottom of the dialog box.

After you have added a custom document property, you will be able to insert it into your document as a field.

In the example below, we're adding a field for Project Manager:

After you click Add, the custom field appears in the Properties list:

Inserting custom document property fields

The value of a custom document property can be inserted in a Word document using DocProperty fields. Custom document properties that have been added to a document are saved with the document whether they are inserted as a DocProperty field or not. You can insert DocProperty fields multiple times in a document.

To insert a custom document property field using the Field dialog box:

• In the list of Field names on the left, select DocProperty.
• Under Field properties, select a property name.

In the example below, we're inserting the custom Project Manager field we created in Advanced Properties:

Updating built-in and custom fields

Word should automatically update fields when a document is opened. Many fields are also updated automatically when you go to Print Preview (click the File tab and then click Print). If you prefer, you can update fields manually.

To update a field manually, right-click the field and then click Update Field or press F9.

To update all fields manually in the main body of a document, press Ctrl + A to select all and then press F9.

Some fields in headers, footers or text boxes must be updated separately. Click in the header, footer or text box, press Ctrl + A to select all and then press F9. Page fields do not need to be updated manually because they update when you go the Print Preview.

If you want to edit a custom DocProperty field, you will need to edit it in the Advanced Properties dialog box.

Subscribe to get more articles like this one

Did you find this article helpful? If you would like to receive new articles, join our email list.

More resources

How to Create, Save, Edit and Use Templates in Word

How to Insert, Format and Update Cross-References in Word

5 Ways to Insert the Division Symbol in Word (Type or Insert ÷)

10 Microsoft Word Tips, Tricks and Shortcuts for Selecting in Tables

How to Create a Table of Contents in Word (Insert, Format and Update a TOC)

Related courses

Microsoft Word: Intermediate / Advanced

Microsoft Excel: Intermediate / Advanced

Microsoft PowerPoint: Intermediate / Advanced

Microsoft Word: Long Documents Master Class

Microsoft Word: Styles, Templates and Tables of Contents

Microsoft Word: Designing Dynamic Word Documents Using Fields

VIEW MORE COURSES >

Our instructor-led courses are delivered in virtual classroom format or at our downtown Toronto location at 18 King Street East, Suite 1400, Toronto, Ontario, Canada (some in-person classroom courses may also be delivered at an alternate downtown Toronto location). Contact us at [email protected] if you'd like to arrange custom instructor-led virtual classroom or onsite training on a date that's convenient for you.

Copyright 2023 Avantix ® Learning

You may also like

How to Generate Random Text in Word

If you are creating a Microsoft Word document, template or mockup and you want to create placeholder text, you can generate random text using the built-in RAND function or LOREM function (which generates Latin or Lorem ipsum text).

How to Center Text Vertically in a Word Table (and Fix Common Issues)

You can center or align text vertically in cells in a Word table using commands in the Table Design or Table Tools Design tab in the Ribbon. If the text doesn't seem to align correctly, there are several common issues that may be affecting the alignment including extra blank paragraphs, paragraph spacing and cell margins.

How to Insert a Watermark in Word (like DRAFT)

You can insert a watermark in the background of one or more pages in a Microsoft Word document. Common watermarks are text such as DRAFT or CONFIDENTIAL but you can also add a picture watermark.

Microsoft, the Microsoft logo, Microsoft Office and related Microsoft applications and logos are registered trademarks of Microsoft Corporation in Canada, US and other countries. All other trademarks are the property of the registered owners.

Avantix Learning |18 King Street East, Suite 1400, Toronto, Ontario, Canada M5C 1C4 | Contact us at [email protected]

Our Courses

Avantix Learning courses are offered online in virtual classroom format or as in-person classroom training. Our hands-on, instructor-led courses are available both as public scheduled courses or on demand as a custom training solution.

All Avantix Learning courses include a comprehensive course manual including tips, tricks and shortcuts as well as sample and exercise files.

VIEW COURSES  >

Contact us at  [email protected]  for more information about any of our courses or to arrange custom training.

Privacy Overview

Pin it on pinterest.

• Print Friendly

Is your WordPress site slow? Get a free audit to uncover performance bottlenecks.

Advanced Custom Fields Tutorial: Your Ultimate Guide

WordPress custom fields are an important part of what makes WordPress a flexible content management system , rather than “ just a blogging platform “.

When it comes to WordPress custom fields, the freemium Advanced Custom Fields plugin is one of the most well-known names. It makes it easier to work with custom fields in all aspects, and it’s also the topic of our post today.

Specifically, we’ll explain why Advanced Custom Fields is so valuable and then show you step-by-step how you can apply it to your WordPress site.

There’s a lot to cover, so let’s dive in…

What Are WordPress Custom Fields? What Do They Let You Do?

WordPress custom fields let you add, store, and display additional information about a piece of content in WordPress. On a more technical level, custom fields help you store metadata.

Even if you’re not familiar with this term, custom fields power much of the functionality in your favorite plugins and themes.

For example, WooCommerce , the most popular way to build an eCommerce store, uses custom fields to store additional information about a product like:

Or, if you have a WordPress event calendar plugin , that plugin will use custom fields to store extra information about an event such as:

• Start/end time

You can also create your own custom fields to store information that’s relevant to your unique needs, which is what this entire post is about.

When Should You Use Custom Fields?

Now, you might be wondering why you even need custom fields in the first place.

For example, if you want to post an event on your WordPress site, couldn’t you just put all that information as regular text in the WordPress editor?

Well, yes, you could. But using custom fields is a better approach for a few reasons:

• Easier input — rather than typing things from scratch, a well-laid out custom field group will make it much easier to input data. For example, instead of typing a date, you can just select the date from a date picker.
• Consistency — the information you enter in your custom fields will always display according to your setup, which means it’ll be consistent across your entire site.
• Easy updates and maintenance — if you want to change something about how that information displays in the future, you can just update one thing rather than having to edit each post individually.

WordPress Includes Built-In Custom Fields Functionality

WordPress actually includes built-in functionality for adding custom fields to your content. In the classic TinyMCE editor , you can enable this from the Screen Options area. Or, in the new block editor , you can enable it from the Options area:

You can then enter your custom field data using key/value pairs:

This native custom fields functionality is totally functional, but it’s not the most user-friendly way to do things, which is why a lot of people turn to the Advanced Custom Fields plugin instead.

Advanced Custom Fields Makes It a Lot Easier

Put simply, Advanced Custom Fields makes it a lot easier to work with custom fields in WordPress in… pretty much all aspects.

It simplifies the interface for adding and managing custom fields in your WordPress dashboard and it also simplifies the process for displaying information from custom fields on the frontend of your site. That fact only helps explain why it’s active on more than 1 million websites with a 4.9-star rating on over 1,000 reviews .

On the backend, it will let you create user-friendly meta boxes that include pre-selected field types. So, rather than that generic key-value pair interface (like those you saw above), you’ll be able to use date pickers, checkboxes, and more like this:

In total, Advanced Custom Fields offers 30+ different field types that you can add to any area in your dashboard, including posts, users, taxonomies, media, comments, and even custom options pages.

You can view detailed information about each field type here .

Advanced Custom Fields also makes it a lot easier to display that information, with well-documented functions, shortcodes, Gutenberg blocks, and more.

Or, you can find integrations with other tools, like some drag-and-drop WordPress page builders .

Advanced Custom Fields Free vs Pro: Which One Do You Need?

Advanced Custom Fields comes both in a free as well as an affordable premium version.

For most basic uses, the free version is completely fine. It gives you access to almost all the field types, as well as all the time-saving and user-friendly features outlined above.

If you just want to store some extra information about your content, the free version is all you need.

With that being said, the Pro version does add some pretty convenient features that help you use Advanced Custom Fields in more interesting ways:

• Repeater fields — these let you repeat certain fields/groups of fields on a post-by-post basis. For example, if you were adding information about a speaker to an event, a repeater field would help you handle the situation where there’s more than one speaker ( you could just “repeat” the field(s) for the speaker as many times as needed, which lets you handle edge cases where there are multiple speakers ).
• ACF blocks — display your fields as a block Gutenberg, rather than a meta box. This is especially convenient if you’re building a site for a client and want to give them an easy way to input and visualize custom field data.
• Flexible content field — create layouts from other fields. It’s kind of like a lightweight page builder based on custom field information.
• Gallery field — upload multiple images to a single field.

There are also some other differences, like options pages, the ability to clone fields, improvements to the relationship fields, and other smaller tweaks.

You can see all the ACF PRO features here .

ACF PRO starts at $49 for yearly use on a single site, $149 yearly for use on 10 sites, and $249 yearly for use on unlimited sites.

When in doubt, start with the free version until you figure out exactly what functionality you need. You can always upgrade later if needed.

Advanced Custom Fields Tutorial: How to Add Your Fields

Let’s now dig into the actual Advanced Custom Fields tutorial and I’ll show you how to create and display your first set of custom fields.

For this example, let’s say you have a blog about running. You’re like…really into running and you want to share your day-to-day workouts with your readers. Specifically, with each blog post, you want to share a run’s:

• Purpose — let’s say you have two different types of running: “speed work” and “conditioning”.
• Distance — how long your run was.
• Start Time — when you started your run.
• Finish Time — when you finished your run.
• Location — where your run took place.

To collect that information, you’ll want to add five custom fields.

It’s important to note that the principles you’ll learn in this Advanced Custom Fields tutorial apply to any use case. We’re just picking a specific example because it helps to have a tangible example to connect to.

We’ll break this tutorial into two parts:

• How to add and manage your custom fields on the backend.
• How to display custom field information on the frontend of your site.

1. Create a New Field Group

Once you’ve installed and activated the free version of Advanced Custom Fields from WordPress.org , go to Custom Fields > Add New to create your first Field Group .

As the name suggests, a “Field Group” is a group of one or more custom fields that are displayed together in your WordPress dashboard .

For this example, you’ll create one field group that contains five custom fields.

Give your field group a name, and then choose its Location . For this example, we want to display these custom fields for regular WordPress blog posts, so you can leave it as the default Post .

However, if you want to display your custom fields elsewhere, like alongside a custom post type or with a taxonomy, you’d want to change this. You can also set up multiple rules to display your fields in multiple locations:

2. Add Custom Fields

Next, click the + Add Field button to add your first custom field:

This will open a lot of options, but you don’t necessarily need to fill out everything.

The two most important choices are:

• Field Label — this is what will appear in the editor. It will also be used to generate the Field Name, which is what you’ll use in code. You don’t need to change the field name (though you can if you need to).
• Field Type — this is the type of information you want to collect. For example, you’d want a Number field to collect number information or an Email field to collect an email address.

For this first field, you’d want a Radio Button field type:

Further down, you can enter the radio button selection options in the Choices box:

There are also a number of other choices you can make, like whether or not a field is required and a default value. Feel free to configure these to your needs.

Let’s look at another example: a custom field to collect the distance of the run. This time, you’d want a Number field type:

You could also make things a little more user-friendly by opting to Append the distance unit. And if you want, you could also add validation with a Minimum Value and Maximum Value . For example, you’re probably not going on 1,000-mile runs (and if you do… OMG, you’re the ultimate Forrest Gump)!

Just repeat the process for all the other custom fields you want to collect. When done, it should look something like this:

3. Configure Settings and Publish

To finish things out, scroll down to the Settings box. Here, you can control how your fields display in the WordPress editor .

Most of the time, you can leave these as the defaults. But feel free to change things up if you want. For example, you could opt to display your custom fields above the regular WordPress editor:

Once you’ve made your choices, Publish your field group to make it live.

4. Add Some Information in the WordPress Editor

Once you’ve published your field group, you’ll see your fields appear when you go to create a new post.

By default, they’ll appear together underneath the editor in both the classic TinyMCE editor and the new block editor:

The information you enter here will be stored in your site’s WordPress database for easy retrieval (you’ll see that in the next part of our Advanced Custom Fields tutorial).

Exploring Conditional Logic

Before we move forward, let’s take a quick detour.

See, one of the reasons why Advanced Custom Fields is so popular is because of all the interesting implementations it allows.

And one powerful option here is Conditional Logic , which lets you show/hide fields based on how a previous field was answered.

Let’s look at a quick example of how this works…

Let’s say that you want to blog about food , your travels , or anything other than running. When you’re writing about a non-run topic, it doesn’t make much sense to display the custom fields for information about the run, right?

What if, instead of automatically displaying all the custom fields you just created, you could add a custom field that says “Is this post a run?”:

If you check the box, then the run information fields automatically appear. If you leave it unchecked, they stay hidden:

That’s what conditional logic allows you to do!

To set this up, you would edit your field group and add a new True / False field for “Is this a run?”:

Then, you would edit the existing fields and turn on Conditional Logic so that each field only displays when the “Is this a run?” field is checked:

How to Display Advanced Custom Fields on the Frontend

Ok, we’re halfway through our Advanced Custom Fields journey. You’re now able to add information to your custom fields, associate it with the relevant post type, and store it in your database.

However, there’s still one potential problem: the information from your custom fields doesn’t appear anywhere on the frontend yet!

That is, even though you’ve added some custom fields to the editor for your blog posts, your blog post still just looks like a normal blog post on the frontend:

Let’s fix that.

There are a few different ways you can display Advanced Custom Fields data on the frontend of your site. The exact method you choose will depend on your needs and knowledge level. Here are three different ways to achieve that:

• Your theme’s template files — this requires a little technical knowledge, but it’s the best approach most of the time, especially if you’re comfortable working in your theme’s template files.
• With a shortcode — this is super simple and a good option if you just want to insert custom field data on a case-by-case basis. However, it requires a lot more manual work because you’ll need to add shortcodes to every post.
• With Elementor Pro — this is great because it completely eliminates the need to work with PHP, but it’s a premium product and it also means you’ll need to use Elementor Pro for your templating.

You can click above to jump straight to a specific method or you can read through all of them. Up to you.

How to Add Advanced Custom Fields in Theme Template Files

The first way to display your custom field information is to add Advanced Custom Fields’ PHP functions directly to your child theme’s template files .

This is a little advanced because it requires you to dig into your theme’s template files, but it ensures that your custom fields will automatically display in the same spot every time.

Specifically, you’ll need to edit the single template for the post type in question.

For a regular blog post, this is single.php . Or, some themes break things up into template parts. For example, for the TwentyNineteen theme , you actually need to edit the content-single.php template part.

If you’re feeling lost here, you might want to use a different method.

Once you’ve found the theme template file for your single post, you can use Advanced Custom Fields’ the_field() function to display a field’s information. For example,

Learn more here about it.

For example, to display the “Purpose” field, you’d use

You can find the field name when you edit a field group:

So, combining a little HTML markup with the PHP, you might get something like this to display all the fields:

To add this above the regular post content, you’d add this to your theme template file above the_content() :

And now, after refreshing the blog post, you can see the custom field data above the regular WordPress content:

To learn more, check out Advanced Custom Fields’ full documentation .

How to Display Advanced Custom Fields Data with a Shortcode

For a much simpler way to display your custom fields’ data, you can also use shortcodes. The downside here, though, is that you’ll need to add the shortcode every single time you want to display a custom field. There’s no easy way to automate this task.

The shortcode is this:

For example, if you entered this in the WordPress editor:

Then, the frontend of your site would look exactly the same as the previous theme template method:

How to Display Advanced Custom Fields with Elementor Pro

Elementor is one of the most popular WordPress page builders . It lets you build your designs using visual, drag-and-drop editing. On a sidenote, Elementor is one of Kinsta’s official partners .

With Elementor Pro, the paid add-on, you can also build your theme’s template files, including an option to insert dynamic custom field data from Advanced Custom Fields into your designs.

This is a great option if you want the flexibility to automatically include custom field data in your templates, but don’t feel comfortable making direct code edits to your theme’s template files.

To get started, you’d go to Templates > Theme Builder and create a new Elementor template for your post Single:

You could add the regular Elementor widgets for your Post Title and Post Content . Then, to display the custom field data, you’d add regular Text Editor widgets. The only difference here, instead of editing the text, you’d select the Dynamic option:

After this, you can select ACF Field from the drop-down:

From there, you can select the specific field you added with Advanced Custom Fields:

And you can also use the Advanced accordion tab to prepend or append information, which lets you add labels and units:

Easy, right? Now just repeat for other custom fields!

Using Advanced Custom Fields, you can enrich your pages and blog posts with more data and information with an easy-to-use solution. More: you can start to collect additional information for any content on your site and then display it on the frontend for your visitors.

To do that, you have 3 options:

• Your theme’s template files
• With a shortcode
• With Elementor Pro

The knowledge you’ve gained in this post will let you unlock the deep potential of WordPress to build 100% custom sites that go far beyond WordPress’ blogging roots.

The only question left is this:

What will you create with Advanced Custom Fields? Share it with us in the comments below

Head of Content at Kinsta and Content Marketing Consultant for WordPress plugin developers. Connect with Matteo on Twitter .

Related Articles and Topics

WordPress Custom Post Types: The All-In-One Guide to Create and Use Them

How to Create a Child Theme in WordPress (Extended Guide)

I’m surprised there is only a tiny mention of CPT’s ? As they are a fundamental WP feature to tailor the use of custom fields, it seems odd to not include details of their use. But other than that, a great article, well done!

Hey Dave, we didn’t go in too many details as I wanted to keep the focus on ACF. Anyway, I linked to our phenomenal guide on Custom Post Types for those who’d like to really learn more about them. You should check it out!

Thanks for your kind words!

Excellent post, Matteo!

As an avid ACF Pro user and WP engineer, I can tell you that this plugin is essential to our stack. The pro license is a no-brainer, and in reality, Elliot should charge MUCH more for it. Custom fields combined with custom post_type modeling is the foundation for solid WP development and content architecture.

Glad to see you sharing content like this over at Kinsta :)

Hey Ali, yeah, I agree with you! ACF is really an awesome plugin that allows developers (or advanced users) to really enhance and customize their product/pages in many ways.

Thanks for sharing your comment! 🙂🙏

Nice guide! ACF (pro) has block support now, so you can dispense with shortcodes and metaboxes by generating Gutenblocks for your custom fields.

Hey Dan, yep, it’s really a powerful plugin. Props to Elliot!

Some developers may prefer OOP and strong typing. ACF can be wrapped to achieve that! See https://github.com/szepeviktor/acf-get

Is there a security vulnerability in allowing php to be entered in fields?

ie Purpose:

Post authors can add this, we’ve got a directory with listings using ACF and it seems like it would be a vulnerability. I’m having trouble finding instructions on how to sanitize/prevent for non-admin to enter php

Hi, I’m confused about how the acf block works compared to the standard custom fields. If I create a field group with various fields I can then link that group with a particular post, page, post type etc, then I can add that data to the template that type uses where I want it. With the blocks you link the field group to a block that has it’s own template, so how can you then link that block to a particular post type or page template etc and ensure that the block is rendered in the correct place in that template, or don’t they work that way?

Hi, it was a nice tutorial over all BUT would like to know a bit about why we can’t use acf non-text widgets like FILE with Elementor, or am I missing something?

I just can’t see this type of acf fields in the field group when creating any template with Elementor Pro?

Leave a Reply Cancel reply

By submitting this form: You agree to the processing of the submitted personal data in accordance with Kinsta's Privacy Policy , including the transfer of data to the United States.

You also agree to receive information from Kinsta related to our services, events, and promotions. You may unsubscribe at any time by following the instructions in the communications received.

What Are Custom Fields In WordPress?

Table of contents.

Custom fields are a WordPress feature that enables users to add information when writing a post. WordPress stores this information as metadata. Users can then display the metadata by using template tags in their WordPress themes. 

Essentially, custom fields allow users to hold extra information related to pages or blogs they are editing, custom post types, or taxonomies (like tags and categories).

How Do Custom Fields Work?

By default, when you write any content type, WordPress saves it into two areas. The first is in the body of the content you add using the post editor. The second is the information about that particular content – for example, title, author, date, time, and more. This part of the post is called metadata.

WordPress automatically adds built-in custom fields to each post or page you create. By default, the option is hidden on the post edit screen. To display your custom field on the site’s front-end, so it’s not just sitting in your database, you need to edit your WordPress theme files. Alternatively, there are dedicated custom field plugins like Elementor Pro and its dynamic content feature. This lets you display the information quickly and requires no code. 

Custom Fields Use Cases

Custom Fields can be used in many ways. 

• For instance, when creating a WordPress eCommerce store, you will need to collect a great deal of data on your products. For example: 
• Stock status

Customs Fields allow you to store that extra metadata to display your products correctly at the front-end of your store. 

• Another use case would be creating a real estate site . The site will include data-filled listings such as:
• Square footage

You could add a custom field for each piece of data to enter fluidly in the back-end editor and then automatically display it on the front-end.

• If you are building a restaurant site , custom fields can effortlessly create and maintain a menu by collecting information such as:
• A dish’s price
• Relevant dietary concerns (for example, you could add checkboxes to indicate if a meal is gluten-free or vegan)

Every time you publish a new dish, it will automatically appear on the menu in the proper format.

Put simply, custom fields are vital to unlocking the power of WordPress as a complete content management system.

Recommended From Elementor

What is kubernetes.

Kubernetes is an open-source, extensible, portable platform that automates software management, deployment, and scaling of containerized services and workloads

What is Hosting Bandwidth?

Bandwidth in website hosting is the quantity of data a site can transfer to its users in a particular timeframe

What is a Web Host Manager?

A Web Host Manager (WHM) is cPanel’s web application providing customers with administrative control of their Dedicated Virtual Private Server

What is Domain Privacy?

Domain privacy protection is a service that keeps contact information anonymous by replacing authentic contact details with those of the privacy service and randomly generated email addresses.

What Are DNS Record Types?

Every website starts with a domain and a name. A record must verify that the domain has an IP address when you acquire these. The

What Is DNS Propagation?

DNS propagation is the time taken for changes to a Domain Name Server (DNS) update to disseminate across the internet

The Future of Web Creation. Straight to Your Inbox.

What Intrests You?

Search code, repositories, users, issues, pull requests...

Provide feedback.

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly.

To see all available qualifiers, see our documentation .

• Notifications

Using Custom Fields

This page is describing the functionality of the current Marketing Campaigns experience. If you're using legacy Marketing Campaigns, your workflow and screens may be a little different. Learn more about migrating from legacy Marketing Campaigns here .

Custom Fields allow you to add extra information about a contact within your contact database when you upload a CSV. You can use custom fields to create dynamic segments or to personalize the subject lines or content of Marketing Campaigns emails you send. Your custom fields are completely customizable to the use cases and user information that you need.

You can create up to 500 custom fields.

Creating Custom Fields

To add a custom field:

The most common way to add custom fields is by including each custom field you’d like to add as a column in your CSV upload . If you’d like to add custom fields programmatically, see our API documentation

You can also add custom fields manually from the Custom Fields page.

• Navigate to the Custom Fields page and click New Custom Field .
• Add a Field Name and select a Field Type .
• Click Create Field .

The field name should be created using only alphanumeric characters (A-Z and 0-9) and underscores (_). Custom fields should only begin with letters A-Z or underscores (_). The field type can be date , text , or number fields. The field type is important for creating segments from your contact database. Note: If you have created a custom field that begins with a number, you will need to recreate it with a name that begins with letters A-Z or an underscore (_).

Custom fields that begin with a number will cause issues when sending with Marketing Campaigns.

You can create three different types of custom fields, based on the data type. Each data type will allow you to use different queries for segmentation:

• Date - allows you to select contacts before, after, or on a specific date. Example: 1/1/2014
• Text - allows you to select contacts who match the specific text. Example: Pet field that says "Dog"
• Number - allows you to do things like “greater than,” “less than,” or “equals” a specific number. Both decimal and integer values are accepted. Example: The age of your recipient: 27

Text custom fields are limited to 1,000 characters.

Reserved Fields

Your account comes preloaded with unremovable reserved fields. The following field names are all reserved:

SendGrid auto-populates 6 reserved fields:

last_emailed

last_clicked

last_opened

Reserved fields are used by default to track useful metrics for your contacts.

Deleting a Custom Field

To delete a custom field:

• Navigate to Marketing and select Custom Fields .
• Locate the field you wish to remove.
• Hover over the action menu to the right of the field name entry.
• Select the delete icon.
• Click Delete Field .

This deletion process may take several minutes; you will continue to see the custom field on this page until the process completes.

Deleting a custom field deletes all values for that field across your contact database. It will also break Single Sends or Automation emails using the custom field as a tag or segments using the field as a condition. See below for details.

If a deleted custom field is used as a tag within a Single Send or Automation email as part of the subject line or body copy, the email will send with the default value you've designated or the fall back "default". If you have deleted the fallback, the email will not display anything at all in place of the deleted custom field.

If a deleted custom field is used as criteria within a segment the segment will fail to load. Neither Single Sends nor Automation emails will be able to be sent to the segment using the deleted custom field.

Troubleshooting

If a custom field value does not appear in the corresponding Substitution Tag , make sure that there is a value for that custom field associated with the contact in your contact database. If there is no value for a particular custom field, a space will be substituted instead.

If you do find that the custom field has an associated value on the contact’s profile page, check the spelling of the substitution tag in the content of your campaign.

Additional Resources

• Substitution Tags
• Segmenting your Contacts

Need some help?

We all do sometimes. Get help now from the Twilio SendGrid Support Team .

Running into a coding hurdle? Lean on the wisdom of the crowd by browsing the SendGrid tag on Stack Overflow or visiting Twilio's Stack Overflow Collective .

Thank you for your feedback!

Please select the reason(s) for your feedback. The additional information you provide helps us improve our documentation:

Need help? Talk to Support

Thanks for your feedback.

How to Add Custom Fields to Your WordPress Posts

As you become comfortable with WordPress, you may want to start pushing its boundaries. This means experimenting with some of the platform’s more advanced options, which includes learning how to create custom fields.

Adding a custom field to your WordPress post enables you to assign extra data to it. In turn, this helps you add specific information or features only to particular posts. As an example, you could use a custom field to tell WordPress which of your posts are sponsored, then add some code to your theme file that will display a disclosure statement only on those posts.

Get Content Delivered Straight to Your Inbox

Subscribe to our blog and receive great content just like this delivered straight to your inbox.

An Introduction to Custom Fields

The WordPress Block Editor is pretty flexible by default and enables you to customize your content to the Nth degree. You can add just about anything you like to your posts. However, the more content you have, the more you may start wishing for better ways to organize and manage it.

Custom fields are a somewhat more advanced WordPress feature that lets you add extra information to specific posts. That information is called ‘metadata’. Custom fields and metadata are of particular use to developers, who can use them to extend posts with all sorts of additional coding. However, they can still be beneficial for the more general WordPress users.

For example, let’s say you wanted to indicate which of the posts on your blog are sponsored to ensure you’re being transparent with your audience. You could add a short disclosure statement to each relevant post individually. Alternatively, you could save time by using a custom field that displays a relevant message. Then, you could add code to your theme file to make your disclosure statement appear on the correct posts.

If this sounds complex, don’t worry. Using custom fields is more straightforward than it looks. In fact, we’ll show you exactly how to implement this example below. If you’re interested in other potential applications for custom fields and metadata, you may also want to check out the WordPress Codex entry on the topic.

How to Add Custom Fields to Your WordPress Posts (In 2 Steps)

The concept of custom fields might seem a bit abstract, so let’s walk through an example to see exactly how this feature works in action. This general custom field process can be used for a wide variety of applications. You could add status updates to your posts, include a disclosure notice on sponsored content, and much more.

However, you’ll first want to take a moment and back up your website . If you’re following these instructions, you’ll be implementing changes to your theme’s primary file, and you don’t want to risk making any permanent mistakes. For extra security, creating a child theme and using it instead of your base theme is also advisable.

Step 1: Enable Custom Fields and Assign New Metadata to Your Post

The first thing you’ll need to do is open up a post to which you would like to add a custom field. It can be an old post or a new one.

Click on the three dots in the top right corner and select Preferences from the dropdown list:

Then, select Panels from the popup menu and enable Custom fields . You’ll now be prompted to Enable & Reload :

Now, if you scroll down below the post, you’ll find a new section:

Under Name and Value , you’ll add some metadata describing the information you want to add to this post. Depending on the themes and plugins you have installed, you may already have some options listed under Name . Regardless, you’ll want to create new metadata in this instance.

Choose a name for your metadata. It can be anything, although it’s best to keep it short and descriptive. Continuing our example from above about displaying a disclosure statement on specific posts, we’ll call it Sponsored Post . Then we’ll add a simple “Yes” to the Value box, indicating that this particular post is sponsored:

Click on Add Custom Field , and this metadata will now be assigned to your post. Don’t forget to save or update the post itself too.

Step 2: Add Conditional Code to Your Theme File

The previous step told WordPress a critical piece of information about your post: whether or not it is sponsored content. Now, you need to add directions so that your site knows what to do about that. As we mentioned earlier, this does involve a bit of coding. However, don’t let that scare you off. Even if you aren’t a developer, you should find the process relatively straightforward.

Within WordPress, you’ll want to navigate to Tools > Theme File Editor . Here, you can look through and make changes to the files that make up your site. You’ll want to check out the sidebar on the right-hand side and find the Single Post file (also known as single.php ):

This is where you’ll add the code that will tell WordPress what to do in response to your custom fields. The exact code you’ll use will vary somewhat, depending on what you want to do. In our example, you’d want to add this snippet :

Then, click on the Update File button. This code tells WordPress to check and see if a post has the Sponsored Post custom field and if the value is set to “Yes”. If so, it will display the message. If there is no custom field or the Sponsored Post value is set to “No”, nothing extra will be added to the post.

Also, where you place the code will determine when it appears in the post. For example, to get it to appear at the top of the page, you would add it before this line in the single.php file:

Hopefully, you are beginning to see how custom fields can be useful. There are a lot of possibilities when using this feature, so don’t be afraid to play around a little and see what you can accomplish with it.

Using Plugins to Manage Your Custom Fields

You now know how to add custom fields and metadata to your WordPress posts. However, what if you want to get more flexibility from this feature or just want to simplify the process?

This is WordPress we’re talking about, so of course, there are plugins that can help you out. There may not be a lot of plugins related to custom fields, but you can find a few quality options. For a great example, check out Advanced Custom Fields :

This very popular, free plugin streamlines the process of adding custom fields to WordPress. It also gives you more choices for where metadata can be added, such as users, media, and comments. Finally, it adds tools to provide more options for displaying custom field values within your theme files. There’s even a premium version with even more functionality.

If that plugin seems like overkill — and it can be for non-developers — Custom Field Suite is a solid alternative:

This tool is essentially a lightweight version of Advanced Custom Fields. It adds a handful of useful new custom field types to your site. Plus, it simplifies adding and managing custom fields without overwhelming you with too many new options.

This can be a smart plugin to start with if you’re looking to get more out of your custom fields. What’s more, you can always switch to a more robust solution once you feel more confident with the process.

Add Custom Fields to WordPress Content

Custom fields and metadata are concepts that might seem a smidge confusing at first. However, with time and patience, you’ll find that they enable you to get even more out of the WordPress platform.

Want a Free Theme?

When you host with DreamHost you get access to our WP Website Builder tool and more than 200+ industry-specific starter sites for free!

About the Author : Jason Cosper

Jason is DreamHost’s WordPress Product Advocate, based out of Bakersfield, CA. He is currently working on making our DreamPress product even better. In his free time, he likes to curl up on the couch and watch scary movies with his wife Sarah and three very small dogs. Follow him on Twitter .

Custom Fields

What are custom fields in wordpress.

WordPress custom fields represent a powerful and handy library of data associated with each piece of content on the site. This data can be drawn from either an internal or external source, allowing it to be reused in any format.

Custom fields can store information such as tags, text boxes, dates, drop-downs, videos, images, and more.

These values can then be extracted and used elsewhere in the website’s design. Content creators can use custom fields to offer additional meaning or context for their pieces that may otherwise go unnoticed by visitors.

They also provide a way for users to easily customize content to their needs without manually entering complex code. Ultimately, custom fields are invaluable for creating a dynamic and engaging website experience since they allow developers to structure the design however they want.

Custom fields provide more depth, detail, and variety than other forms of metadata and make content much easier to manage, given their flexibility and simplicity.

Whether you want to display specific values or offer visitors extra context, custom fields are crucial to setting up a WordPress site perfectly tailored to users’ needs.

How to Add Custom Fields to a Post or Page

Adding custom fields to a post or page in WordPress is a helpful way to display important information that otherwise wouldn’t be available.

• To get started, open the post or page you’d like to edit and select the Screen Options tab at the top right of your screen. This will reveal several fields which can be displayed on the page, including Custom Fields.
• Activate this field, and you’ll find yourself on the main screen with a Custom Fields box on the right side. Each custom field consists of two parts: a Name and a Value. The Name of your area should describe its contents (e.g., Product Number), while its Value should contain the corresponding information (e.g., 123456789).
• When you’re finished providing Names and Values for each field, click Add Custom Field and repeat until all necessary fields have been added. Once you hit Update at the bottom of the Page Editor or Publish at the top right if it’s a new post, those Custom Fields will be associated with that item in WordPress.

That’s all there is to it! With just a few clicks, you’ll be able to keep track of extra bits of information and seamlessly integrate them into any content type in WordPress – no additional code required!

How to Use Custom Fields on Your WordPress Site

Custom fields on your WordPress blog or site can be an invaluable asset for a website owner. Custom fields allow you to quickly add extra information about any page or post, such as date, author, category, etc.

For example, say you want to showcase individual posts within a specific category. You can easily do this by adding a custom field and specifying the type of posts that you want to show. This allows you to dynamically change and display content without manually coding it into each page or post.

In addition, creating custom fields opens up the possibility of creating more interactive websites by allowing visitors to sort content based on their specifications. Adding and using custom fields can initially seem intimidating, but with practice and determination, it can quickly become second nature.

Properly utilizing custom fields provides a wealth of flexibility by making data easier to analyze, assimilate and present efficiently, allowing for easy understanding and comprehension for website users.

Also, allowing for customized data sets makes managing information increasingly user-friendly which ultimately helps foster better connections between users and website owners.

Examples of How to Use Custom Fields on a WordPress Site

Custom fields are a versatile tool for adding additional content to WordPress sites. With custom fields, users can create specific sections in their posts, display metadata on a page, or store information without displaying it publicly.

• One way to use custom fields is to display event date and time information, allowing users to keep track of upcoming events in an organized and easily accessible manner.
• Custom fields can also be used as pricing tables when displaying multiple product options or services; this is helpful when setting up eCommerce stores or other businesses with various offerings.
• Additionally, custom fields help create additional variations within a single post; for instance, users may want to include long-form and short-form versions of the same article for different purposes.
• Similarly, recipe posts can contain variations of ingredients depending on the size of a dish or a user’s dietary restrictions.

Custom fields are a powerful tool for tailoring WordPress sites to individualized needs; they enable content curators to make data more accessible while maintaining the desired formatting.

The possibilities are endless!

By using custom fields thoughtfully, site owners can take control of their web pages and turn them into powerful tools that meet their unique requirements.

Related Posts

Leave a comment cancel reply.

Your email address will not be published. Required fields are marked *

Save my name, email, and website in this browser for the next time I comment.

Learn WordPress

Creating Custom Fields

Custom fields and add extra information to WordPress posts, pages and custom post types. This information can not only enhance the post but make it more sortable and searchable. This video will show you how to add fields in just a few minutes without using any code. For full context check out the Creating Custom Post Types tutorial first.

This Tutorial will show you how to do this using a plugin called Advanced Custom Fields – other options are also mentioned in the video.

Learning outcomes

• Understanding what custom fields are.
• Knowing how to create new custom fields.

Comprehension questions

• What are custom fields?
• How can I crate my own custom fields?

0:00 Hey folks, welcome to another HeroPress Tip of the Week.

0:03 This week, we’re going to talk about adding custom fields to our custom post types.

0:07 Last week, we talked about custom post types. And you can see what we made then – this is a staff post type. And I’ve entered Steve here. And there’s almost no difference between a custom post type and regular posts unless you make them different.

0:25 And right now, we haven’t made them different yet, we have a title and content is Gutenberg, that’s it.

0:31 One perk that you do get is, if you go to slash staff you get a custom archive of just staff. So your posts aren’t going to be in here, your pages aren’t going to be in here.

0:43 So this automatically makes a nice little staff listing.

0:49 But if we want to get really unique, we need to add some custom fields. So I’m going to show you how to do that.

0:57 There are a variety of ways to do it, you can write the code yourself, which isn’t that hard. There are wizards to help you. There are several libraries, there’s CMB2 , there’s Metabox.io and Advanced Custom Fields . I’m going to show you advanced custom fields because it is the simplest.

1:16 So let’s go to “Add New”, and search for Advanced Custom Fields. And it is right here. And you’ll note over here is ACF extended, that’s an add on, and it’s cool, but if you just get this thinking it’s better than this, it’s not gonna work because it requires this.

1:36 So grab Advanced Custom Fields. And we’ll activate…and now on the left here, you’ll see there’s a custom fields thing.

1:47 And fields go in field groups. And we don’t have any right now, so we’re going to add one. And we will call it “staff information”. And before we add fields right here, we want to show this if the post type is equal to “staff”.

2:10 And now it will show up on the staff page. There’s some other options here that you can mess with. I find that again, I like the defaults. So we’ll know we’re not going to go over those.

2:22 So we’re going to add a field…and we’re going to add “first name”. And the field name can be automatically generated from this I just clicked and it just did that our field type is going to be text – here are all the different field types. There are quite a few – you can do a lot of stuff here – we just want them to type in their first name.

2:50 We can make it required if we want. There’s placeholder text all that stuff, we don’t really need any of that we just need these first three things.

3:00 So I’m going to click a number. No, I’m gonna close that. At the bottom, go to close field.

3:10 And we’ll make a new one. We’ll make “last name”. Now you may ask why we’re making first and last name if his name is in the title.

3:19 That’s because you can’t sort by last name on a whole name in the title, where with this, you can sort by last name alphabetically.

3:29 So there’s “last name” and again text. And we will close this field. And we’ll put in a phone number.

3:44 See, is there a phone number in here…there’s not probably because it’d be too hard to do internationally. So we’ll leave that one to text as well.

3:56 So now we have three text fields in a group called staff information. So let’s go back to old Steve here and “edit”. And down at the bottom, you’ll see this box.

4:11 So we’ll put in Steve, there’s Wilson and phone number is 61655-1212 and hit “Update”. So now we have this information associated with Steve.

4:30 It does not automatically render on the front of the site. We’re going to have to do something to make that happen. And that’s going to be in next week’s tip.

4:41 So to review real quick, we used Advanced Custom Fields to quickly create some text fields here and we put the information in and hit “Update”. And I’ll even show you if you go to add a new one, they are empty.

4:57 So be sure to come back next week and I’ll show you how to make these appear on the front of the website.

5:04 I hope you find this useful

Workshop Details

• Length 5 mins
• Topic Dashboard
• Language English
• Subtitles English
• Transcript View
• Print View View

🚧 Public Applications Only The ServiceM8 Custom Fields API is only available to Public Applications . You will need to implement OAuth 2.0 Authentication and obtain an access token before you can use the Custom Fields API.

Custom fields allow you to add additional fields to the standard database schema per account.

ServiceM8 Custom Fields are commonly used for:

• Collecting additional job or client information
• Used in conjunction with Web Hooks to trigger workflows

When to Use Custom Fields

Our thoughts on custom fields are that they are inappropriate for most use cases. Custom fields slow down user data entry and complicate the user interface. Use them sparingly and only when you cannot innovate your way around using them. Custom fields will be applied to all Company/Job records you add them to – in the real world it’s likely only a subset of these records needed your custom field.

In most cases, storing the information in a Note or Photo is much easier, and should be preferred over custom fields unless there is a requirement to store the data in a structured format.

Supported Objects

Custom Fields are supported for the following object types:

Field Types

You can use any of the following field types when setting new custom fields:

Reading and Writing Custom Fields

After a Custom Field has been created via the Custom Fields API, you can read and write values for that field via the REST API . The field name specified when creating the custom field will be prefixed with customfield_ . So if you create a Custom Field with field_name = favourite_ice_cream , that field will be available on the REST API as customfield_favourite_ice_cream .

How to Use the Custom Fields API

Refer to the Custom Fields API Reference for details of the Custom Fields endpoint.

Updated over 4 years ago

• Popular Professionals
• Design & Planning
• Construction & Renovation
• Finishes & Fixtures
• Landscaping & Outdoor
• Systems & Appliances
• Interior Designers & Decorators
• Architects & Building Designers
• Design-Build Firms
• Kitchen & Bathroom Designers
• General Contractors
• Kitchen & Bathroom Remodelers
• Home Builders
• Roofing & Gutters
• Cabinets & Cabinetry
• Tile & Stone
• Hardwood Flooring Dealers
• Landscape Contractors
• Landscape Architects & Landscape Designers
• Home Stagers
• Swimming Pool Builders
• Lighting Designers and Suppliers
• 3D Rendering
• Sustainable Design
• Basement Design
• Architectural Design
• Universal Design
• Energy-Efficient Homes
• Multigenerational Homes
• House Plans
• Home Remodeling
• Home Additions
• Green Building
• Garage Building
• New Home Construction
• Basement Remodeling
• Stair & Railing Contractors
• Cabinetry & Cabinet Makers
• Roofing & Gutter Contractors
• Window Contractors
• Exterior & Siding Contractors
• Carpet Contractors
• Carpet Installation
• Flooring Contractors
• Wood Floor Refinishing
• Tile Installation
• Custom Countertops
• Quartz Countertops
• Cabinet Refinishing
• Custom Bathroom Vanities
• Finish Carpentry
• Cabinet Repair
• Custom Windows
• Window Treatment Services
• Window Repair
• Fireplace Contractors
• Paint & Wall Covering Dealers
• Door Contractors
• Glass & Shower Door Contractors
• Landscape Construction
• Land Clearing
• Garden & Landscape Supplies
• Deck & Patio Builders
• Deck Repair
• Patio Design
• Stone, Pavers, & Concrete
• Paver Installation
• Driveway & Paving Contractors
• Driveway Repair
• Asphalt Paving
• Garage Door Repair
• Fence Contractors
• Fence Installation
• Gate Repair
• Pergola Construction
• Spa & Pool Maintenance
• Swimming Pool Contractors
• Hot Tub Installation
• HVAC Contractors
• Electricians
• Appliance Services
• Solar Energy Contractors
• Outdoor Lighting Installation
• Landscape Lighting Installation
• Outdoor Lighting & Audio/Visual Specialists
• Home Theater & Home Automation Services
• Handyman Services
• Closet Designers
• Professional Organizers
• Furniture & Accessories Retailers
• Furniture Repair & Upholstery Services
• Specialty Contractors
• Color Consulting
• Wine Cellar Designers & Builders
• Home Inspection
• Custom Artists
• Columbus, OH Painters
• New York City, NY Landscapers
• San Diego, CA Bathroom Remodelers
• Minneapolis, MN Architects
• Portland, OR Tile Installers
• Kansas City, MO Flooring Contractors
• Denver, CO Countertop Installers
• San Francisco, CA New Home Builders
• Rugs & Decor
• Home Improvement
• Kitchen & Tabletop
• Bathroom Vanities
• Bathroom Vanity Lighting
• Bathroom Mirrors
• Bathroom Fixtures
• Nightstands & Bedside Tables
• Kitchen & Dining
• Bar Stools & Counter Stools
• Dining Chairs
• Dining Tables
• Buffets and Sideboards
• Kitchen Fixtures
• Desks & Hutches
• Office Chairs
• Living Room
• Armchairs & Accent Chairs
• Coffee & Accent Tables
• Sofas & Sectionals
• Media Storage
• Patio & Outdoor Furniture
• Outdoor Lighting
• Ceiling Lighting
• Chandeliers
• Pendant Lighting
• Wall Sconces
• Wall Mirrors
• View All Products
• Side & End Tables
• Console Tables
• Living Room Sets
• Chaise Lounges
• Ottomans & Poufs
• Bedroom Furniture
• Nightstands
• Bedroom Sets
• Dining Room Sets
• Sideboards & Buffets
• File Cabinets
• Room Dividers
• Furniture Sale
• Trending in Furniture
• View All Furniture
• Bath Vanities
• Single Vanities
• Double Vanities
• Small Vanities
• Transitional Vanities
• Modern Vanities
• Houzz Curated Vanities
• Best Selling Vanities
• Bathroom Vanity Mirrors
• Medicine Cabinets
• Bathroom Faucets
• Bathroom Sinks
• Shower Doors
• Showerheads & Body Sprays
• Bathroom Accessories
• Bathroom Storage
• Trending in Bath
• View All Bath
• How to Choose a Bathroom Vanity

• Patio Furniture
• Outdoor Dining Furniture
• Outdoor Lounge Furniture
• Outdoor Chairs
• Adirondack Chairs
• Outdoor Bar Furniture
• Outdoor Benches
• Wall Lights & Sconces
• Outdoor Flush-Mounts
• Landscape Lighting
• Outdoor Flood & Spot Lights
• Outdoor Decor
• Outdoor Rugs
• Outdoor Cushions & Pillows
• Patio Umbrellas
• Lawn & Garden
• Garden Statues & Yard Art
• Planters & Pots
• Outdoor Sale
• Trending in Outdoor
• View All Outdoor
• 8 x 10 Rugs
• 9 x 12 Rugs
• Hall & Stair Runners
• Home Decor & Accents
• Pillows & Throws
• Decorative Storage
• Faux Florals
• Wall Panels
• Window Treatments
• Curtain Rods
• Blackout Curtains
• Blinds & Shades
• Rugs & Decor Sale
• Trending in Rugs & Decor
• View All Rugs & Decor
• Pendant Lights
• Flush-Mounts
• Ceiling Fans
• Track Lighting
• Wall Lighting
• Swing Arm Wall Lights
• Display Lighting
• Table Lamps
• Floor Lamps
• Lamp Shades
• Lighting Sale
• Trending in Lighting
• View All Lighting
• Bathroom Remodel
• Kitchen Remodel
• Kitchen Faucets
• Kitchen Sinks
• Major Kitchen Appliances
• Cabinet Hardware
• Backsplash Tile
• Mosaic Tile
• Wall & Floor Tile
• Accent, Trim & Border Tile
• Whole House Remodel
• Heating & Cooling
• Building Materials
• Front Doors
• Interior Doors
• Home Improvement Sale
• Trending in Home Improvement
• View All Home Improvement
• Cups & Glassware
• Kitchen & Table Linens
• Kitchen Storage and Org
• Kitchen Islands & Carts
• Food Containers & Canisters
• Pantry & Cabinet Organizers
• Kitchen Appliances
• Gas & Electric Ranges
• Range Hoods & Vents
• Beer & Wine Refrigerators
• Small Kitchen Appliances
• Cookware & Bakeware
• Tools & Gadgets
• Kitchen & Tabletop Sale
• Trending in Kitchen & Tabletop
• View All Kitchen & Tabletop
• Storage & Organization
• Baby & Kids
• Cleaning & Laundry
• Pet Supplies
• Black Friday Furniture Sale
• Black Friday Rugs Sale
• Black Friday Sofas Sale
• Black Friday Patio Furniture Sale

• View all photos
• Dining Room
• Breakfast Nook
• Family Room
• Bed & Bath
• Powder Room
• Storage & Closet
• Outdoor Kitchen
• Bar & Wine
• Wine Cellar
• Home Office
• Popular Design Ideas
• Kitchen Backsplash
• Deck Railing
• Privacy Fence
• Small Closet
• Stories and Guides
• Popular Stories
• Renovation Cost Guides
• Fence Installation Cost Guide
• Window Installation Cost Guide
• Discussions
• Design Dilemmas
• Before & After
• Houzz Research
• View all pros
• View all services
• View all products

• View all sales
• Living Room Chairs
• Dining Room Furniture
• Coffee Tables
• Home Office Furniture
• Join as a Pro
• Interior Design Software
• Project Management
• Custom Website
• Lead Generation
• Invoicing & Billing
• Landscape Contractor Software
• General Contractor Software
• Remodeler Software
• Builder Software
• Roofer Software
• Architect Software
• Takeoff Software
• Lumber & Framing Takeoffs
• Steel Takeoffs
• Concrete Takeoffs
• Drywall Takeoffs
• Insulation Takeoffs
• Stories & Guides
• LATEST FROM HOUZZ
• HOUZZ DISCUSSIONS
• SHOP KITCHEN & DINING
• Kitchen & Dining Furniture
• Sinks & Faucets
• Kitchen Cabinets & Storage
• Knobs & Pulls
• Kitchen Knives
• KITCHEN PHOTOS
• FIND KITCHEN PROS
• Bath Accessories
• Bath Linens
• BATH PHOTOS
• FIND BATH PROS
• SHOP BEDROOM
• Beds & Headboards
• Bedroom Decor
• Closet Storage
• Bedroom Vanities
• BEDROOM PHOTOS
• Kids' Room
• FIND DESIGN PROS
• SHOP LIVING
• Fireplaces & Accessories
• LIVING PHOTOS
• SHOP OUTDOOR
• Pool & Spa
• Backyard Play
• OUTDOOR PHOTOS
• FIND LANDSCAPING PROS
• SHOP LIGHTING
• Bathroom & Vanity
• Flush Mounts
• Kitchen & Cabinet
• Outdoor Wall Lights
• Outdoor Hanging Lights
• Kids' Lighting
• Decorative Accents
• Artificial Flowers & Plants
• Decorative Objects
• Screens & Room Dividers
• Wall Shelves
• About Houzz
• Houzz Credit Cards
• Privacy & Notice
• Cookie Policy
• Your Privacy Choices
• Mobile Apps
• Copyright & Trademark
• For Professionals
• Remodeling Software
• Floor Planner
• Contractor Leads
• Trade Program
• Buttons & Badges
• Your Orders
• Shipping & Delivery
• Return Policy
• Houzz Canada
• Review Professionals
• Suggested Professionals
• Accessibility
• Houzz Support
• COUNTRY COUNTRY

Custom Cabinet Makers in Elektrostal'

Location (1).

• Use My Current Location

Popular Locations

• Albuquerque
• Cedar Rapids
• Grand Rapids
• Indianapolis
• Jacksonville
• Kansas City
• Little Rock
• Los Angeles
• Minneapolis
• New Orleans
• Oklahoma City
• Orange County
• Philadelphia
• Portland Maine
• Salt Lake City
• San Francisco
• San Luis Obispo
• Santa Barbara
• Washington D.C.
• Elektrostal', Moscow Oblast, Russia

Featured Reviews for Custom Cabinet Makers in Elektrostal'

What does a cabinet maker near me do, questions to ask a prospective cabinet maker:, find cabinetry and custom cabinet makers near me on houzz, how do i find a local cabinets & cabinetry professional in elektrostal'.

• Reach out to the pro(s) you want, then share your vision to get the ball rolling.
• Request and compare quotes, then hire the Cabinets & Cabinetry professional that perfectly fits your project and budget limits.

What services do Cabinets & Cabinetry companies provide in Elektrostal'?

• Cabinet Installation
• Cabinet Refacing
• Custom Bookcases
• Custom Built-ins
• Custom Cabinet Doors
• Custom Cabinets

How many Cabinets & Cabinetry professionals are in Elektrostal'?

What are custom, semi-custom and prefab cabinets.

• Custom Cabinets – made to fit your specific kitchen, allowing complete customization. You can choose the materials, finishes, and features. Usually are of a higher quality. For example, for a small kitchen with limited space, custom cabinets can be designed to maximize storage and functionality. Contact a local professional in Elektrostal' to order the best cabinets for your kitchen.
• Semi-Custom Cabinets: – offer some customization options within pre-built standard sizes and styles. You can choose from a range of finishes, door styles, and accessories. For instance, you can select a specific color and add features like pull-out shelves or spice racks.
• Prefab (or Stock) Cabinets – pre-made and readily available in standard sizes, styles, and finishes. They are more affordable and convenient for quick installations. An example would be purchasing pre-assembled cabinets from a home improvement store to update your kitchen without any modifications.

Which is better – custom or prefab cabinets?

• Higher quality and craftsmanship
• More customization options available
• Allows for a personalized and unique kitchen design
• More expensive than prefab cabinets
• Longer production and installation time required
• More affordable option
• Suitable for budget-conscious or time-sensitive projects
• Limited customization options
• Generally lower overall quality compared to custom cabinets

BUSINESS SERVICES

Connect with us.

Claudia Looi

Touring the Top 10 Moscow Metro Stations

By Claudia Looi 2 Comments

Komsomolskaya metro station looks like a museum. It has vaulted ceilings and baroque decor.

Hidden underground, in the heart of Moscow, are historical and architectural treasures of Russia. These are Soviet-era creations – the metro stations of Moscow.

Our guide Maria introduced these elaborate metro stations as “the palaces for the people.” Built between 1937 and 1955, each station holds its own history and stories. Stalin had the idea of building beautiful underground spaces that the masses could enjoy. They would look like museums, art centers, concert halls, palaces and churches. Each would have a different theme. None would be alike.

The two-hour private tour was with a former Intourist tour guide named Maria. Maria lived in Moscow all her life and through the communist era of 60s to 90s. She has been a tour guide for more than 30 years. Being in her 60s, she moved rather quickly for her age. We traveled and crammed with Maria and other Muscovites on the metro to visit 10 different metro stations.

Arrow showing the direction of metro line 1 and 2

Moscow subways are very clean

To Maria, every street, metro and building told a story. I couldn’t keep up with her stories. I don’t remember most of what she said because I was just thrilled being in Moscow.   Added to that, she spilled out so many Russian words and names, which to one who can’t read Cyrillic, sounded so foreign and could be easily forgotten.

The metro tour was the first part of our all day tour of Moscow with Maria. Here are the stations we visited:

1. Komsomolskaya Metro Station  is the most beautiful of them all. Painted yellow and decorated with chandeliers, gold leaves and semi precious stones, the station looks like a stately museum. And possibly decorated like a palace. I saw Komsomolskaya first, before the rest of the stations upon arrival in Moscow by train from St. Petersburg.

2. Revolution Square Metro Station (Ploshchad Revolyutsii) has marble arches and 72 bronze sculptures designed by Alexey Dushkin. The marble arches are flanked by the bronze sculptures. If you look closely you will see passersby touching the bronze dog's nose. Legend has it that good luck comes to those who touch the dog's nose.

Touch the dog's nose for good luck. At the Revolution Square station

Revolution Square Metro Station

3. Arbatskaya Metro Station served as a shelter during the Soviet-era. It is one of the largest and the deepest metro stations in Moscow.

Arbatskaya Metro Station

4. Biblioteka Imeni Lenina Metro Station was built in 1935 and named after the Russian State Library. It is located near the library and has a big mosaic portrait of Lenin and yellow ceramic tiles on the track walls.

Lenin's portrait at the Biblioteka Imeni Lenina Metro Station

5. Kievskaya Metro Station was one of the first to be completed in Moscow. Named after the capital city of Ukraine by Kiev-born, Nikita Khruschev, Stalin's successor.

Kievskaya Metro Station

6. Novoslobodskaya Metro Station  was built in 1952. It has 32 stained glass murals with brass borders.

Novoslobodskaya metro station

7. Kurskaya Metro Station was one of the first few to be built in Moscow in 1938. It has ceiling panels and artwork showing Soviet leadership, Soviet lifestyle and political power. It has a dome with patriotic slogans decorated with red stars representing the Soviet's World War II Hall of Fame. Kurskaya Metro Station is a must-visit station in Moscow.

Ceiling panel and artworks at Kurskaya Metro Station

8. Mayakovskaya Metro Station built in 1938. It was named after Russian poet Vladmir Mayakovsky. This is one of the most beautiful metro stations in the world with 34 mosaics painted by Alexander Deyneka.

Mayakovskaya station

One of the over 30 ceiling mosaics in Mayakovskaya metro station

9. Belorusskaya Metro Station is named after the people of Belarus. In the picture below, there are statues of 3 members of the Partisan Resistance in Belarus during World War II. The statues were sculpted by Sergei Orlov, S. Rabinovich and I. Slonim.

10. Teatralnaya Metro Station (Theatre Metro Station) is located near the Bolshoi Theatre.

Teatralnaya Metro Station decorated with porcelain figures .

Taking the metro's escalator at the end of the tour with Maria the tour guide.

Have you visited the Moscow Metro? Leave your comment below.

January 15, 2017 at 8:17 am

An excellent read! Thanks for much for sharing the Russian metro system with us. We're heading to Moscow in April and exploring the metro stations were on our list and after reading your post, I'm even more excited to go visit them. Thanks again 🙂

December 6, 2017 at 10:45 pm

Hi, do you remember which tour company you contacted for this tour?

Leave a Reply Cancel reply

You must be logged in to post a comment.

Please go to the Instagram Feed settings page to create a feed.