your questions are mostly concerned with what getValueByKey does. If I understand the Qt function names correctly it looks sane. You already saw that there is a problem with the function, ie. it will return a valid value in case of an error.

I suggest converting the complete list to a std::map<std::string, std::string> and handling errors there. Once you have that map you can easily use STL functionality to get your values and use the usual checks to find out if a value exists.

You are converting QString to QVariant in your loop. Why not just hand out the string and let the caller decide what to do with it?

Once your function is finished, you should remove the debug statement.

Also: from your question it sounds as if the API is fixed and cannot be changed. However, returning a list with even length to avoid building a map is a really bad design decision and should be changed. Maybe you have a chance of changing this.

Are the keys always in the same order?

You mention an API that delivers data as a QStringList. Do you know if the keys are always in the same order in that list? If so, you don't need to scan the list to find a matching key, you can just use its index in the list. Note that you should only rely on this if the API guarantees the order, or if you have some control over the code that produces the list and can ensure the order.

Don't return a variant

If the list would store values already in a variant, then it would be fine to return that varant in getValueByKey(). But since the list only contains strings, converting to and from a variant adds unnecessary overhead. Consider making functions that return the desired type immediately: getStringByKey(), getIntByKey(), and so on. It could be implemented like so:

const QString& getStringByKey(const QStringList& list, const QString& key) {
    if (auto index = list.indexOf(key); index != -1) {
        return list[index];
    } else {
        // Handle error here
    }
}

const int getIntByKey(const QStringList& list, const QString& key) {
    return getStringByKey(list, key).toInt();
}

Handling non-existing keys

There are several ways to handle it. If it is exceptional that a key does not exist (for example, because the API guarantees it should), consider throwing an exception. This way you don't have to deal with returning a value that indicates the key doesn't exist.

Otherwise, consider using std::optional<> for the return value.

Does this code make sense?

The code looks time inefficient due to the frequent indexOf calls for strings, but it makes sense because it solves the problem.

Is there a better way to do such task?

From the problem statement, I assume that keys consist of ASCII characters, and a kind of deserialization function is needed. Here, possible solution based on this answer (requires c++14).

// file data.h
#ifndef DATA_H
#define DATA_H

#include <QString>

struct Data
{
    QString mString;
    bool mBool;
    int mInt;
    float mFloat;
};

Data deserialize(const QStringList& plainData);

#endif

// file data.cpp
#include "data.h"

#include <QVariant>

namespace
{

constexpr size_t latin1Code(char ch)
{
    return static_cast<size_t>(ch);
}

constexpr size_t latin1Code(QChar ch)
{
    return static_cast<size_t>(ch.toLatin1());
}

template<typename T>
constexpr size_t hashCString(const T* str)
{
    size_t strHash = 0u;
    for (const T* p = str; *p != '\0'; ++p)
        strHash = strHash * 33 + latin1Code(*p);

    return strHash;
}

size_t hashString(const QString& str)
{
    return hashCString(str.data());
}

constexpr size_t hashString(const char* str)
{
    return hashCString(str);
}

} // namespace    

Data deserialize(const QStringList& plainData)
{
    Data d{};
    for (int i = 0; i + 1 < plainData.size(); i += 2) {
        const QString &key = plainData.at(i);
        const QString &value = plainData.at(i + 1);

        switch (hashString(key)) {
        case hashString("KEY-STRING"):
            d.mString = value;
            break;

        case hashString("KEY-BOOL"):
            d.mBool = QVariant(value).toBool();
            break;

        case hashString("KEY-INT"):
            d.mInt = value.toInt();
            break;

        case hashString("KEY-FLOAT"):
            d.mFloat = value.toFloat();
            break;

        default:
            break;
        }
    }

    return d;
}

I suppose, this solution is more time efficient because it compares integers instead of strings, although it computes a hash value of every second list element. To reason about performance improvements, one should test both solutions with actual data.

Note that the hashString overload with const char * parameter must be constexpr to appear after the case. The c++14 requirement is due to the hashCString implementation given merely as an example. It has the for loop, and it will likely not compile with c++11.

Is there a way to tell the caller of the function that something had gone wrong?

This problem has no universal solution. An actual solution depends on particular safety requirements. In general, I would recommend checking error handling guidelines.