diff --git a/examples/quick/main.qml b/examples/quick/main.qml
index 4990944..3307c0b 100644
--- a/examples/quick/main.qml
+++ b/examples/quick/main.qml
@@ -40,7 +40,7 @@ Window {
         name: "maplibre"
         // specify plugin parameters if necessary
         PluginParameter {
-            name: "maplibre.map.style_urls"
+            name: "maplibre.map.styles"
             value: "https://demotiles.maplibre.org/style.json"
         }
     }
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index 7d5e45d..538accb 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -49,7 +49,7 @@ target_sources(
         renderer_backend.cpp renderer_backend_p.hpp
         renderer_observer_p.hpp
         scheduler.cpp scheduler_p.hpp
-        settings.cpp
+        settings.cpp settings_p.hpp
         types.cpp
         utils.cpp
 )
diff --git a/src/core/map.cpp b/src/core/map.cpp
index d17a8b5..7f6539e 100644
--- a/src/core/map.cpp
+++ b/src/core/map.cpp
@@ -128,10 +128,17 @@ mbgl::MapOptions mapOptionsFromSettings(const QMapLibre::Settings &settings, con
 }
 
 mbgl::ResourceOptions resourceOptionsFromSettings(const QMapLibre::Settings &settings) {
+    if (settings.tileServerOptions() == nullptr) {
+        return std::move(mbgl::ResourceOptions()
+                             .withAssetPath(settings.assetPath().toStdString())
+                             .withCachePath(settings.cacheDatabasePath().toStdString())
+                             .withMaximumCacheSize(settings.cacheDatabaseMaximumSize()));
+    }
+
     return std::move(mbgl::ResourceOptions()
                          .withApiKey(settings.apiKey().toStdString())
                          .withAssetPath(settings.assetPath().toStdString())
-                         .withTileServerOptions(*settings.tileServerOptionsInternal())
+                         .withTileServerOptions(*settings.tileServerOptions())
                          .withCachePath(settings.cacheDatabasePath().toStdString())
                          .withMaximumCacheSize(settings.cacheDatabaseMaximumSize()));
 }
@@ -1236,14 +1243,6 @@ void Map::connectionEstablished() {
     mbgl::NetworkStatus::Reachable();
 }
 
-/*!
-    Returns a list containing a pair of string objects, representing the style
-    URL and name, respectively.
-*/
-const QVector<QPair<QString, QString>> &Map::defaultStyles() const {
-    return d_ptr->defaultStyles;
-}
-
 /*!
     \fn void QMapLibre::Map::needsRendering()
 
@@ -1303,11 +1302,6 @@ MapPrivate::MapPrivate(Map *q, const Settings &settings, const QSize &size, qrea
     connect(m_mapObserver.get(), &MapObserver::copyrightsChanged, q, &Map::copyrightsChanged);
 
     auto resourceOptions = resourceOptionsFromSettings(settings);
-    for (auto style : resourceOptions.tileServerOptions().defaultStyles()) {
-        defaultStyles.append(
-            QPair<QString, QString>(QString::fromStdString(style.getUrl()), QString::fromStdString(style.getName())));
-    }
-
     auto clientOptions = clientOptionsFromSettings(settings);
 
     // Setup the Map object.
diff --git a/src/core/map.hpp b/src/core/map.hpp
index 25ee7dc..9602d92 100644
--- a/src/core/map.hpp
+++ b/src/core/map.hpp
@@ -169,8 +169,6 @@ class Q_MAPLIBRE_CORE_EXPORT Map : public QObject {
     void destroyRenderer();
     void setFramebufferObject(quint32 fbo, const QSize &size);
 
-    const QVector<QPair<QString, QString>> &defaultStyles() const;
-
 public slots:
     void render();
     void connectionEstablished();
diff --git a/src/core/map_p.hpp b/src/core/map_p.hpp
index 83bfdbe..7aaf346 100644
--- a/src/core/map_p.hpp
+++ b/src/core/map_p.hpp
@@ -47,7 +47,6 @@ class MapPrivate : public QObject, public mbgl::RendererFrontend {
 
     mbgl::EdgeInsets margins;
     std::unique_ptr<mbgl::Map> mapObj{};
-    QVector<QPair<QString, QString>> defaultStyles;
 
 public slots:
     void requestRendering();
diff --git a/src/core/settings.cpp b/src/core/settings.cpp
index c240a01..e73d9c9 100644
--- a/src/core/settings.cpp
+++ b/src/core/settings.cpp
@@ -4,6 +4,7 @@
 // SPDX-License-Identifier: BSD-2-Clause
 
 #include "settings.hpp"
+#include "settings_p.hpp"
 
 #include <mbgl/gfx/renderer_backend.hpp>
 #include <mbgl/map/mode.hpp>
@@ -12,6 +13,7 @@
 #include <mbgl/util/traits.hpp>
 
 #include <QtCore/QCoreApplication>
+#include <QtCore/QDebug>
 
 #ifdef _MSC_VER
 #pragma warning(push)
@@ -143,18 +145,41 @@ namespace QMapLibre {
 
 /*!
     Constructs a Settings object with the default values. The default
-    configuration is valid for initializing a QMapLibre::Map.
+    configuration is not valid for initializing a \a QMapLibre::Map,
+    but a provider template can be provided.
 */
