diff --git a/phosphor-regulators/src/config_file_parser.cpp b/phosphor-regulators/src/config_file_parser.cpp
new file mode 100644
index 0000000..9ac6060
--- /dev/null
+++ b/phosphor-regulators/src/config_file_parser.cpp
@@ -0,0 +1,322 @@
+/**
+ * Copyright © 2020 IBM Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "config_file_parser.hpp"
+
+#include "config_file_parser_error.hpp"
+#include "pmbus_utils.hpp"
+
+#include <exception>
+#include <fstream>
+#include <optional>
+#include <utility>
+
+using json = nlohmann::json;
+
+namespace phosphor::power::regulators::config_file_parser
+{
+
+std::tuple<std::vector<std::unique_ptr<Rule>>,
+           std::vector<std::unique_ptr<Chassis>>>
+    parse(const std::filesystem::path& pathName)
+{
+    try
+    {
+        // Use standard JSON parser to create tree of JSON elements
+        std::ifstream file{pathName};
+        json rootElement = json::parse(file);
+
+        // Parse tree of JSON elements and return corresponding C++ objects
+        return internal::parseRoot(rootElement);
+    }
+    catch (const std::exception& e)
+    {
+        throw ConfigFileParserError{pathName, e.what()};
+    }
+}
+
+namespace internal
+{
+
+std::unique_ptr<Action> parseAction(const json& element)
+{
+    verifyIsObject(element);
+    unsigned int propertyCount{0};
+
+    // Optional comments property; value not stored
+    if (element.contains("comments"))
+    {
+        ++propertyCount;
+    }
+
+    // Required action type property; there must be exactly one specified
+    std::unique_ptr<Action> action{};
+    if (element.contains("and"))
+    {
+        // TODO: Not implemented yet
+        // action = parseAnd(element["and"]);
+        // ++propertyCount;
+    }
+    else if (element.contains("compare_presence"))
+    {
+        // TODO: Not implemented yet
+        // action = parseComparePresence(element["compare_presence"]);
+        // ++propertyCount;
+    }
+    else if (element.contains("compare_vpd"))
+    {
+        // TODO: Not implemented yet
+        // action = parseCompareVPD(element["compare_vpd"]);
+        // ++propertyCount;
+    }
+    else if (element.contains("i2c_compare_bit"))
+    {
+        // TODO: Not implemented yet
+        // action = parseI2CCompareBit(element["i2c_compare_bit"]);
+        // ++propertyCount;
+    }
+    else if (element.contains("i2c_compare_byte"))
+    {
+        // TODO: Not implemented yet
+        // action = parseI2CCompareByte(element["i2c_compare_byte"]);
+        // ++propertyCount;
+    }
+    else if (element.contains("i2c_compare_bytes"))
+    {
+        // TODO: Not implemented yet
+        // action = parseI2CCompareBytes(element["i2c_compare_bytes"]);
+        // ++propertyCount;
+    }
+    else if (element.contains("i2c_write_bit"))
+    {
+        // TODO: Not implemented yet
+        // action = parseI2CWriteBit(element["i2c_write_bit"]);
+        // ++propertyCount;
+    }
+    else if (element.contains("i2c_write_byte"))
+    {
+        // TODO: Not implemented yet
+        // action = parseI2CWriteByte(element["i2c_write_byte"]);
+        // ++propertyCount;
+    }
+    else if (element.contains("i2c_write_bytes"))
+    {
+        // TODO: Not implemented yet
+        // action = parseI2CWriteBytes(element["i2c_write_bytes"]);
+        // ++propertyCount;
+    }
+    else if (element.contains("if"))
+    {
+        // TODO: Not implemented yet
+        // action = parseIf(element["if"]);
+        // ++propertyCount;
+    }
+    else if (element.contains("not"))
+    {
+        // TODO: Not implemented yet
+        // action = parseNot(element["not"]);
+        // ++propertyCount;
+    }
+    else if (element.contains("or"))
+    {
+        // TODO: Not implemented yet
+        // action = parseOr(element["or"]);
+        // ++propertyCount;
+    }
+    else if (element.contains("pmbus_read_sensor"))
+    {
+        // TODO: Not implemented yet
+        // action = parsePMBusReadSensor(element["pmbus_read_sensor"]);
+        // ++propertyCount;
+    }
+    else if (element.contains("pmbus_write_vout_command"))
+    {
+        action =
+            parsePMBusWriteVoutCommand(element["pmbus_write_vout_command"]);
+        ++propertyCount;
+    }
+    else if (element.contains("run_rule"))
+    {
+        // TODO: Not implemented yet
+        // action = parseRunRule(element["run_rule"]);
+        // ++propertyCount;
+    }
+    else if (element.contains("set_device"))
+    {
+        // TODO: Not implemented yet
+        // action = parseSetDevice(element["set_device"]);
+        // ++propertyCount;
+    }
+    else
+    {
+        throw std::invalid_argument{"Required action type property missing"};
+    }
+
+    // Verify no invalid properties exist
+    verifyPropertyCount(element, propertyCount);
+
+    return action;
+}
+
+std::vector<std::unique_ptr<Action>> parseActionArray(const json& element)
+{
+    verifyIsArray(element);
+    std::vector<std::unique_ptr<Action>> actions;
+    for (auto& actionElement : element)
+    {
+        actions.emplace_back(parseAction(actionElement));
+    }
+    return actions;
+}
+
+std::vector<std::unique_ptr<Chassis>> parseChassisArray(const json& element)
+{
+    verifyIsArray(element);
+    std::vector<std::unique_ptr<Chassis>> chassis;
+    // TODO: Not implemented yet
+    // for (auto& chassisElement : element)
+    // {
+    //     chassis.emplace_back(parseChassis(chassisElement));
+    // }
+    return chassis;
+}
+
+std::unique_ptr<PMBusWriteVoutCommandAction>
+    parsePMBusWriteVoutCommand(const json& element)
+{
+    verifyIsObject(element);
+    unsigned int propertyCount{0};
+
+    // Optional volts property
+    std::optional<double> volts{};
+    auto voltsIt = element.find("volts");
+    if (voltsIt != element.end())
+    {
+        volts = parseDouble(*voltsIt);
+        ++propertyCount;
+    }
+
+    // Required format property
+    const json& formatElement = getRequiredProperty(element, "format");
+    std::string formatString = parseString(formatElement);
+    if (formatString != "linear")
+    {
+        throw std::invalid_argument{"Invalid format value: " + formatString};
+    }
+    pmbus_utils::VoutDataFormat format = pmbus_utils::VoutDataFormat::linear;
+    ++propertyCount;
+
+    // Optional exponent property
+    std::optional<int8_t> exponent{};
+    auto exponentIt = element.find("exponent");
+    if (exponentIt != element.end())
+    {
+        exponent = parseInt8(*exponentIt);
+        ++propertyCount;
+    }
+
+    // Optional is_verified property
+    bool isVerified = false;
+    auto isVerifiedIt = element.find("is_verified");
+    if (isVerifiedIt != element.end())
+    {
+        isVerified = parseBoolean(*isVerifiedIt);
+        ++propertyCount;
+    }
+
+    // Verify no invalid properties exist
+    verifyPropertyCount(element, propertyCount);
+
+    return std::make_unique<PMBusWriteVoutCommandAction>(volts, format,
+                                                         exponent, isVerified);
+}
+
+std::tuple<std::vector<std::unique_ptr<Rule>>,
+           std::vector<std::unique_ptr<Chassis>>>
+    parseRoot(const json& element)
+{
+    verifyIsObject(element);
+    unsigned int propertyCount{0};
+
+    // Optional comments property; value not stored
+    if (element.contains("comments"))
+    {
+        ++propertyCount;
+    }
+
+    // Optional rules property
+    std::vector<std::unique_ptr<Rule>> rules{};
+    auto rulesIt = element.find("rules");
+    if (rulesIt != element.end())
+    {
+        rules = parseRuleArray(*rulesIt);
+        ++propertyCount;
+    }
+
+    // Required chassis property
+    const json& chassisElement = getRequiredProperty(element, "chassis");
+    std::vector<std::unique_ptr<Chassis>> chassis =
+        parseChassisArray(chassisElement);
+    ++propertyCount;
+
+    // Verify no invalid properties exist
+    verifyPropertyCount(element, propertyCount);
+
+    return std::make_tuple(std::move(rules), std::move(chassis));
+}
+
+std::unique_ptr<Rule> parseRule(const json& element)
+{
+    verifyIsObject(element);
+    unsigned int propertyCount{0};
+
+    // Optional comments property; value not stored
+    if (element.contains("comments"))
+    {
+        ++propertyCount;
+    }
+
+    // Required id property
+    const json& idElement = getRequiredProperty(element, "id");
+    std::string id = parseString(idElement);
+    ++propertyCount;
+
+    // Required actions property
+    const json& actionsElement = getRequiredProperty(element, "actions");
+    std::vector<std::unique_ptr<Action>> actions =
+        parseActionArray(actionsElement);
+    ++propertyCount;
+
+    // Verify no invalid properties exist
+    verifyPropertyCount(element, propertyCount);
+
+    return std::make_unique<Rule>(id, std::move(actions));
+}
+
+std::vector<std::unique_ptr<Rule>> parseRuleArray(const json& element)
+{
+    verifyIsArray(element);
+    std::vector<std::unique_ptr<Rule>> rules;
+    for (auto& ruleElement : element)
+    {
+        rules.emplace_back(parseRule(ruleElement));
+    }
+    return rules;
+}
+
+} // namespace internal
+
+} // namespace phosphor::power::regulators::config_file_parser
diff --git a/phosphor-regulators/src/config_file_parser.hpp b/phosphor-regulators/src/config_file_parser.hpp
new file mode 100644
index 0000000..2b5ca0d
--- /dev/null
+++ b/phosphor-regulators/src/config_file_parser.hpp
@@ -0,0 +1,308 @@
+/**
+ * Copyright © 2020 IBM Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "action.hpp"
+#include "chassis.hpp"
+#include "pmbus_write_vout_command_action.hpp"
+#include "rule.hpp"
+
+#include <nlohmann/json.hpp>
+
+#include <cstdint>
+#include <filesystem>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <tuple>
+#include <vector>
+
+namespace phosphor::power::regulators::config_file_parser
+{
+
+/**
+ * Parses the specified JSON configuration file.
+ *
+ * Returns the corresponding C++ Rule and Chassis objects.
+ *
+ * Throws a ConfigFileParserError if an error occurs.
+ *
+ * @param pathName configuration file path name
+ * @return tuple containing vectors of Rule and Chassis objects
+ */
+std::tuple<std::vector<std::unique_ptr<Rule>>,
+           std::vector<std::unique_ptr<Chassis>>>
+    parse(const std::filesystem::path& pathName);
+
+/*
+ * Internal implementation details for parse()
+ */
+namespace internal
+{
+
+/**
+ * Returns the specified property of the specified JSON element.
+ *
+ * Throws an invalid_argument exception if the property does not exist.
+ *
+ * @param element JSON element
+ * @param property property name
+ */
+inline const nlohmann::json& getRequiredProperty(const nlohmann::json& element,
+                                                 const std::string& property)
+{
+    auto it = element.find(property);
+    if (it == element.end())
+    {
+        throw std::invalid_argument{"Required property missing: " + property};
+    }
+    return *it;
+}
+
+/**
+ * Parses a JSON element containing an action.
+ *
+ * Returns the corresponding C++ Action object.
+ *
+ * Throws an exception if parsing fails.
+ *
+ * @param element JSON element
+ * @return Action object
+ */
+std::unique_ptr<Action> parseAction(const nlohmann::json& element);
+
+/**
+ * Parses a JSON element containing an array of actions.
+ *
+ * Returns the corresponding C++ Action objects.
+ *
+ * Throws an exception if parsing fails.
+ *
+ * @param element JSON element
+ * @return vector of Action objects
+ */
+std::vector<std::unique_ptr<Action>>
+    parseActionArray(const nlohmann::json& element);
+
+/**
+ * Parses a JSON element containing a boolean.
+ *
+ * Returns the corresponding C++ boolean value.
+ *
+ * Throws an exception if parsing fails.
+ *
+ * @param element JSON element
+ * @return boolean value
+ */
+inline bool parseBoolean(const nlohmann::json& element)
+{
+    // Verify element contains a boolean
+    if (!element.is_boolean())
+    {
+        throw std::invalid_argument{"Element is not a boolean"};
+    }
+    return element.get<bool>();
+}
+
+/**
+ * Parses a JSON element containing an array of chassis.
+ *
+ * Returns the corresponding C++ Chassis objects.
+ *
+ * Throws an exception if parsing fails.
+ *
+ * @param element JSON element
+ * @return vector of Chassis objects
+ */
+std::vector<std::unique_ptr<Chassis>>
+    parseChassisArray(const nlohmann::json& element);
+
+/**
+ * Parses a JSON element containing a double (floating point number).
+ *
+ * Returns the corresponding C++ double value.
+ *
+ * Throws an exception if parsing fails.
+ *
+ * @param element JSON element
+ * @return double value
+ */
+inline double parseDouble(const nlohmann::json& element)
+{
+    // Verify element contains a number (integer or floating point)
+    if (!element.is_number())
+    {
+        throw std::invalid_argument{"Element is not a number"};
+    }
+    return element.get<double>();
+}
+
+/**
+ * Parses a JSON element containing an 8-bit signed integer.
+ *
+ * Returns the corresponding C++ int8_t value.
+ *
+ * Throws an exception if parsing fails.
+ *
+ * @param element JSON element
+ * @return int8_t value
+ */
+inline int8_t parseInt8(const nlohmann::json& element)
+{
+    // Verify element contains an integer
+    if (!element.is_number_integer())
+    {
+        throw std::invalid_argument{"Element is not an integer"};
+    }
+    int value = element;
+    if ((value < INT8_MIN) || (value > INT8_MAX))
+    {
+        throw std::invalid_argument{"Element is not an 8-bit signed integer"};
+    }
+    return static_cast<int8_t>(value);
+}
+
+/**
+ * Parses a JSON element containing a pmbus_write_vout_command action.
+ *
+ * Returns the corresponding C++ PMBusWriteVoutCommandAction object.
+ *
+ * Throws an exception if parsing fails.
+ *
+ * @param element JSON element
+ * @return PMBusWriteVoutCommandAction object
+ */
+std::unique_ptr<PMBusWriteVoutCommandAction>
+    parsePMBusWriteVoutCommand(const nlohmann::json& element);
+
+/**
+ * Parses the JSON root element of the entire configuration file.
+ *
+ * Returns the corresponding C++ Rule and Chassis objects.
+ *
+ * Throws an exception if parsing fails.
+ *
+ * @param element JSON element
+ * @return tuple containing vectors of Rule and Chassis objects
+ */
+std::tuple<std::vector<std::unique_ptr<Rule>>,
+           std::vector<std::unique_ptr<Chassis>>>
+    parseRoot(const nlohmann::json& element);
+
+/**
+ * Parses a JSON element containing a rule.
+ *
+ * Returns the corresponding C++ Rule object.
+ *
+ * Throws an exception if parsing fails.
+ *
+ * @param element JSON element
+ * @return Rule object
+ */
+std::unique_ptr<Rule> parseRule(const nlohmann::json& element);
+
+/**
+ * Parses a JSON element containing an array of rules.
+ *
+ * Returns the corresponding C++ Rule objects.
+ *
+ * Throws an exception if parsing fails.
+ *
+ * @param element JSON element
+ * @return vector of Rule objects
+ */
+std::vector<std::unique_ptr<Rule>>
+    parseRuleArray(const nlohmann::json& element);
+
+/**
+ * Parses a JSON element containing a string.
+ *
+ * Returns the corresponding C++ string.
+ *
+ * Throws an exception if parsing fails.
+ *
+ * @param element JSON element
+ * @param isEmptyValid indicates whether an empty string value is valid
+ * @return string value
+ */
+inline std::string parseString(const nlohmann::json& element,
+                               bool isEmptyValid = false)
+{
+    if (!element.is_string())
+    {
+        throw std::invalid_argument{"Element is not a string"};
+    }
+    std::string value = element;
+    if (value.empty() && !isEmptyValid)
+    {
+        throw std::invalid_argument{"Element contains an empty string"};
+    }
+    return value;
+}
+
+/**
+ * Verifies that the specified JSON element is a JSON array.
+ *
+ * Throws an invalid_argument exception if the element is not an array.
+ *
+ * @param element JSON element
+ */
+inline void verifyIsArray(const nlohmann::json& element)
+{
+    if (!element.is_array())
+    {
+        throw std::invalid_argument{"Element is not an array"};
+    }
+}
+
+/**
+ * Verifies that the specified JSON element is a JSON object.
+ *
+ * Throws an invalid_argument exception if the element is not an object.
+ *
+ * @param element JSON element
+ */
+inline void verifyIsObject(const nlohmann::json& element)
+{
+    if (!element.is_object())
+    {
+        throw std::invalid_argument{"Element is not an object"};
+    }
+}
+
+/**
+ * Verifies that the specified JSON element contains the expected number of
+ * properties.
+ *
+ * Throws an invalid_argument exception if the element contains a different
+ * number of properties.  This indicates the element contains an invalid
+ * property.
+ *
+ * @param element JSON element
+ * @param expectedCount expected number of properties in element
+ */
+inline void verifyPropertyCount(const nlohmann::json& element,
+                                unsigned int expectedCount)
+{
+    if (element.size() != expectedCount)
+    {
+        throw std::invalid_argument{"Element contains an invalid property"};
+    }
+}
+
+} // namespace internal
+
+} // namespace phosphor::power::regulators::config_file_parser
diff --git a/phosphor-regulators/src/meson.build b/phosphor-regulators/src/meson.build
index b652f08..ef40cb9 100644
--- a/phosphor-regulators/src/meson.build
+++ b/phosphor-regulators/src/meson.build
@@ -4,6 +4,7 @@
 )
 
 phosphor_regulators_library_source_files = [
+    'config_file_parser.cpp',
     'id_map.cpp',
     'pmbus_utils.cpp',