n8n-nodes-upload-post 0.1.55 → 0.2.0

package/README.md

@@ -77,6 +77,11 @@ The node provides the following operations grouped for clarity:
   - Parameters: Request ID, Platform (optional filter).
 - **Get Post Analytics by Platform ID**: Per-post metrics for a post published outside Upload-Post.
   - Parameters: Platform Post ID, Platform, Profile Username.
+- **Get Cached Post Analytics**: Replays per-post metrics already fetched, instead of querying the platforms again, so it is not subject to the live analytics rate limit (100 requests / 5 minutes). Only contains posts previously fetched through a live per-post endpoint; there is no background refresh, so captured_at is the last time that post was read live.
+  - Parameters: Profile Username (required), Platform (optional filter), Limit (default 50, max 200), Cursor, Since / Until (`YYYY-MM-DD`, defaults to the last 30 days).
+  - Values are only as fresh as your last live read — check `captured_at` on each post. Use **Get Post Analytics** for a just-published post and this operation for bulk or historical reads.
+  - Paginate by passing the `next_cursor` from the previous response as `Cursor` while `has_more` is true.
+  - Supported: Facebook, Instagram, LinkedIn, Pinterest, Reddit, Threads, TikTok, YouTube. X (Twitter) is not cached.
 - **Get Total Impressions**: Impressions aggregated across connected platforms.
   - Parameters: Profile Username, Period or Start/End Date, Platforms, Breakdown.
 - **Get Platform Metrics**: Lists which metrics each platform exposes.
@@ -102,9 +107,12 @@ The node provides the following operations grouped for clarity:
 - **Delete User**: Delete an existing user profile.
   - Parameters: Username to delete.
 - **Generate JWT (for platform integration)**: Generate a connection URL (JWT) for a given profile so the user can link social accounts.
-  - Parameters: User Identifier, optional redirect URL, logo image URL, redirect button text, platform restrictions.
+  - Parameters: User Identifier, optional redirect URL, logo image URL, redirect button text, platform restrictions, calendar options, connect title/description, language, UI labels.
+  - **Language**: forces the connection page language. Supported: English, Spanish, German, French, Portuguese, Polish, Turkish. Leave on Auto-Detect to use the visitor's browser language (falls back to English).
+  - **UI Labels**: white-label overrides for individual connection page texts, as key/value pairs (sent as `ui_labels`). The key is an i18n dot-path such as `connect.connectButton`, the value the replacement string. The API accepts up to 100 entries, keys matching `^[a-zA-Z0-9_.]+$` and values of up to 300 characters, and rejects the request otherwise.
 - **Validate JWT (for platform integration)**: Validate a connection token from your backend.
   - Parameters: JWT token (password field).