-Settings::Settings()
-    : m_contextMode(Settings::SharedGLContext),
-      m_mapMode(Settings::Continuous),
-      m_constrainMode(Settings::ConstrainHeightOnly),
-      m_viewportMode(Settings::DefaultViewport),
-      m_cacheMaximumSize(mbgl::util::DEFAULT_MAX_CACHE_SIZE),
-      m_cacheDatabasePath(":memory:"),
-      m_assetPath(QCoreApplication::applicationDirPath()),
-      m_apiKey(qgetenv("MLN_API_KEY")),
-      m_tileServerOptionsInternal(new mbgl::TileServerOptions(mbgl::TileServerOptions::DefaultConfiguration())) {}
+Settings::Settings(ProviderTemplate provider)
+    : d_ptr(new SettingsPrivate) {
+    d_ptr->setProviderTemplate(provider);
+}
+
+Settings::~Settings() {
+    delete d_ptr;
+}
+
+Settings::Settings(const Settings &s)
+    : d_ptr(new SettingsPrivate) {
+    *d_ptr = *s.d_ptr;
+}
+
+Settings::Settings(Settings &&s) noexcept
+    : d_ptr(s.d_ptr) {
+    s.d_ptr = nullptr;
+}
+
+Settings &Settings::operator=(const Settings &s) {
+    if (d_ptr != nullptr) delete d_ptr;
+    d_ptr = new SettingsPrivate;
+    *d_ptr = *s.d_ptr;
+    return *this;
+}
+
+Settings &Settings::operator=(Settings &&s) noexcept {
+    if (d_ptr != nullptr) delete d_ptr;
+    d_ptr = s.d_ptr;
+    s.d_ptr = nullptr;
+    return *this;
+}
 
 /*!
     Returns the OpenGL context mode. This is specially important when mixing
@@ -163,14 +188,14 @@ Settings::Settings()
     By default, it is set to Settings::SharedGLContext.
 */
 Settings::GLContextMode Settings::contextMode() const {
-    return m_contextMode;
+    return d_ptr->m_contextMode;
 }
 
 /*!
     Sets the OpenGL context \a mode.
 */
 void Settings::setContextMode(GLContextMode mode) {
-    m_contextMode = mode;
+    d_ptr->m_contextMode = mode;
 }
 
 /*!
@@ -186,14 +211,14 @@ void Settings::setContextMode(GLContextMode mode) {
     By default, it is set to QMapLibre::Settings::Continuous.
 */
 Settings::MapMode Settings::mapMode() const {
-    return m_mapMode;
+    return d_ptr->m_mapMode;
 }
 
 /*!
     Sets the map \a mode.
 */
 void Settings::setMapMode(MapMode mode) {
-    m_mapMode = mode;
+    d_ptr->m_mapMode = mode;
 }
 
 /*!
@@ -203,14 +228,14 @@ void Settings::setMapMode(MapMode mode) {
     By default, it is set to QMapLibre::Settings::ConstrainHeightOnly.
 */
 Settings::ConstrainMode Settings::constrainMode() const {
-    return m_constrainMode;
+    return d_ptr->m_constrainMode;
 }
 
 /*!
     Sets the map constrain \a mode.
 */
 void Settings::setConstrainMode(ConstrainMode mode) {
-    m_constrainMode = mode;
+    d_ptr->m_constrainMode = mode;
 }
 
 /*!
@@ -220,14 +245,14 @@ void Settings::setConstrainMode(ConstrainMode mode) {
     By default, it is set to QMapLibre::Settings::DefaultViewport.
 */
 Settings::ViewportMode Settings::viewportMode() const {
-    return m_viewportMode;
+    return d_ptr->m_viewportMode;
 }
 
 /*!
     Sets the viewport \a mode.
 */
 void Settings::setViewportMode(ViewportMode mode) {
-    m_viewportMode = mode;
+    d_ptr->m_viewportMode = mode;
 }
 
 /*!
@@ -239,14 +264,14 @@ void Settings::setViewportMode(ViewportMode mode) {
     By default, it is set to 50 MB.
 */
 unsigned Settings::cacheDatabaseMaximumSize() const {
-    return m_cacheMaximumSize;
+    return d_ptr->m_cacheMaximumSize;
 }
 
 /*!
     Returns the maximum allowed cache database \a size in bytes.
 */
 void Settings::setCacheDatabaseMaximumSize(unsigned size) {
-    m_cacheMaximumSize = size;
+    d_ptr->m_cacheMaximumSize = size;
 }
 
 /*!
@@ -260,7 +285,7 @@ void Settings::setCacheDatabaseMaximumSize(unsigned size) {
     cache instead of a file on disk.
 */
 QString Settings::cacheDatabasePath() const {
-    return m_cacheDatabasePath;
+    return d_ptr->m_cacheDatabasePath;
 }
 
 /*!
@@ -269,7 +294,7 @@ QString Settings::cacheDatabasePath() const {
     Setting the \a path to \c :memory: will create an in-memory cache.
 */
 void Settings::setCacheDatabasePath(const QString &path) {
-    m_cacheDatabasePath = path;
+    d_ptr->m_cacheDatabasePath = path;
 }
 
 /*!
@@ -281,14 +306,14 @@ void Settings::setCacheDatabasePath(const QString &path) {
     By default, it is set to the value returned by QCoreApplication::applicationDirPath().
 */
 QString Settings::assetPath() const {
-    return m_assetPath;
+    return d_ptr->m_assetPath;
 }
 
 /*!
     Sets the asset \a path.
 */
 void Settings::setAssetPath(const QString &path) {
-    m_assetPath = path;
+    d_ptr->m_assetPath = path;
 }
 
 /*!
@@ -298,7 +323,7 @@ void Settings::setAssetPath(const QString &path) {
     or empty if the variable is not set.
 */
 QString Settings::apiKey() const {
-    return m_apiKey;
+    return d_ptr->m_apiKey;
 }
 
 /*!
@@ -308,14 +333,18 @@ QString Settings::apiKey() const {
     key or access token.
 */
 void Settings::setApiKey(const QString &key) {
-    m_apiKey = key;
+    d_ptr->m_apiKey = key;
 }
 
 /*!
     Returns the API base URL.
 */
 QString Settings::apiBaseUrl() const {
-    return QString::fromStdString(m_tileServerOptionsInternal->baseURL());
+    if (tileServerOptions() == nullptr) {
+        return {};
+    }
+
+    return QString::fromStdString(tileServerOptions()->baseURL());
 }
 
 /*!
@@ -326,14 +355,14 @@ QString Settings::apiBaseUrl() const {
     changed, for instance, to a tile cache server address.
 */
 void Settings::setApiBaseUrl(const QString &url) {
-    m_tileServerOptionsInternal = &m_tileServerOptionsInternal->withBaseURL(url.toStdString());
+    d_ptr->setProviderApiBaseUrl(url);
 }
 
 /*!
     Returns the local font family. Returns an empty string if no local font family is set.
 */
 QString Settings::localFontFamily() const {
-    return m_localFontFamily;
+    return d_ptr->m_localFontFamily;
 }
 
 /*!
@@ -345,42 +374,42 @@ QString Settings::localFontFamily() const {
    instead of font data fetched from the server.
 */
 void Settings::setLocalFontFamily(const QString &family) {
-    m_localFontFamily = family;
+    d_ptr->m_localFontFamily = family;
 }
 
 /*!
     Returns the client name. Returns an empty string if no client name is set.
 */
 QString Settings::clientName() const {
-    return m_clientName;
+    return d_ptr->m_clientName;
 }
 
 /*!
     Sets the client name.
 */
 void Settings::setClientName(const QString &name) {
-    m_clientName = name;
+    d_ptr->m_clientName = name;
 }
 
 /*!
     Returns the client version. Returns an empty string if no client version is set.
 */
 QString Settings::clientVersion() const {
-    return m_clientVersion;
+    return d_ptr->m_clientVersion;
 }
 
 /*!
     Sets the client version.
 */
 void Settings::setClientVersion(const QString &version) {
-    m_clientVersion = version;
+    d_ptr->m_clientVersion = version;
 }
 
 /*!
     Returns resource transformation callback used to transform requested URLs.
 */
 std::function<std::string(const std::string &)> Settings::resourceTransform() const {
-    return m_resourceTransform;
+    return d_ptr->m_resourceTransform;
 }
 
 /*!
@@ -392,7 +421,7 @@ std::function<std::string(const std::string &)> Settings::resourceTransform() co
     servers or endpoints.
 */
 void Settings::setResourceTransform(const std::function<std::string(const std::string &)> &transform) {
-    m_resourceTransform = transform;
+    d_ptr->m_resourceTransform = transform;
 }
 
 /*!
@@ -403,36 +432,120 @@ void Settings::setResourceTransform(const std::function<std::string(const std::s
     in the library. This function will re-initialise all settings based
     on the default values of specific service provider defaults.
 */
