diff --git a/src/backend/common/transforms/NativeTransformer.ts b/src/backend/common/transforms/NativeTransformer.ts
index 59bdbc7a..275f9f1f 100644
--- a/src/backend/common/transforms/NativeTransformer.ts
+++ b/src/backend/common/transforms/NativeTransformer.ts
@@ -9,10 +9,26 @@ import { TransformerOptions } from "./AbstractTransformer.js";
 import { DELIMITERS_NO_AMP } from "../infrastructure/Atomic.js";
 import { asArray } from "../../utils/DataUtils.js";
 
+export type ArtistParseSource = 'artists' | 'title'
+
+export const asArtistParseSource = (str: string): ArtistParseSource => {
+    const clean = str.trim().toLocaleLowerCase();
+    switch(clean) {
+        case 'track':
+        case 'title':
+            return 'title';
+        case 'artist':
+        case 'artists':
+            return 'artists';
+    }
+    throw new Error(`ArtistParseSource must be one of 'artist' or 'title', given: ${clean}`);
+}
+
 export interface NativeTransformerData {
     delimiters?: string[]
-    extraDelimiters?: string[]
-    ignoreArtists?: string[]
+    delimitersExtra?: string[]
+    artistsIgnore?: string[]
+    artistsParseFrom?: ArtistParseSource[]
 }
 
 export type NativeTransformerConfig = TransformerCommon<NativeTransformerData>;
@@ -23,6 +39,7 @@ export default class NativeTransformer extends AtomicPartsTransformer<ExternalMe
 
     ignoreArtistsRegex: RegExp[] = [];
     delimiters?: string[]