+  - The API response is returned as-is; its `profile` object also carries the `ui_labels` map configured for that profile.
 
 Refer to the [Upload Post API Documentation](https://docs.upload-post.com) for detailed information on parameters and platform requirements.
 
@@ -160,6 +168,45 @@ If you saw duplicate posts on an older version of this node, upgrade: versions b
 - **Video Options**: Privacy level (Public/Mutual Friends/Followers/Self), disable duet/stitch/comments, cover timestamp (ms), brand content toggles, AI-generated content flag, post mode (Direct Post/Media Upload).
 - **Brand Content**: Separate toggles for paid partnerships and own business promotion.
 
+#### TikTok Advanced Video Options
+
+> **Capability-gated.** `GET /api/uploadposts/users` returns a `capabilities`
+> array on each TikTok account (`music`, `location`, `cover_image`,
+> `cover_timestamp`, `draft`, `photo_privacy`, `video_privacy`,
+> `inbox_fallback`, `profile_analytics`). If the connection does not declare the capability an option
+> needs, the API ignores that field, the post still publishes and the response
+> includes a per-field warning — reconnect the TikTok account to enable it.
+> These options are only sent when actually filled in, so leaving them at their
+> defaults keeps the previous behaviour.
+
+- **Music** (`music`): TikTok Music ID — the `id` of a track returned by `GET /api/uploadposts/tiktok/music/trending` or `GET /api/uploadposts/tiktok/music/search` (not its `commercial_music_id`) — plus music volume (0-100) and music start/end offsets in ms. The Music ID works on **video and photo** posts; the volume and the offsets are video-only, because TikTok's photo contract takes the track id alone.
+
+  To pick a track by name inside a workflow, put an **HTTP Request** node before
+  this one calling
+  `GET https://api.upload-post.com/api/uploadposts/tiktok/music/search?profile=<profile>&q=<song or artist>`
+  with the header `Authorization: Apikey <your key>`, and feed `tracks[0].id`
+  into TikTok Music ID. It also accepts `genre`, `country_code`, `date_range`
+  and `limit`. Note that TikTok has **no music search endpoint**: the search
+  runs over the trending charts Upload-Post caches per genre/country/period, so
+  it finds trending tracks, not TikTok's entire catalogue.
+- **Original Sound Volume**: Volume (0-100) of the video's own audio when music is added. Keep it above 0 so the original audio is not muted. Music volume and original sound volume are only sent when a Music ID is set.
+- **Location** (`location`): TikTok Location ID plus TikTok Location Name — TikTok requires both together. Works on video and photo posts.
+- **Cover Image URL** (`cover_image`): Custom cover image, takes priority over the cover timestamp. Video only.
+- **Is AI Generated**: AI-generated content disclosure. Works on video and photo posts.
+- **Upload to Draft** (`draft`): Sends the video to TikTok drafts instead of publishing; TikTok then ignores the rest of the post settings. Video only.
+
+> **Privacy level on TikTok.** `privacy_level` is accepted on video and photo
+> uploads alike (capabilities `video_privacy` / `photo_privacy`), but **TikTok
+> decides per account which values are available**: a private account is offered
+> Followers / Mutual Friends / Self Only and has no Public. Asking for one the
+> account does not have fails with `tiktok_privacy_unavailable`, and the error
+> lists the ones it does have. The **Account Default** option on the TikTok
+> Privacy Level (Video) field sends nothing and lets TikTok apply the account's
+> own setting — the only choice guaranteed to work on every account, and the
+> default for new nodes. Photo posts default to Public. To pick a value up front,
+> query `GET /api/uploadposts/tiktok/settings?profile=<profile>` from an HTTP
+> Request node and read `privacy_level_options`.
+
 #### YouTube
 - **Video Metadata**: Tags (comma-separated), category ID, privacy status (public/unlisted/private), embeddable, license, public stats viewable.
 - **Compliance**: Made for kids declaration, self-declared made for kids (COPPA), contains synthetic media (AI transparency), has paid product placement (FTC).

package/dist/nodes/UploadPost/UploadPost.node.js

@@ -394,6 +394,20 @@ const applyFacebookOptions = (ctx, operation, formData, isManualPlatform = false
         }
     }
 };