-void Settings::resetToTemplate(SettingsTemplate settings_template) {
-    if (m_tileServerOptionsInternal) delete m_tileServerOptionsInternal;
-
-    if (settings_template == MapLibreSettings) {
-        m_tileServerOptionsInternal = new mbgl::TileServerOptions(mbgl::TileServerOptions::MapLibreConfiguration());
-    } else if (settings_template == MapTilerSettings) {
-        m_tileServerOptionsInternal = new mbgl::TileServerOptions(mbgl::TileServerOptions::MapTilerConfiguration());
-    } else if (settings_template == MapboxSettings) {
-        m_tileServerOptionsInternal = new mbgl::TileServerOptions(mbgl::TileServerOptions::MapboxConfiguration());
-    } else {
-        m_tileServerOptionsInternal = new mbgl::TileServerOptions(mbgl::TileServerOptions::DefaultConfiguration());
-    }
+void Settings::setProviderTemplate(ProviderTemplate providerTemplate) {
+    d_ptr->setProviderTemplate(providerTemplate);
 }
 
 /*!
-    All predefined styles.
+    Returns the map styles set by user.
 
-    Return all styles that are defined in default settings.
+    The styles are a list type \c QMapLibre::Style. Each style is a pair
+    of URL and name/label.
 */
-QVector<QPair<QString, QString>> Settings::defaultStyles() const {
-    QVector<QPair<QString, QString>> styles;
-    for (const auto &style : tileServerOptionsInternal()->defaultStyles()) {
-        styles.append(
-            QPair<QString, QString>(QString::fromStdString(style.getUrl()), QString::fromStdString(style.getName())));
+const Styles &Settings::styles() const {
+    return d_ptr->m_styles;
+}
+
+/*!
+    Sets the map styles.
+
+    The styles are a list type \c QMapLibre::Style. Each style is a pair
+    of URL and name/label.
+*/
+void Settings::setStyles(const Styles &styles) {
+    d_ptr->m_styles = styles;
+}
+
+/*!
+    All predefined provider styles.
+
+    Return all styles that are defined in provider settings template.
+*/
+Styles Settings::providerStyles() const {
+    Styles styles;
+    if (tileServerOptions() == nullptr) {
+        return styles;
+    }
+
+    for (const auto &style : tileServerOptions()->defaultStyles()) {
+        styles.append(Style(QString::fromStdString(style.getUrl()), QString::fromStdString(style.getName())));
     }
     return styles;
 }
 
-mbgl::TileServerOptions *Settings::tileServerOptionsInternal() const {
-    return m_tileServerOptionsInternal;
+/*!
+    Returns the default coordinate.
+*/
+Coordinate Settings::defaultCoordinate() const {
+    return d_ptr->m_defaultCoordinate;
+}
+
+/*!
+    Sets the default coordinate.
+*/
+void Settings::setDefaultCoordinate(const Coordinate &coordinate) {
+    d_ptr->m_defaultCoordinate = coordinate;
+}
+
+/*!
+    Returns the default zoom level.
+*/
+double Settings::defaultZoom() const {
+    return d_ptr->m_defaultZoom;
+}
+
+/*!
+    Sets the default zoom level.
+*/
+void Settings::setDefaultZoom(double zoom) {
+    d_ptr->m_defaultZoom = zoom;
+}
+
+/*!
+    Returns the provider tile server options.
+
+    Note that this is mainly for internal use.
+*/
+mbgl::TileServerOptions *Settings::tileServerOptions() const {
+    return d_ptr->m_tileServerOptions;
+}
+
+// Private implementation
+SettingsPrivate::SettingsPrivate()
+    : m_contextMode(Settings::SharedGLContext),
+      m_mapMode(Settings::Continuous),
+      m_constrainMode(Settings::ConstrainHeightOnly),
+      m_viewportMode(Settings::DefaultViewport),
+      m_providerTemplate(Settings::NoProvider),
+      m_cacheMaximumSize(mbgl::util::DEFAULT_MAX_CACHE_SIZE),
+      m_cacheDatabasePath(":memory:"),
+      m_assetPath(QCoreApplication::applicationDirPath()),
+      m_apiKey(qgetenv("MLN_API_KEY")) {}
+
+void SettingsPrivate::setProviderTemplate(Settings::ProviderTemplate providerTemplate) {
+    if (m_tileServerOptions) {
+        delete m_tileServerOptions;
+        m_tileServerOptions = nullptr;
+    }
+
+    m_providerTemplate = providerTemplate;
+
+    if (providerTemplate == Settings::MapLibreProvider) {
+        m_tileServerOptions = new mbgl::TileServerOptions(mbgl::TileServerOptions::MapLibreConfiguration());
+    } else if (providerTemplate == Settings::MapTilerProvider) {
+        m_tileServerOptions = new mbgl::TileServerOptions(mbgl::TileServerOptions::MapTilerConfiguration());
+    } else if (providerTemplate == Settings::MapboxProvider) {
+        m_tileServerOptions = new mbgl::TileServerOptions(mbgl::TileServerOptions::MapboxConfiguration());
+    }
+}
+
+void SettingsPrivate::setProviderApiBaseUrl(const QString &url) {
+    if (m_tileServerOptions == nullptr) {
+        qWarning() << "No provider set so not setting API URL.";
+        return;
+    }
+
+    m_tileServerOptions = &m_tileServerOptions->withBaseURL(url.toStdString());
 }
 
 } // namespace QMapLibre
diff --git a/src/core/settings.hpp b/src/core/settings.hpp
index 51002df..f30b690 100644
--- a/src/core/settings.hpp
+++ b/src/core/settings.hpp
@@ -7,6 +7,7 @@
 #define QMAPLIBRE_SETTINGS_H
 
 #include <QMapLibre/Export>
+#include <QMapLibre/Types>
 
 #include <QtCore/QString>
 #include <QtGui/QImage>
@@ -20,10 +21,10 @@ class TileServerOptions;
 
 namespace QMapLibre {
 
+class SettingsPrivate;
+
 class Q_MAPLIBRE_CORE_EXPORT Settings {
 public:
-    Settings();
-
     enum GLContextMode {
         UniqueGLContext = 0,
         SharedGLContext
@@ -45,13 +46,20 @@ class Q_MAPLIBRE_CORE_EXPORT Settings {
         FlippedYViewport
     };
 
-    enum SettingsTemplate {
-        DefaultSettings = 0,
-        MapLibreSettings,
-        MapTilerSettings,
-        MapboxSettings
+    enum ProviderTemplate {
+        NoProvider = 0,
+        MapLibreProvider,
+        MapTilerProvider,
+        MapboxProvider
     };
 
+    explicit Settings(ProviderTemplate provider = NoProvider);
+    ~Settings();
+    Settings(const Settings &);
+    Settings(Settings &&) noexcept;
+    Settings &operator=(const Settings &);
+    Settings &operator=(Settings &&) noexcept;
+
     GLContextMode contextMode() const;
     void setContextMode(GLContextMode);
 
@@ -91,28 +99,21 @@ class Q_MAPLIBRE_CORE_EXPORT Settings {
     std::function<std::string(const std::string &)> resourceTransform() const;
     void setResourceTransform(const std::function<std::string(const std::string &)> &);
 
-    void resetToTemplate(SettingsTemplate);
+    void setProviderTemplate(ProviderTemplate);
+    void setStyles(const Styles &styles);
+
+    const Styles &styles() const;
+    Styles providerStyles() const;
 
-    QVector<QPair<QString, QString>> defaultStyles() const;
+    Coordinate defaultCoordinate() const;
+    void setDefaultCoordinate(const Coordinate &);
+    double defaultZoom() const;
+    void setDefaultZoom(double);
 
-    mbgl::TileServerOptions *tileServerOptionsInternal() const;
+    mbgl::TileServerOptions *tileServerOptions() const;
 
 private:
-    GLContextMode m_contextMode;
-    MapMode m_mapMode;
-    ConstrainMode m_constrainMode;
-    ViewportMode m_viewportMode;
-
-    unsigned m_cacheMaximumSize;
-    QString m_cacheDatabasePath;
-    QString m_assetPath;
-    QString m_apiKey;
-    QString m_localFontFamily;
-    QString m_clientName;
-    QString m_clientVersion;
-    std::function<std::string(const std::string &)> m_resourceTransform;
-
-    mbgl::TileServerOptions *m_tileServerOptionsInternal{};
+    SettingsPrivate *d_ptr;
 };
 
 } // namespace QMapLibre
diff --git a/src/core/settings_p.hpp b/src/core/settings_p.hpp
new file mode 100644
index 0000000..20ee672
--- /dev/null
+++ b/src/core/settings_p.hpp
@@ -0,0 +1,53 @@
+// Copyright (C) 2023 MapLibre contributors
+// Copyright (C) 2019 Mapbox, Inc.
+
+// SPDX-License-Identifier: BSD-2-Clause
+
+#pragma once
+
+#include "settings.hpp"
+#include "types.hpp"
+
+#include <QtCore/QString>
+#include <QtCore/QVector>
+
+#include <functional>
+
+namespace mbgl {
+class TileServerOptions;
+}
+
+namespace QMapLibre {
+
+class SettingsPrivate {
+public:
+    SettingsPrivate();
+
+    void setProviderTemplate(Settings::ProviderTemplate providerTemplate);
+    void setProviderApiBaseUrl(const QString &url);
+
+    Settings::GLContextMode m_contextMode;
+    Settings::MapMode m_mapMode;
+    Settings::ConstrainMode m_constrainMode;
+    Settings::ViewportMode m_viewportMode;
+    Settings::ProviderTemplate m_providerTemplate;
+
+    unsigned m_cacheMaximumSize;
+    QString m_cacheDatabasePath;
+    QString m_assetPath;
+    QString m_apiKey;
+    QString m_localFontFamily;
+    QString m_clientName;
+    QString m_clientVersion;
+
+    Coordinate m_defaultCoordinate{};
+    double m_defaultZoom{};
+
+    Styles m_styles;
+
+    std::function<std::string(const std::string &)> m_resourceTransform;
+
+    mbgl::TileServerOptions *m_tileServerOptions{};
+};
+
+} // namespace QMapLibre
diff --git a/src/core/types.hpp b/src/core/types.hpp
index 070f0bd..becfbd5 100644
--- a/src/core/types.hpp
+++ b/src/core/types.hpp
@@ -25,6 +25,35 @@ typedef QVector<Coordinates> CoordinatesCollection;
 
 typedef QVector<CoordinatesCollection> CoordinatesCollections;
 
+struct Q_MAPLIBRE_CORE_EXPORT Style {
+    enum Type { // Taken from Qt to be in sync with QtLocation
+        NoMap = 0,
+        StreetMap,
+        SatelliteMapDay,
+        SatelliteMapNight,
+        TerrainMap,
+        HybridMap,
+        TransitMap,
+        GrayStreetMap,
+        PedestrianMap,
+        CarNavigationMap,
+        CycleMap,
+        CustomMap = 100
+    };
+
+    Style(const QString &url_, const QString &name_ = QString())
+        : url(url_),
+          name(name_) {}
+
+    QString url;
+    QString name;
+    QString description;
+    bool night{};
+    Type type{CustomMap};
+};
+
+typedef QVector<Style> Styles;
+
 struct Q_MAPLIBRE_CORE_EXPORT Feature {
     enum Type {
         PointType = 1,
diff --git a/src/location/qgeomap.cpp b/src/location/qgeomap.cpp
index 947c320..60c1507 100644
--- a/src/location/qgeomap.cpp
+++ b/src/location/qgeomap.cpp
@@ -81,8 +81,8 @@ QSGNode *QGeoMapMapLibrePrivate::updateSceneGraph(QSGNode *node, QQuickWindow *w
     }
     map = static_cast<TextureNode *>(node)->map();
 
-    if (m_syncState & MapTypeSync) {
-        map->setStyleUrl(m_activeMapType.name());
+    if ((m_syncState & MapTypeSync) && m_activeMapType.metadata().contains(QStringLiteral("url"))) {
+        map->setStyleUrl(m_activeMapType.metadata()[QStringLiteral("url")].toString());
     }
 
     if (m_syncState & VisibleAreaSync) {
diff --git a/src/location/qt_mapping_engine.cpp b/src/location/qt_mapping_engine.cpp
index 3b0063a..7629964 100644
--- a/src/location/qt_mapping_engine.cpp
+++ b/src/location/qt_mapping_engine.cpp
@@ -6,13 +6,49 @@
 
 #include "qt_mapping_engine.hpp"
 #include "qgeomap.hpp"
+#include "types.hpp"
 
 #include <QtLocation/private/qabstractgeotilecache_p.h>
 #include <QtLocation/private/qgeocameracapabilities_p.h>
 #include <QtLocation/private/qgeomaptype_p.h>
 
 #include <QtCore/QDir>
+#include <QtCore/QJsonArray>
+#include <QtCore/QJsonDocument>
+#include <QtCore/QJsonObject>
+#include <QtCore/QJsonValue>
 #include <QtCore/QStandardPaths>
+#include <QtCore/QVariant>
+#include <QtQml/QJSValue>
+
+namespace {
+
+void parseStyleJsonObject(QMapLibre::Styles &styles, const QJsonObject &obj) {
+    if (!obj.contains(QStringLiteral("url"))) return;
+
+    const QString url = obj.value(QStringLiteral("url")).toString();
+    if (url.isEmpty()) return;
+
+    const QString name = obj.contains(QStringLiteral("name"))
+                             ? obj.value(QStringLiteral("name")).toString()
+                             : QStringLiteral("Style") + QString::number(styles.size() + 1);
+    QMapLibre::Style style(url, name);
+    if (obj.contains(QStringLiteral("description"))) {
+        style.description = obj.value(QStringLiteral("description")).toString();
+    }
+    if (obj.contains(QStringLiteral("night"))) {
+        style.night = obj.value(QStringLiteral("night")).toBool();
+    }
+    if (obj.contains("type")) {
+        style.type = QMapLibre::Style::Type(obj.value(QStringLiteral("type")).toInt());
+    }
+    if (obj.contains("style")) {
+        style.type = QMapLibre::Style::Type(obj.value(QStringLiteral("style")).toInt());
+    }
+    styles.append(std::move(style));
+}
+
+} // namespace
 
 namespace QMapLibre {
 
@@ -34,15 +70,33 @@ QtMappingEngine::QtMappingEngine(const QVariantMap &parameters, QGeoServiceProvi
     cameraCaps.setMaximumFieldOfView(36.87);
     setCameraCapabilities(cameraCaps);
 
+    const QStringList supportedOptions{QStringLiteral("maplibre.api.provider"),
+                                       QStringLiteral("maplibre.api.base_url"),
+                                       QStringLiteral("maplibre.api.key"),
+                                       QStringLiteral("maplibre.map.styles"),
+                                       QStringLiteral("maplibre.cache.memory"),
+                                       QStringLiteral("maplibre.cache.directory"),
+                                       QStringLiteral("maplibre.cache.size"),
+                                       QStringLiteral("maplibre.items.insert_before"),
+                                       QStringLiteral("maplibre.client.name"),
+                                       QStringLiteral("maplibre.client.version")};
+    for (const QString &key : parameters.keys()) {
+        if (!supportedOptions.contains(key)) {
+            qWarning() << "Unsupported option" << key;
+        }
+    }
+
     // API settings
     if (parameters.contains(QStringLiteral("maplibre.api.provider"))) {
-        const QString api_provider = parameters.value(QStringLiteral("maplibre.api.provider")).toString();
-        if (api_provider == "maptiler") {
-            m_settings.resetToTemplate(Settings::MapTilerSettings);
-        } else if (api_provider == "mapbox") {
-            m_settings.resetToTemplate(Settings::MapboxSettings);
+        const QString apiProvider = parameters.value(QStringLiteral("maplibre.api.provider")).toString();
+        if (apiProvider == "maplibre") {
+            m_settings.setProviderTemplate(Settings::MapLibreProvider);
+        } else if (apiProvider == "maptiler") {
+            m_settings.setProviderTemplate(Settings::MapTilerProvider);
+        } else if (apiProvider == "mapbox") {
+            m_settings.setProviderTemplate(Settings::MapboxProvider);
         } else {
-            qWarning() << "Unknown API provider" << api_provider;
+            qWarning() << "Unknown API provider" << apiProvider;
         }
     }
 
@@ -58,23 +112,47 @@ QtMappingEngine::QtMappingEngine(const QVariantMap &parameters, QGeoServiceProvi
     const QByteArray pluginName = "maplibre";
     QList<QGeoMapType> mapTypes;
     int mapId{};
-    QVariantMap mapMetadata;
-    mapMetadata["isHTTPS"] = true;
 
     if (parameters.contains(QStringLiteral("maplibre.map.styles"))) {
-        const QString ids = parameters.value(QStringLiteral("maplibre.map.styles")).toString();
-        const QStringList idList = ids.split(',', Qt::SkipEmptyParts);
+        Styles styles;
+        const QVariant stylesValue = parameters.value(QStringLiteral("maplibre.map.styles"));
+        if (stylesValue.userType() == qMetaTypeId<QJSValue>()) {
+            auto jsonDoc = QJsonDocument::fromVariant(stylesValue.value<QJSValue>().toVariant());
+            if (jsonDoc.isObject()) {
+                parseStyleJsonObject(styles, jsonDoc.object());
+            } else if (jsonDoc.isArray()) {
+                for (const auto &value : jsonDoc.array()) {
+                    if (value.isObject()) {
+                        parseStyleJsonObject(styles, value.toObject());
+                    } else if (value.isString()) {
+                        const QString url = value.toString();
+                        if (url.isEmpty()) continue;
+                        styles.append(Style(url, "Style " + QString::number(styles.size() + 1)));
+                    }
+                }
+            }
+        } else {
+            const QString urls = parameters.value(QStringLiteral("maplibre.map.styles")).toString();
+            const QStringList urlsList = urls.split(',', Qt::SkipEmptyParts);
 
-        for (const QString &url : idList) {
-            if (url.isEmpty()) continue;
+            for (const QString &url : urlsList) {
+                if (url.isEmpty()) continue;
+                styles.append(Style(url, "Style " + QString::number(styles.size() + 1)));
+            }
+        }
 
-            mapMetadata["isHTTPS"] = url.startsWith(QStringLiteral("http:"));
+        m_settings.setStyles(styles);
 
-            mapTypes << QGeoMapType(QGeoMapType::CustomMap,
-                                    url,
-                                    tr("User provided style"),
-                                    false,
+        for (const Style &style : styles) {
+            QVariantMap mapMetadata;
+            mapMetadata[QStringLiteral("url")] = style.url;
+            mapMetadata[QStringLiteral("isHTTPS")] = style.url.startsWith(QStringLiteral("https:"));
+
+            mapTypes << QGeoMapType(QGeoMapType::MapStyle(style.type),
+                                    style.name,
+                                    style.description,
                                     false,
+                                    style.night,
                                     ++mapId,
                                     pluginName,
                                     cameraCaps,
@@ -82,12 +160,17 @@ QtMappingEngine::QtMappingEngine(const QVariantMap &parameters, QGeoServiceProvi
         }
     }
 
-    for (const QPair<QString, QString> &style : m_settings.defaultStyles()) {
-        mapTypes << QGeoMapType(QGeoMapType::StreetMap,
-                                style.first,
-                                style.second,
-                                false,
+    // load provider styles if available
+    for (const Style &style : m_settings.providerStyles()) {
+        QVariantMap mapMetadata;
+        mapMetadata[QStringLiteral("url")] = style.url;
+        mapMetadata[QStringLiteral("isHTTPS")] = true;
+
+        mapTypes << QGeoMapType(QGeoMapType::MapStyle(style.type),
+                                style.name,
+                                style.description,
                                 false,
+                                style.night,
                                 ++mapId,
                                 pluginName,
                                 cameraCaps,
diff --git a/src/widgets/gl_widget.cpp b/src/widgets/gl_widget.cpp
index 1545f48..096bcde 100644
--- a/src/widgets/gl_widget.cpp
+++ b/src/widgets/gl_widget.cpp
@@ -41,10 +41,15 @@ void GLWidget::initializeGL() {
     d_ptr->m_map.reset(new Map(nullptr, d_ptr->m_settings, size(), devicePixelRatioF()));
     connect(d_ptr->m_map.get(), SIGNAL(needsRendering()), this, SLOT(update()));
 
-    // Set default location to Helsinki.
-    d_ptr->m_map->setCoordinateZoom(Coordinate(60.170448, 24.942046), 5);
+    // Set default location
+    d_ptr->m_map->setCoordinateZoom(d_ptr->m_settings.defaultCoordinate(), d_ptr->m_settings.defaultZoom());
+
     // Set default style
-    d_ptr->m_map->setStyleUrl(d_ptr->m_map->defaultStyles()[0].first);
+    if (!d_ptr->m_settings.styles().empty()) {
+        d_ptr->m_map->setStyleUrl(d_ptr->m_settings.styles().front().url);
+    } else if (!d_ptr->m_settings.providerStyles().empty()) {
+        d_ptr->m_map->setStyleUrl(d_ptr->m_settings.providerStyles().front().url);
+    }
 }
 
 void GLWidget::paintGL() {
diff --git a/test/core/map_tester.cpp b/test/core/map_tester.cpp
index e7b5913..8f84e51 100644
--- a/test/core/map_tester.cpp
+++ b/test/core/map_tester.cpp
@@ -13,6 +13,7 @@ namespace QMapLibre {
 
 MapTester::MapTester()
     : size(512, 512),
+      settings(Settings::MapLibreProvider),
       map(nullptr, settings, size) {
     connect(&map, &Map::mapChanged, this, &MapTester::onMapChanged);
     connect(&map, &Map::needsRendering, this, &MapTester::onNeedsRendering);
diff --git a/test/core/test_core.cpp b/test/core/test_core.cpp
index 4faf2c4..93ad903 100644
--- a/test/core/test_core.cpp
+++ b/test/core/test_core.cpp
@@ -62,7 +62,7 @@ void TestCore::testStyleURL() {
 
     auto tester = std::make_unique<QMapLibre::MapTester>();
 
-    QString url(tester->map.defaultStyles()[0].first);
+    QString url(tester->settings.providerStyles().front().url);
 
     tester->map.setStyleUrl(url);
     QCOMPARE(tester->map.styleUrl(), url);
diff --git a/test/qml/qt5/tst_map.qml b/test/qml/qt5/tst_map.qml
index 75f8566..3f4d771 100644
--- a/test/qml/qt5/tst_map.qml
+++ b/test/qml/qt5/tst_map.qml
@@ -30,8 +30,8 @@ Rectangle {
         name: "maplibre"
         // specify plugin parameters if necessary
         PluginParameter {
-            name: "maplibre.map.style_urls"
-            value: "https://demotiles.maplibre.org/style.json"
+            name: "maplibre.map.styles"
+            value: "https://demotiles.maplibre.org/style.json,https://demotiles.maplibre.org/style2.json"
         }
     }
 
@@ -62,7 +62,11 @@ Rectangle {
             wait(2000)
             window.fullWindow = true
             map.center = window.coordinate
-            wait(2000)
+            wait(500)
+        }
+
+        function test_styles() {
+            compare(map.supportedMapTypes.length, 2)
         }
     }
 }
diff --git a/test/qml/qt5/tst_plugin_style.qml b/test/qml/qt5/tst_plugin_style.qml
new file mode 100644
index 0000000..1a8ca31
--- /dev/null
+++ b/test/qml/qt5/tst_plugin_style.qml
@@ -0,0 +1,77 @@
+// Copyright (C) 2023 MapLibre contributors
+
+// SPDX-License-Identifier: BSD-2-Clause
+
+import QtQuick 2.15
+import QtQuick.Window 2.15
+import QtLocation 5.15
+import QtPositioning 5.15
+
+import QtTest 1.0
+
+Item {
+    id: window
+    width: 512
+    height: 512
+
+    Plugin {
+        id: mapPlugin
+        name: "maplibre"
+
+        PluginParameter {
+            name: "maplibre.map.styles"
+            value: [
+                {
+                    "url": "https://demotiles.maplibre.org/style.json",
+                    "name": "Demo Tiles",
+                    "description": "MapLibre Demo Tiles",
+                    "type": MapType.PedestrianMap
+                },
+                {
+                    "url": "https://demotiles.maplibre.org/style.json",
+                    "name": "Demo Tiles Night",
+                    "description": "MapLibre Demo Tiles for night usage",
+                    "night": true,
+                    "style": MapType.SatelliteMapNight
+                },
+                "http://test.com/style.json",
+            ]
+        }
+    }
+
+    Map {
+        id: map
+        anchors.fill: parent
+        plugin: mapPlugin
+    }
+
+    TestCase {
+        id: tc1
+        name: "Run"
+
+        function test_plugin_style() {
+            compare(map.supportedMapTypes.length, 3)
+            wait(500)
+        }
+
+        function test_plugin_style_values() {
+            compare(map.supportedMapTypes[0].name, "Demo Tiles")
+            compare(map.supportedMapTypes[0].description, "MapLibre Demo Tiles")
+            compare(map.supportedMapTypes[0].night, false)
+            compare(map.supportedMapTypes[0].style, MapType.PedestrianMap)
+            compare(map.supportedMapTypes[0].metadata["url"], "https://demotiles.maplibre.org/style.json")
+
+            compare(map.supportedMapTypes[1].name, "Demo Tiles Night")
+            compare(map.supportedMapTypes[1].description, "MapLibre Demo Tiles for night usage")
+            compare(map.supportedMapTypes[1].night, true)
+            compare(map.supportedMapTypes[1].style, MapType.SatelliteMapNight)
+            compare(map.supportedMapTypes[1].metadata["url"], "https://demotiles.maplibre.org/style.json")
+
+            compare(map.supportedMapTypes[2].name, "Style 3")
+            compare(map.supportedMapTypes[2].description, "")
+            compare(map.supportedMapTypes[2].night, false)
+            compare(map.supportedMapTypes[2].style, MapType.CustomMap)
+            compare(map.supportedMapTypes[2].metadata["url"], "http://test.com/style.json")
+        }
+    }
+}
diff --git a/test/qml/qt6/tst_map.qml b/test/qml/qt6/tst_map.qml
index e3fd135..296fb55 100644
--- a/test/qml/qt6/tst_map.qml
+++ b/test/qml/qt6/tst_map.qml
@@ -28,8 +28,8 @@ Item {
         name: "maplibre"
         // specify plugin parameters if necessary
         PluginParameter {
-            name: "maplibre.map.style_urls"
-            value: "https://demotiles.maplibre.org/style.json"
+            name: "maplibre.map.styles"
+            value: "https://demotiles.maplibre.org/style.json,https://demotiles.maplibre.org/style2.json"
         }
     }
 
@@ -59,7 +59,11 @@ Item {
             wait(2000)
             window.fullWindow = true
             mapView.map.center = window.coordinate
-            wait(2000)
+            wait(500)
+        }
+
+        function test_styles() {
+            compare(mapView.map.supportedMapTypes.length, 2)
         }
     }
 }
diff --git a/test/qml/qt6/tst_plugin_no_parameters.qml b/test/qml/qt6/tst_plugin_no_parameters.qml
new file mode 100644
index 0000000..7c7f3f9
--- /dev/null
+++ b/test/qml/qt6/tst_plugin_no_parameters.qml
@@ -0,0 +1,37 @@
+// Copyright (C) 2023 MapLibre contributors
+
+// SPDX-License-Identifier: BSD-2-Clause
+
+import QtQuick 2.15
+import QtQuick.Window 2.15
+import QtLocation 6.5
+import QtPositioning 6.5
+
+import QtTest 1.0
+
+Item {
+    id: window
+    width: 512
+    height: 512
+
+    Plugin {
+        id: mapPlugin
+        name: "maplibre"
+    }
+
+    MapView {
+        id: mapView
+        anchors.fill: parent
+        map.plugin: mapPlugin
+    }
+
+    TestCase {
+        id: tc1
+        name: "Run"
+
+        function test_plugin_no_parameters() {
+            compare(mapView.map.supportedMapTypes.length, 0)
+            wait(500)
+        }
+    }
+}
diff --git a/test/qml/qt6/tst_plugin_provider.qml b/test/qml/qt6/tst_plugin_provider.qml
new file mode 100644
index 0000000..a02ff7c
--- /dev/null
+++ b/test/qml/qt6/tst_plugin_provider.qml
@@ -0,0 +1,42 @@
+// Copyright (C) 2023 MapLibre contributors
+
+// SPDX-License-Identifier: BSD-2-Clause
+
+import QtQuick 2.15
+import QtQuick.Window 2.15
+import QtLocation 6.5
+import QtPositioning 6.5
+
+import QtTest 1.0
+
+Item {
+    id: window
+    width: 512
+    height: 512
+
+    Plugin {
+        id: mapPlugin
+        name: "maplibre"
+
+        PluginParameter {
+            name: "maplibre.api.provider"
+            value: "maplibre"
+        }
+    }
+
+    MapView {
+        id: mapView
+        anchors.fill: parent
+        map.plugin: mapPlugin
+    }
+
+    TestCase {
+        id: tc1
+        name: "Run"
+
+        function test_plugin_provider() {
+            compare(mapView.map.supportedMapTypes.length, 1)
+            wait(500)
+        }
+    }
+}
diff --git a/test/qml/qt6/tst_plugin_style.qml b/test/qml/qt6/tst_plugin_style.qml
new file mode 100644
index 0000000..b1fb62f
--- /dev/null
+++ b/test/qml/qt6/tst_plugin_style.qml
@@ -0,0 +1,77 @@
+// Copyright (C) 2023 MapLibre contributors
+
+// SPDX-License-Identifier: BSD-2-Clause
+
+import QtQuick 2.15
+import QtQuick.Window 2.15
+import QtLocation 6.5
+import QtPositioning 6.5
+
+import QtTest 1.0
+
+Item {
+    id: window
+    width: 512
+    height: 512
+
+    Plugin {
+        id: mapPlugin
+        name: "maplibre"
+
+        PluginParameter {
+            name: "maplibre.map.styles"
+            value: [
+                {
+                    "url": "https://demotiles.maplibre.org/style.json",
+                    "name": "Demo Tiles",
+                    "description": "MapLibre Demo Tiles",
+                    "type": MapType.PedestrianMap
+                },
+                {
+                    "url": "https://demotiles.maplibre.org/style.json",
+                    "name": "Demo Tiles Night",
+                    "description": "MapLibre Demo Tiles for night usage",
+                    "night": true,
+                    "style": MapType.SatelliteMapNight
+                },
+                "http://test.com/style.json",
+            ]
+        }
+    }
+
+    MapView {
+        id: mapView
+        anchors.fill: parent
+        map.plugin: mapPlugin
+    }
+
+    TestCase {
+        id: tc1
+        name: "Run"
+
+        function test_plugin_style() {
+            compare(mapView.map.supportedMapTypes.length, 3)
+            wait(500)
+        }
+
+        function test_plugin_style_values() {
+            compare(mapView.map.supportedMapTypes[0].name, "Demo Tiles")
+            compare(mapView.map.supportedMapTypes[0].description, "MapLibre Demo Tiles")
+            compare(mapView.map.supportedMapTypes[0].night, false)
+            compare(mapView.map.supportedMapTypes[0].style, MapType.PedestrianMap)
+            compare(mapView.map.supportedMapTypes[0].metadata["url"], "https://demotiles.maplibre.org/style.json")
+
+            compare(mapView.map.supportedMapTypes[1].name, "Demo Tiles Night")
+            compare(mapView.map.supportedMapTypes[1].description, "MapLibre Demo Tiles for night usage")
+            compare(mapView.map.supportedMapTypes[1].night, true)
+            compare(mapView.map.supportedMapTypes[1].style, MapType.SatelliteMapNight)
+            compare(mapView.map.supportedMapTypes[1].metadata["url"], "https://demotiles.maplibre.org/style.json")
+
+            compare(mapView.map.supportedMapTypes[2].name, "Style 3")
+            compare(mapView.map.supportedMapTypes[2].description, "")
+            compare(mapView.map.supportedMapTypes[2].night, false)
+            compare(mapView.map.supportedMapTypes[2].style, MapType.CustomMap)
+            compare(mapView.map.supportedMapTypes[2].metadata["url"], "http://test.com/style.json")
+        }
+    }
+}
diff --git a/test/widgets/test_widgets.cpp b/test/widgets/test_widgets.cpp
index a6b77ab..e775f05 100644
--- a/test/widgets/test_widgets.cpp
+++ b/test/widgets/test_widgets.cpp
@@ -14,10 +14,12 @@ class TestWidgets : public QObject {
     Q_OBJECT
 
 private slots:
-    void testGLWidget();
+    void testGLWidgetNoProvider();
+    void testGLWidgetMapLibreProvider();
+    void testGLWidgetStyle();
 };
 
-void TestWidgets::testGLWidget() {
+void TestWidgets::testGLWidgetNoProvider() {
     std::unique_ptr<QSurface> surface = QMapLibre::createTestSurface(QSurface::Window);
     QVERIFY(surface != nullptr);
 
@@ -29,6 +31,40 @@ void TestWidgets::testGLWidget() {
     auto tester = std::make_unique<QMapLibre::GLTester>(settings);
     tester->show();
     QTest::qWait(1000);
+}
+
+void TestWidgets::testGLWidgetMapLibreProvider() {
+    std::unique_ptr<QSurface> surface = QMapLibre::createTestSurface(QSurface::Window);
+    QVERIFY(surface != nullptr);
+
+    QOpenGLContext ctx;
+    QVERIFY(ctx.create());
+    QVERIFY(ctx.makeCurrent(surface.get()));
+
+    QMapLibre::Settings settings(QMapLibre::Settings::MapLibreProvider);
+    auto tester = std::make_unique<QMapLibre::GLTester>(settings);
+    tester->show();
+    QTest::qWait(100);
+    tester->initializeAnimation();
+    QTest::qWait(tester->selfTest());
+}
+
+void TestWidgets::testGLWidgetStyle() {
+    std::unique_ptr<QSurface> surface = QMapLibre::createTestSurface(QSurface::Window);
+    QVERIFY(surface != nullptr);
+
+    QOpenGLContext ctx;
+    QVERIFY(ctx.create());
+    QVERIFY(ctx.makeCurrent(surface.get()));
+
+    QMapLibre::Styles styles;
+    styles.append(QMapLibre::Style("https://demotiles.maplibre.org/style.json", "Demo tiles"));
+
+    QMapLibre::Settings settings;
+    settings.setStyles(styles);
+    auto tester = std::make_unique<QMapLibre::GLTester>(settings);
+    tester->show();
+    QTest::qWait(100);
     tester->initializeAnimation();
     QTest::qWait(tester->selfTest());
 }