+    parseArtistsFrom: ArtistParseSource[]
 
     public constructor(config: NativeTransformerConfig, options: TransformerOptions) {
         super(config, options);
@@ -35,33 +52,39 @@ export default class NativeTransformer extends AtomicPartsTransformer<ExternalMe
         if(this.config.data === null || typeof this.config.data !== 'object') {
             throw new Error('Native Transformer data should be an object or not defined.');
         }
-        if(this.config.data.ignoreArtists !== undefined) {
-            this.config.data.ignoreArtists = asArray(this.config.data.ignoreArtists);
-            const nonStr = this.config.data.ignoreArtists.filter(x => typeof x !== 'string');
+        if(this.config.data.artistsIgnore !== undefined) {
+            this.config.data.artistsIgnore = asArray(this.config.data.artistsIgnore);
+            const nonStr = this.config.data.artistsIgnore.filter(x => typeof x !== 'string');
             if(nonStr.length > 0) {
                 throw new Error(`ignoreArtists must be an array of strings but non-strings found: ${nonStr.map(x => (x as unknown).toString()).join(' | ')}`)
             }
-            for(const i of this.config.data.ignoreArtists) {
+            for(const i of this.config.data.artistsIgnore) {
                 try {
                     this.ignoreArtistsRegex.push(parseToRegexOrLiteralSearch(i));
                 } catch (e) {
                     throw new Error(`Could not convert ignoreArtist string to regex (or literal): ${i}`);
                 }
             }
-            this.logger.debug(`Ignoring artists using ${this.config.data.ignoreArtists.length} rules`);
+            this.logger.debug(`Ignoring artists using ${this.config.data.artistsIgnore.length} rules`);
         }
 
         if(this.config.data.delimiters !== undefined) {
             this.delimiters = asArray(this.config.data.delimiters);
-            this.logger.debug(`Using user-defined delimiters '${this.config.data.extraDelimiters.join(' ')}' instead of built-ins`);
-        } else if(this.config.data.extraDelimiters !== undefined) {
-            this.delimiters = [...DELIMITERS_NO_AMP, ...(asArray(this.config.data.extraDelimiters))];
-            this.logger.debug(`Using extra delimiters '${this.config.data.extraDelimiters.join(' ')}' with built-in delimiters '${DELIMITERS_NO_AMP.join(' ')}'`);
+            this.logger.debug(`Using user-defined delimiters '${this.config.data.delimitersExtra.join(' ')}' instead of built-ins`);
+        } else if(this.config.data.delimitersExtra !== undefined) {
+            this.delimiters = [...DELIMITERS_NO_AMP, ...(asArray(this.config.data.delimitersExtra))];
+            this.logger.debug(`Using extra delimiters '${this.config.data.delimitersExtra.join(' ')}' with built-in delimiters '${DELIMITERS_NO_AMP.join(' ')}'`);
         }
 
         if(this.delimiters !== undefined) {
             this.delimiters.map(x => x.trim());
         }
+
+        if(this.config.data.artistsParseFrom !== undefined) {
+            const arr = asArray(this.config.data.artistsParseFrom);
+            this.parseArtistsFrom = arr.map(asArtistParseSource);
+        }
+        this.logger.debug(`Will try to parse artists from ${this.parseArtistsFrom.join(' and ')} string`);
     }
 
     protected doParseConfig(data: StageConfig) {
@@ -94,7 +117,11 @@ export default class NativeTransformer extends AtomicPartsTransformer<ExternalMe
 
     public async getTransformerData(play: PlayObject): Promise<PlayObject> {
         let artists = [];
-        if (play.data.artists.length === 1) {
+        const {
+            artistsParseFrom: parseArtistsFrom = ['artists', 'title']
+        } = this.config.data;
+
+        if (play.data.artists.length === 1 && parseArtistsFrom.includes('artists')) {
             const matchedIgnoreArtists = this.ignoreArtistsRegex.map(x => ({reg: x.toString(), res: parseRegexSingle(x, play.data.artists[0])})).filter(x => x !== undefined);
             if(matchedIgnoreArtists.length > 0) {
                 this.logger.debug(`Will not parse artist because it matched an ignore regex:\n${matchedIgnoreArtists.map(x => `Reg: ${x.reg} => ${x.res.match}`).join('\n')}`)
@@ -114,10 +141,13 @@ export default class NativeTransformer extends AtomicPartsTransformer<ExternalMe
             }
         }
 
-        const trackArtists = parseTrackCredits(play.data.track, this.delimiters);
-        if (trackArtists !== undefined && trackArtists.secondary !== undefined) {
-            artists = artists.concat(trackArtists.secondary);
+        if(parseArtistsFrom.includes('title')) {
+            const trackArtists = parseTrackCredits(play.data.track, this.delimiters);
+            if (trackArtists !== undefined && trackArtists.secondary !== undefined) {
+                artists = artists.concat(trackArtists.secondary);
+            }
         }
+
         artists = uniqueNormalizedStrArr([...artists]);
 
         return {
diff --git a/src/backend/tests/component/transformers.test.ts b/src/backend/tests/component/transformers.test.ts
index a9f94696..b30a257c 100644
--- a/src/backend/tests/component/transformers.test.ts
+++ b/src/backend/tests/component/transformers.test.ts
@@ -420,7 +420,7 @@ describe('Play Transforms', function () {
 
             const [str, primaries, secondaries] = generateArtistsStr({primary: {max: 3, ambiguousJoinedNames: true, trailingAmpersand: true, finalJoiner: false}});
 
-            const t = new NativeTransformer({name: 'test', type: 'native', data: {ignoreArtists: [str]}}, {logger: loggerTest, cache: memorycache()});
+            const t = new NativeTransformer({name: 'test', type: 'native', data: {artistsIgnore: [str]}}, {logger: loggerTest, cache: memorycache()});
 
             await t.tryInitialize();
 
@@ -441,7 +441,7 @@ describe('Play Transforms', function () {
                 finalJoiner: false
             }});
 
-            const t = new NativeTransformer({name: 'test', type: 'native', data: {extraDelimiters: ['•']}}, {logger: loggerTest, cache: memorycache()});
+            const t = new NativeTransformer({name: 'test', type: 'native', data: {delimitersExtra: ['•']}}, {logger: loggerTest, cache: memorycache()});
 
             await t.tryInitialize();