+const applySharedTiktokFields = (ctx, formData) => {
+    const musicId = ctx.node.getNodeParameter('tiktokMusicId', ctx.itemIndex, '');
+    if (musicId)
+        formData.tiktok_music_id = musicId;
+    const locationId = ctx.node.getNodeParameter('tiktokLocationId', ctx.itemIndex, '');
+    const locationName = ctx.node.getNodeParameter('tiktokLocationName', ctx.itemIndex, '');
+    if (locationId && locationName) {
+        formData.tiktok_location_id = locationId;
+        formData.tiktok_location_name = locationName;
+    }
+    const isAiGenerated = ctx.node.getNodeParameter('tiktokIsAiGenerated', ctx.itemIndex, false);
+    if (isAiGenerated)
+        formData.tiktok_is_ai_generated = 'true';
+};
 const applyTiktokOptions = (ctx, operation, formData) => {
     if (operation === 'uploadPhotos') {
         const autoAddMusic = ctx.node.getNodeParameter('tiktokAutoAddMusic', ctx.itemIndex, false);
@@ -410,6 +424,7 @@ const applyTiktokOptions = (ctx, operation, formData) => {
         if (photoDescription && formData.description === undefined) {
             formData.description = photoDescription;
         }
+        applySharedTiktokFields(ctx, formData);
     }
     else if (operation === 'uploadVideo') {
         const privacyLevel = ctx.node.getNodeParameter('tiktokPrivacyLevel', ctx.itemIndex, '');
@@ -432,6 +447,23 @@ const applyTiktokOptions = (ctx, operation, formData) => {
         formData.is_aigc = String(isAigc);
         if (postMode)
             formData.post_mode = postMode;
+        applySharedTiktokFields(ctx, formData);
+        if (formData.tiktok_music_id) {
+            formData.tiktok_music_volume = ctx.node.getNodeParameter('tiktokMusicVolume', ctx.itemIndex, 50);
+            formData.tiktok_original_sound_volume = ctx.node.getNodeParameter('tiktokOriginalSoundVolume', ctx.itemIndex, 50);
+            const musicStart = ctx.node.getNodeParameter('tiktokMusicStart', ctx.itemIndex, 0);
+            const musicEnd = ctx.node.getNodeParameter('tiktokMusicEnd', ctx.itemIndex, 0);
+            if (musicStart > 0)
+                formData.tiktok_music_start = musicStart;
+            if (musicEnd > 0)
+                formData.tiktok_music_end = musicEnd;
+        }
+        const coverImageUrl = ctx.node.getNodeParameter('tiktokCoverImageUrl', ctx.itemIndex, '');
+        if (coverImageUrl)
+            formData.tiktok_cover_image_url = coverImageUrl;
+        const uploadToDraft = ctx.node.getNodeParameter('tiktokUploadToDraft', ctx.itemIndex, false);
+        if (uploadToDraft)
+            formData.tiktok_upload_to_draft = 'true';
     }
 };
 const applyInstagramOptions = async (ctx, operation, formData) => {
@@ -694,6 +726,13 @@ const applyGoogleBusinessOptions = (ctx, _operation, formData) => {
     const mediaFormat = ctx.node.getNodeParameter('gbpMediaFormat', ctx.itemIndex, '');
     if (mediaFormat)
         formData.gbp_media_format = mediaFormat;
+    const postType = ctx.node.getNodeParameter('gbpPostType', ctx.itemIndex, '');
+    if (postType) {
+        formData.gbp_post_type = postType;
+        const mediaCategory = ctx.node.getNodeParameter('gbpMediaCategory', ctx.itemIndex, '');
+        if (mediaCategory)
+            formData.gbp_media_category = mediaCategory;
+    }
     const ctaType = ctx.node.getNodeParameter('gbpCtaType', ctx.itemIndex, '');
     if (ctaType)
         formData.gbp_cta_type = ctaType;
@@ -965,6 +1004,33 @@ const buildMonitoringRequest = (ctx) => {
                 waitForCompletion: false,
             };
         }
+        case 'getCachedPostAnalytics': {
+            const qs = {
+                user: ctx.node.getNodeParameter('cachedAnalyticsProfileUsername', ctx.itemIndex),
+            };
+            const platform = ctx.node.getNodeParameter('cachedAnalyticsPlatform', ctx.itemIndex, '');
+            if (platform)
+                qs.platform = platform;
+            const limit = ctx.node.getNodeParameter('cachedAnalyticsLimit', ctx.itemIndex, 50);
+            if (limit)
+                qs.limit = limit;
+            const cursor = ctx.node.getNodeParameter('cachedAnalyticsCursor', ctx.itemIndex, '');
+            if (cursor)
+                qs.cursor = cursor;
+            const since = ctx.node.getNodeParameter('cachedAnalyticsSince', ctx.itemIndex, '');
+            if (since)
+                qs.since = since;
+            const until = ctx.node.getNodeParameter('cachedAnalyticsUntil', ctx.itemIndex, '');
+            if (until)
+                qs.until = until;
+            return {
+                endpoint: '/uploadposts/post-analytics/cached',
+                method: 'GET',
+                qs,
+                isUploadOperation: false,
+                waitForCompletion: false,
+            };
+        }
         case 'getPlatformMetrics': {
             return {
                 endpoint: '/uploadposts/platform-metrics',
@@ -1051,6 +1117,19 @@ const buildMonitoringRequest = (ctx) => {
             });
     }
 };
+const collectUiLabels = (ctx) => {
+    var _a, _b;
+    const raw = ctx.node.getNodeParameter('uiLabels', ctx.itemIndex, {});
+    const entries = Array.isArray(raw.label) ? raw.label : [];
+    const uiLabels = {};
+    for (const entry of entries) {
+        const key = String((_a = entry.key) !== null && _a !== void 0 ? _a : '').trim();
+        if (!key)
+            continue;
+        uiLabels[key] = String((_b = entry.value) !== null && _b !== void 0 ? _b : '');
+    }
+    return uiLabels;
+};
 const buildUserRequest = async (ctx) => {
     switch (ctx.operation) {
         case 'listUsers':
@@ -1108,6 +1187,9 @@ const buildUserRequest = async (ctx) => {
                 body.connect_description = connectDescription;
             if (language)
                 body.language = language;
+            const uiLabels = collectUiLabels(ctx);
+            if (Object.keys(uiLabels).length > 0)
+                body.ui_labels = uiLabels;
             return {
                 endpoint: '/uploadposts/users/generate-jwt',
                 method: 'POST',
@@ -1384,6 +1466,7 @@ class UploadPost {
                         { name: 'Cancel Scheduled Post', value: 'cancelScheduled', action: 'Cancel scheduled post', description: 'Cancel a scheduled post by its job ID' },
                         { name: 'Edit Scheduled Post', value: 'editScheduled', action: 'Edit scheduled post', description: 'Edit schedule details (like date/time) by job ID' },
                         { name: 'Get Analytics', value: 'getAnalytics', action: 'Get analytics', description: 'Retrieve aggregated analytics for uploads' },
+                        { name: 'Get Cached Post Analytics', value: 'getCachedPostAnalytics', action: 'Get cached post analytics', description: 'Replay per-post metrics already fetched for a profile instead of querying the platforms again, so it is not subject to the live analytics rate limit (100 requests / 5 minutes). Only contains posts previously fetched through Get Post Analytics; there is no background refresh, so captured_at is the last time that post was read live. Use Get Post Analytics to refresh a post, and this operation for bulk re-reads.' },
                         { name: 'Get Job Status', value: 'getJobStatus', action: 'Get job status', description: 'Check the status of a scheduled or queued post using the job_id' },
                         { name: 'Get Platform Metrics', value: 'getPlatformMetrics', action: 'Get platform metrics', description: 'List the analytics metrics available for each platform' },
                         { name: 'Get Post Analytics', value: 'getPostAnalytics', action: 'Get post analytics', description: 'Retrieve per-post analytics for an upload using its request_id' },
@@ -2156,6 +2239,69 @@ class UploadPost {
                     description: 'Upload-Post profile that owns the connected account',
                     displayOptions: { show: { operation: ['getPostAnalyticsByPlatformId'] } },
                 },
+                {
+                    displayName: 'Profile Username',
+                    name: 'cachedAnalyticsProfileUsername',
+                    type: 'string',
+                    required: true,
+                    default: '',
+                    description: 'Profile username whose cached post metrics you want',
+                    displayOptions: { show: { operation: ['getCachedPostAnalytics'] } },
+                },
+                {
+                    displayName: 'Platform',
+                    name: 'cachedAnalyticsPlatform',
+                    type: 'options',
+                    options: [
+                        { name: 'All Platforms', value: '' },
+                        { name: 'Facebook', value: 'facebook' },
+                        { name: 'Instagram', value: 'instagram' },
+                        { name: 'LinkedIn', value: 'linkedin' },
+                        { name: 'Pinterest', value: 'pinterest' },
+                        { name: 'Reddit', value: 'reddit' },
+                        { name: 'Threads', value: 'threads' },
+                        { name: 'TikTok', value: 'tiktok' },
+                        { name: 'YouTube', value: 'youtube' },
+                    ],
+                    default: '',
+                    description: 'Restrict the result to a single platform. X (Twitter) is not available: the snapshot cache does not store it.',
+                    displayOptions: { show: { operation: ['getCachedPostAnalytics'] } },
+                },
+                {
+                    displayName: 'Limit',
+                    name: 'cachedAnalyticsLimit',
+                    type: 'number',
+                    typeOptions: { minValue: 1, maxValue: 200 },
+                    default: 50,
+                    description: 'Max number of results to return',
+                    displayOptions: { show: { operation: ['getCachedPostAnalytics'] } },
+                },
+                {
+                    displayName: 'Cursor',
+                    name: 'cachedAnalyticsCursor',
+                    type: 'string',
+                    default: '',
+                    description: 'Opaque pagination cursor. Pass the next_cursor returned by the previous call to fetch the following page.',
+                    displayOptions: { show: { operation: ['getCachedPostAnalytics'] } },
+                },
+                {
+                    displayName: 'Since',
+                    name: 'cachedAnalyticsSince',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'YYYY-MM-DD',
+                    description: 'Start of the snapshot date range. Defaults to 30 days ago.',
+                    displayOptions: { show: { operation: ['getCachedPostAnalytics'] } },
+                },
+                {
+                    displayName: 'Until',
+                    name: 'cachedAnalyticsUntil',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'YYYY-MM-DD',
+                    description: 'End of the snapshot date range. Defaults to today.',
+                    displayOptions: { show: { operation: ['getCachedPostAnalytics'] } },
+                },
                 {
                     displayName: 'Profile Username',
                     name: 'impressionsProfileUsername',
@@ -2343,8 +2489,43 @@ class UploadPost {
                         { name: 'English', value: 'en' },
                         { name: 'French', value: 'fr' },
                         { name: 'German', value: 'de' },
+                        { name: 'Polish', value: 'pl' },
                         { name: 'Portuguese', value: 'pt' },
                         { name: 'Spanish', value: 'es' },
+                        { name: 'Turkish', value: 'tr' },
+                    ],
+                    displayOptions: { show: { operation: ['generateJwt'] } },
+                },
+                {
+                    displayName: 'UI Labels',
+                    name: 'uiLabels',
+                    type: 'fixedCollection',
+                    typeOptions: { multipleValues: true },
+                    placeholder: 'Add UI Label',
+                    default: {},
+                    description: 'Override individual texts of the connection page, for white-label integrations. Each entry is an i18n dot-path key (for example connect.connectButton) plus the replacement string, and is sent as ui_labels. The API accepts at most 100 entries, keys matching ^[a-zA-Z0-9_.]+$ and values of up to 300 characters, and returns an error otherwise.',
+                    options: [
+                        {
+                            displayName: 'Label',
+                            name: 'label',
+                            values: [
+                                {
+                                    displayName: 'Key',
+                                    name: 'key',
+                                    type: 'string',
+                                    default: '',
+                                    placeholder: 'connect.connectButton',
+                                    description: 'I18n dot-path key of the connection page text to override',
+                                },
+                                {
+                                    displayName: 'Value',
+                                    name: 'value',
+                                    type: 'string',
+                                    default: '',
+                                    description: 'Replacement text shown on the connection page',
+                                },
+                            ],
+                        },
                     ],
                     displayOptions: { show: { operation: ['generateJwt'] } },
                 },
@@ -2693,13 +2874,14 @@ class UploadPost {
                     name: 'tiktokPrivacyLevel',
                     type: 'options',
                     options: [
-                        { name: 'Public to Everyone', value: 'PUBLIC_TO_EVERYONE' },
-                        { name: 'Mutual Follow Friends', value: 'MUTUAL_FOLLOW_FRIENDS' },
+                        { name: 'Account Default', value: '' },
                         { name: 'Follower of Creator', value: 'FOLLOWER_OF_CREATOR' },
+                        { name: 'Mutual Follow Friends', value: 'MUTUAL_FOLLOW_FRIENDS' },
+                        { name: 'Public to Everyone', value: 'PUBLIC_TO_EVERYONE' },
                         { name: 'Self Only', value: 'SELF_ONLY' },
                     ],
-                    default: 'PUBLIC_TO_EVERYONE',
-                    description: 'Privacy setting for TikTok video (PUBLIC_TO_EVERYONE, MUTUAL_FOLLOW_FRIENDS, etc.). Only for Upload Video.',
+                    default: '',
+                    description: 'Privacy setting for the TikTok video. TikTok decides per account which levels are available: a private account has no Public to Everyone, and asking for one the account does not have fails with tiktok_privacy_unavailable listing the allowed ones. Account Default sends nothing and lets TikTok apply the account\'s own setting, which is the only value guaranteed to work on every account. Only for Upload Video.',
                     displayOptions: {
                         show: {
                             operation: ['uploadVideo'],
@@ -2802,6 +2984,140 @@ class UploadPost {
                         }
                     },
                 },
+                {
+                    displayName: 'TikTok Music ID',
+                    name: 'tiktokMusicId',
+                    type: 'string',
+                    default: '',
+                    description: 'Commercial Music Library track ID to add to the post: the ID field returned by the TikTok trending-music or music-search endpoint, not its commercial_music_id. To find a track by song or artist, call GET /api/uploadposts/tiktok/music/search from an HTTP Request node first. Works on video and photo posts alike, but a photo post takes the ID alone: the volume and trim options below are video-only. Needs the music capability on the TikTok connection (see capabilities in the user-profiles response); without it the field is ignored with a warning and the post still publishes. Leave empty to skip.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadVideo', 'uploadPhotos'],
+                            platform: ['tiktok', '__manual_platform__']
+                        }
+                    },
+                },
+                {
+                    displayName: 'TikTok Music Volume',
+                    name: 'tiktokMusicVolume',
+                    type: 'number',
+                    default: 50,
+                    typeOptions: { minValue: 0, maxValue: 100 },
+                    description: 'Volume (0-100) of the Commercial Music Library track. Only sent when a TikTok Music ID is set.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadVideo'],
+                            platform: ['tiktok', '__manual_platform__']
+                        }
+                    },
+                },
+                {
+                    displayName: 'TikTok Music Start (Ms)',
+                    name: 'tiktokMusicStart',
+                    type: 'number',
+                    default: 0,
+                    typeOptions: { minValue: 0 },
+                    description: 'Start offset (ms) of the music track. Only sent when a TikTok Music ID is set and this is above 0.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadVideo'],
+                            platform: ['tiktok', '__manual_platform__']
+                        }
+                    },
+                },
+                {
+                    displayName: 'TikTok Music End (Ms)',
+                    name: 'tiktokMusicEnd',
+                    type: 'number',
+                    default: 0,
+                    typeOptions: { minValue: 0 },
+                    description: 'End offset (ms) of the music track. Only sent when a TikTok Music ID is set and this is above 0.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadVideo'],
+                            platform: ['tiktok', '__manual_platform__']
+                        }
+                    },
+                },
+                {
+                    displayName: 'TikTok Original Sound Volume',
+                    name: 'tiktokOriginalSoundVolume',
+                    type: 'number',
+                    default: 50,
+                    typeOptions: { minValue: 0, maxValue: 100 },
+                    description: 'Volume (0-100) of the original video audio when music is added. Only sent when a TikTok Music ID is set. Keep it above 0 so the original audio is not muted.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadVideo'],
+                            platform: ['tiktok', '__manual_platform__']
+                        }
+                    },
+                },
+                {
+                    displayName: 'TikTok Location ID',
+                    name: 'tiktokLocationId',
+                    type: 'string',
+                    default: '',
+                    description: 'Location ID to tag on the post (video or photos). Needs the location capability on the TikTok connection (see capabilities in the user-profiles response) and a TikTok Location Name — the tag is only sent when both are filled in. Without the capability the field is ignored with a warning and the post still publishes. Leave empty to skip.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadVideo', 'uploadPhotos'],
+                            platform: ['tiktok', '__manual_platform__']
+                        }
+                    },
+                },
+                {
+                    displayName: 'TikTok Location Name',
+                    name: 'tiktokLocationName',
+                    type: 'string',
+                    default: '',
+                    description: 'Location name matching the TikTok Location ID. TikTok requires both together, so the location tag is only sent when this and the ID are both filled in.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadVideo', 'uploadPhotos'],
+                            platform: ['tiktok', '__manual_platform__']
+                        }
+                    },
+                },
+                {
+                    displayName: 'TikTok Cover Image URL',
+                    name: 'tiktokCoverImageUrl',
+                    type: 'string',
+                    default: '',
+                    description: 'Custom cover image URL for the video. Needs the cover_image capability on the TikTok connection (see capabilities in the user-profiles response); without it the field is ignored with a warning and the post still publishes. Takes priority over TikTok Cover Timestamp.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadVideo'],
+                            platform: ['tiktok', '__manual_platform__']
+                        }
+                    },
+                },
+                {
+                    displayName: 'TikTok Is AI Generated',
+                    name: 'tiktokIsAiGenerated',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Whether to disclose the post as AI-generated on TikTok. Works on video and photo posts. Only sent when enabled.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadVideo', 'uploadPhotos'],
+                            platform: ['tiktok', '__manual_platform__']
+                        }
+                    },
+                },
+                {
+                    displayName: 'TikTok Upload to Draft',
+                    name: 'tiktokUploadToDraft',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Whether to send the video to TikTok drafts instead of publishing it. Needs the draft capability on the TikTok connection (see capabilities in the user-profiles response); without it the field is ignored with a warning and the post still publishes. When enabled TikTok ignores the rest of the post settings.',
+                    displayOptions: {
+                        show: {
+                            operation: ['uploadVideo'],
+                            platform: ['tiktok', '__manual_platform__']
+                        }
+                    },
+                },
                 {
                     displayName: 'Instagram Media Type',
                     name: 'instagramMediaType',
@@ -2995,6 +3311,43 @@ class UploadPost {
                     description: 'Format of the attached media',
                     displayOptions: { show: { operation: ['uploadPhotos', 'uploadVideo', 'uploadText'], platform: ['google_business', '__manual_platform__'] } },
                 },
+                {
+                    displayName: 'Google Business Publish As',
+                    name: 'gbpPostType',
+                    type: 'options',
+                    options: [
+                        { name: 'Gallery', value: 'GALLERY' },
+                        { name: 'Local Post (Default)', value: '' },
+                        { name: 'Media', value: 'MEDIA' },
+                        { name: 'Photo', value: 'PHOTO' },
+                    ],
+                    default: '',
+                    description: 'Where the upload lands on the Google Business Profile. Local Post keeps the default behaviour and creates a post on the timeline. Media, Photo and Gallery all publish the image to the location Media/Gallery tab instead, without creating a Local Post.',
+                    displayOptions: { show: { operation: ['uploadPhotos', 'uploadVideo', 'uploadText'], platform: ['google_business', '__manual_platform__'] } },
+                },
+                {
+                    displayName: 'Google Business Media Category',
+                    name: 'gbpMediaCategory',
+                    type: 'options',
+                    options: [
+                        { name: 'Additional', value: 'ADDITIONAL' },
+                        { name: 'At Work', value: 'AT_WORK' },
+                        { name: 'Common Area', value: 'COMMON_AREA' },
+                        { name: 'Cover', value: 'COVER' },
+                        { name: 'Exterior', value: 'EXTERIOR' },
+                        { name: 'Food and Drink', value: 'FOOD_AND_DRINK' },
+                        { name: 'Interior', value: 'INTERIOR' },
+                        { name: 'Logo', value: 'LOGO' },
+                        { name: 'Menu', value: 'MENU' },
+                        { name: 'Product', value: 'PRODUCT' },
+                        { name: 'Profile', value: 'PROFILE' },
+                        { name: 'Rooms', value: 'ROOMS' },
+                        { name: 'Teams', value: 'TEAMS' },
+                    ],
+                    default: 'ADDITIONAL',
+                    description: 'Category the photo is filed under in the Media/Gallery tab. Only used when Publish As is Media, Photo or Gallery.',
+                    displayOptions: { show: { operation: ['uploadPhotos', 'uploadVideo', 'uploadText'], platform: ['google_business', '__manual_platform__'], gbpPostType: ['GALLERY', 'MEDIA', 'PHOTO'] } },
+                },
                 {
                     displayName: 'Google Business Call to Action',
                     name: 'gbpCtaType',