Release notes

2024-11

Removal of support for accessing recruitment agency information

On the 9th of December 2024, we will be removing support for accessing recruitment agency information from the SEEK API.The SEEK API previously supported the retrieval of recruitment agency information associated with a position opening through the PostingRequester type. This information was intended to help hirers understand which recruitment agency was responsible for a job ad, for jobs posted outside of the SEEK API. This functionality has seen limited usage, and is prone to confusion. Most SEEK hirers do not use recruitment agencies in this way, and so these changes will not affect the majority of users.This change will affect the following fields:
  • PostingRequester.roleCode will no longer have Agency as a valid value; it will always return Company. This field is now deprecated, and will be removed at a later date.
  • PostingRequester.id will no longer return an ID for a recruitment agency; it will now always be the ID of the hirer.
  • PostingRequester.name will no longer return the name of a recruitment agency; it will now always be the name of the hirer.
  • HiringOrganization.seekApiCapabilities will now never return null for agencies, as the HiringOrganization type will not be accessible for agency accounts.
  • The hiringOrganization query will not return information for recruitment agencies. If your software has stored IDs for recruitment agencies, they will no longer work.

2024-10

Rate limiting

On the 30th of November 2024, rate limiting will be introduced to the SEEK API. This will improve system stability by protecting against abuse and misuse.Rate limits are applied per query, mutation or attachment download endpoint. General rate limits are applied across the API to prevent denial of service and should not be triggered in general operation. Specific rate limits may apply to certain operations, such as those that are particularly resource-intensive.The rate limits have been designed with typical usage patterns in mind. No impact is anticipated to any existing integrations.When a rate limit is exceeded on a GraphQL query or mutation, the SEEK API will return a RATE_LIMITED error code. Similarly, when a rate limit is exceeded on an attachment download endpoint, the SEEK API will return a 429 Too Many Requests status code. We recommend that you update your software to handle these error scenarios gracefully. Refer to the GraphQL error response documentation for more information on how to handle errors.If you consistently encounter rate limiting or are planning to significantly increase your request volume, contact SEEK’s support team . We’ll work with you to resolve the issue and adjust rate limits if necessary.

2024-06

Home location in Optimised Apply

A candidate can add a home location to their SEEK Profile. We have added support to retrieve this attribute from a job application in Optimised Apply.
QueryVariablesResult
CopyGraphQL Explorer
query ($id: String!) {
  candidateProfile(id: $id) {
    candidate {
      person {
        communication {
          address {
            # Select other address fields as necessary
            formattedAddress
            countryCode
          }
        }
      }
    }
  }
}
A home location may be as specific as a suburb (Cremorne VIC 3121 AU), or as broad as a country (Poland). If you wish to use this attribute, your software will need to account for these differences in granularity. You may retrieve other address fields as appropriate; note that street-level detail is not currently available.

countryCode required for location inference

We have updated our schema for inferLocation query, now making the countryCode value mandatory for all requests.This field accepts a two-letter ISO 3166-1:2013 country code  of the location, in uppercase.Previously, countryCode was optional, but subsequent testing has demonstrated that countryCode significantly improves the quality of inference and avoids cases of incorrect locations being returned that impact hirer experience.No impact to existing implementations is expected.

2024-02

Updates for GraphQL over HTTP compatibility

On the 23rd March 2024, we will be making changes to the SEEK API to ensure compliance with the GraphQL over HTTP specification :
  • Previously, response bodies contained an Content-Type: application/json header. This will be changed to Content-Type: application/json; charset=utf-8, as recommended  by the specification. The encoding of the body is not changing, and will continue to be UTF-8. We advise your software not to take hard dependencies on the exact format of the Content-Type response header, as it may change in the future. For example, application/graphql-response+json; charset=utf-8 may be used in the future. We advise you to check that your software is resilient to changes in the Content-Type response header before the 23rd March 2024.
  • Previously, the SEEK API accepted non-standard request bodies containing variables as a JSON-stringified object. This may look like {"query": "...", "variables": "{...}"}. This support will be removed, as it is not supported by the specification . We require your software to use the standard request body format. This may look like {"query": "...", "variables": {...}}. We advise you to check that your software is not using this non-standard request format before the 23rd March 2024.

2023-11

Removal of CommissionOnly pay type

On 21st December 2023, the CommissionOnly pay type will be removed from the SEEK API. This pay type sees near-zero usage and can lead to compliance issues with local labour laws and our terms of use.From this date, if a hirer selects the ‘Commission only’ pay option in your software, the SEEK API will fail their subsequent request to post a job ad. We highly recommend that you remove or disable this option from your job posting workflow. See our pay type documentation for more information on valid pay types.

2023-10

Stricter end date validation on job ad edits

On 27 October 2023, the updatePostedPositionProfile mutation will be updated with stricter synchronous validation of the end date. Your software will receive a BAD_USER_INPUT error if the supplied date exceeds the maximum duration of the job ad, with a response that looks similar to the following:
JSON
Copy
{
  "errors": [
    {
      "message": "Invalid posting end date",
      "extensions": {
        "code": "BAD_USER_INPUT",
        "invalidFields": {
          "/input/positionProfile/postingInstructions/0/end": "Must not be more than 30 days from 2020-01-01T00:00:00.000Z"
        }
      }
    }
  ]
}
This validation rule has always been enforced on our other posting mutations and will not affect integrations that already limit the end date. We have proactively reached out to partners that systematically provided invalid end dates to the SEEK API. Other partners may review their job edit functionality to ensure that clients can view validation errors and correct the end date where necessary.

2023-05

Partner token expiry time will be reduced

What is the change?On the 2nd of June at 9am AEST, the lifetime of SEEK API partner tokens will be reduced from 24 hours to 30 minutes. Your hirers may be unable to post job ads and receive candidate applications if your SEEK integration does not comply with token expiry best practices after this date.Why is this happening?This change is a routine security upgrade to safeguard both SEEK and our partners in the event of a compromised API credential.Action required from partnersNo action is required if your software caches partner tokens based on the number of seconds specified in the expires_in of the partner token response.If your software has hardcoded the token’s expiry or you are not currently caching partner tokens, you must update it to cache dynamically as described in our partner token documentation.When do partners need to make this change by?In line with the SEEK API terms , this change needs to be completed within 30 days (before the 2nd of June) to avoid hirer impact. It is estimated to take less than 1 day of effort. Reach out if you have any concerns with the above change. Subscribe to our release notes and status page  to be notified of future updates.

2023-01

Replay events by ID

We’ve extended the replayWebhookSubscription mutation with a new eventIds argument that can be used to replay events by their IDs.
MutationVariables
CopyGraphQL Explorer
mutation (
  $webhookSubscription: ReplayWebhookSubscription_SubscriptionInput!
  $eventIds: [String!]
) {
  replayWebhookSubscription(
    input: { webhookSubscription: $webhookSubscription, eventIds: $eventIds }
  ) {
    webhookSubscription {
      id {
        value
      }
    }
  }
}
This functionality has been packaged into the Developer Dashboard’s webhooks page where users can now select individual events to replay under the Events tab of each subscription.

2022-12

Relaxed string length limits

We have relaxed our length validation on String input fields. Previously, string lengths were measured and specified in terms of bytes in UTF-8 encoding. This was stricter than common validation approaches on the web, including the HTML maxlength attribute  and JavaScript String.length property .Now, the SEEK API measures and specifies string lengths in terms of Unicode code points or colloquially characters. This is a closer match to the graphemes visible to an end user, and should provide more equitable support for other scripts and special characters.See string lengths for more information.

2022-11

Webhook Playground

We’ve added a Webhook Playground to the Developer Dashboard that allows you to send a variety of mock events to your webhook endpoint and review the response received by the SEEK API.The mock events sent using this tool contain references to mock objects that can be queried with Playground credentials.This will allow you to develop your software with a much faster feedback loop, since you can easily send a mock event at the click of a button, rather than having to perform any real actions on SEEK.

2022-10

Email parsing retirement

We have retired the SEEK API’s legacy compatibility with email parsing integrations. SEEK will no longer send plain-text job application emails to an email address nominated on the job ad or hirer account. Note that this does not affect the rich HTML emails that can be configured on the SEEK employer website .The ApplicationMethodInput.applicationEmail field is ignored when posting or updating a job ad. Remove this field from your requests, even if you are sending a null value:
Diff
Copy
{
  "postingInstructions": [
-   {
-     "applicationEmail": null
-   }
  ]
}
The ApplicationMethod.applicationEmail field is `null`ed out when querying a job ad. Remove this field from your requests:
Diff
Copy
query {
  positionProfile {
    postingInstructions {
      applicationMethods {
-       applicationEmail {
-         address
-       }
        applicationUri
      }
    }
  }
}
We are actively working with partners who are still sending non-compliant requests. These fields will be formally removed from our GraphQL schema once remediation is complete.

Extended location hierarchy for Asia

We’ve extended our location hierarchy and location suggest with increased granularity in the following regions where the SEEK Group operates:
Code
Name
HK
Hong Kong
ID
Indonesia
MY
Malaysia
PH
The Philippines
SG
Singapore
TH
Thailand
The hierarchy only extends to the country level (e.g. Fiji) outside of our core Asia-Pacific locations.This enhances efficiency and accuracy when posting and searching for international jobs on the SEEK Australia & New Zealand marketplace, and lays the groundwork for the SEEK API to support Jobstreet & Jobsdb markets in future.For the time being, job ads posted to deprecated locations will be mapped to the corresponding new locations and will continue to function as expected across the SEEK API. If you’re using the locationSuggestions query, you will automatically receive our new locations and will not have to modify your integration. If you’re caching locations or using a static mapping to map from your internal location hierarchy, we will contact you at a future date to refresh your data before we remove support for deprecated locations.

2022-09

Ad Selection Panel contract bar and info icons

We have removed contract bar and info icons from the Ad Selection Panel to keep it clean and simple. The contract bar UI component was shown when a hirer is on a contract. Info icons were used to show more information about the ad products.Hirers will still be informed when they have a contract with SEEK through the checkout summary displayed upon selecting an ad product.

2022-05

Webhook event payload hirerId field

We’ve extended the webhook event payload with a new hirerId field.This field is only available on signed webhook subscriptions. This will allow your software to efficiently filter or forward events on a per-hirer basis for partner-scoped subscriptions instead of requiring a follow up query.

2022-03

Job ad preview

We’ve extended Job Posting with the ability to preview a job ad before it’s posted or updated. This allows the hirer to understand how their job ad would be displayed in SEEK’s search results and job details page.
QueryVariablesResult
CopyGraphQL Explorer
query ($positionProfile: PostedPositionProfilePreview_PositionProfileInput!) {
  postedPositionProfilePreview(positionProfile: $positionProfile) {
    previewUri {
      url
    }
  }
}

2022-02

ApplicationQuestionInput.questionHtml limit increased

The maximum size of the ApplicationQuestionInput.questionHtml field has been increased to 1,000 bytes in UTF-8 encoding.We’ve modified this limit to support compliance questions that are non-trivial to reword due to legal implications; we still discourage long questions in the general case as they negatively impact the candidate experience. Note that the increase does not apply to the ApplicationPrivacyConsentInput.descriptionHtml field.See our questionnaire limits for more information.

Updated messaging for ad selection with GraphQL

We’ve updated the guidance for custom Ad Selection Panels to help hirers understand how prices are set by SEEK:
  • We’ve provided instructions on how to display a scheduled pricing caveat and trigger a tooltip explaining how SEEK sets ad prices.
  • We’ve updated the sample images to show how the caveat and tooltip could be shown to the users.
This reflects the changes recently made to the SEEK-built Ad Selection Panel’s tooltip. If you’ve implemented a custom Ad Selection Panel you should incorporate the updated messaging into your software, especially if your software supports scheduling job ads to post on SEEK on a future date.See the “Scheduling pricing caveat” and “How are prices set” sections of the field mapping documentation for further guidance.

Ad Selection Panel tooltip

We’ve added a new caveat under the ad products in Ad Selection Panel to accommodate the case where your software can schedule job ads to post on SEEK on a future date.The caveat states that ”Ad prices shown represent today’s prices only. If you schedule your job ad for a future date, you acknowledge and agree you’ll be charged the price of that ad at the date it’s published on SEEK’s website.”The ”How are prices set?” link has also been replaced by the new info icon in the caveat.

2021-12

Migrating from GraphQL Playground to GraphQL Explorer

We have added the ability to instantly run queries and mutations against the Playground environment from within the Developer Dashboard. Previously, you would’ve had to manually request a partner token and enter it on the GraphQL Playground.This new feature replaces https://graphql.seek.com/graphql  with https://developer.seek.com/manage/graphql-explorer for querying the Playground environment.If you were using https://graphql.seek.com/graphql  with live credentials, we recommend switching to Postman or another similar tool.

Replay events prior to subscription

We’ve updated the replayWebhookSubscription mutation to replay events that were emitted prior to a subscription or a hirer relationship being created. This allows you to backfill events for a hirer without having to contact SEEK.To accommodate this change, the fields in replayWebhookSubscription filter input are now mandatory. In addition, a hirerId must be provided for partner-scoped subscriptions when the field replayDeliveredEventsIndicator is true.This is also available in the Developer Dashboard’s webhooks page and can be triggered by toggling the Include delivered events checkbox and providing a hirer.

2021-11

AdvertisementDetails limit lowered

The maximum size of the AdvertisementDetails position description has been lowered from 20,000 bytes to 15,000 bytes in UTF-8 encoding. This aligns the SEEK API with the corresponding limit on the SEEK Employer website .Our analysis of job posting behaviour over the past 6 months indicates that fewer than 0.005% of job ads would be affected. If your software includes validations for the previous limit you’re encouraged to update to the new limit.

Downloading hirer list CSVs

The Developer Dashboard’s hirers page now supports generating a CSV of all the SEEK hirers you have an active relationship with. Previously, you would’ve had to contact SEEK for a hirer spreadsheet or use the Developer Dashboard’s web interface.The CSV can be generated by clicking the “Download CSV” button on the top right corner of the page’s “Search all hirers” section. This will respect the current hirer search filter; ensure you clear the filters if you want a list of all hirers.

2021-10

Self-service credential management

We’ve added the ability to provision and rotate SEEK API client credentials to the Developer Dashboard. Previously, you’d have to contact SEEK to manage your credentials.See our revised integration process to learn more, and jump to the Developer Dashboard’s credentials page to get started.

Content discoverability improvements

We’ve made a handful of improvements to the discoverability of content on the Developer Site:
  1. Site search is now available on every page
  2. Search results can now deep link to the relevant page section
  3. Content is now indexable by external search engines like Google

Ad Selection Panel maximum width

We removed the maximum width of the Ad Selection Panel to give your software control over the panel’s width. Now the panel will inherit the width of the containerNode’s parent. If you don’t have any preference for the panel’s width, we recommend that you add a max-width: 822px style to the parent of the containerNode.
HTML
Copy
<div style="max-width: 822px;">
  <div id="seekWidget1ContainerDiv"></div>
</div>

2021-09

PostedPositionProfile.seekCreatedBySelfIndicator field

The SEEK API provides access to the job ads and candidate applications of your hirers. This may include job ads posted directly by a hirer on the SEEK employer website.While we recommend handling job ads and candidate applications posted outside of your software, we understand that this isn’t always possible depending on the design of your software. The new PostedPositionProfile.seekCreatedBySelfIndicator field allows you to identify whether your software posted a given job ad.See the updated Job ads posted outside of your software documentation for guidance on using this field.

2021-08

CandidateProfile.associatedPositionProfile field

When retrieving a candidate profile from the SEEK API, you typically need to select additional fields to attribute it to a position and hirer. Previously, this required indirection through the CandidateProfile.associatedPositionOpenings field, which was generally unintuitive and inefficiently retrieved all position profiles for the opening.The new CandidateProfile.associatedPositionProfile field allows you to directly select the position associated with a candidate application or profile purchase:
Diff
Copy
query ($id: String!) {
      candidateProfile(id: $id) {
+       associatedPositionProfile {
-       associatedPositionOpenings {
-         positionOpening {
-           positionProfiles {
              seekHirerJobReference
              positionOrganizations {
                id {
                  value
                }
              }
-             positionUri
-           }
-         }
-         positionUri
        }
      }
    }

Hirer Relationship Changed Events

To use the SEEK API on behalf of a given hirer, you need to have the appropriate hirer relationships configured. Keeping these relationships up to date was difficult, as changes made after your initial integration had to be manually communicated by SEEK.You might have addressed this problem by asking SEEK’s customer support team for spreadsheets of the current state of relationships, or maybe by periodically querying the hiringOrganizations query and calculating a diff.To make this easier, we’ve introduced a new HirerRelationshipChanged event type to the SEEK API. Like existing event types, you can create a webhook subscription that will listen for new HirerRelationshipChanged events and use them to automatically update your software.A sample event might look like this:
JSON
Copy
{
  "events": [
    {
      "id": "seekAnzPublicTest:event:events:RJrWs6Kw13TvACTTXG6qZg",
      "type": "HirerRelationshipChanged",


      "createDateTime": "2020-10-20T23:13:58.804Z",


      "hirerId": "seekAnzPublicTest:organization:seek:93WyyF1h"
    }
  ],
  "subscriptionId": "seekAnzPublicTest:webhookSubscription:events:RNzsabxEX56cuRepCD9A8j",
  "url": "https://example.com/webhook"
}
You can then use the hirerId contained in the event to get the current state of the relationship from the hiringOrganization query.For more information, see the events section of the hirer relationships documentation.

2021-07

Ad Selection Panel theme

We’ve extended the Ad Selection Panel to support custom styling via theme properties provided to the render method. All the theme properties are optional and have default values.Here is an example of how to specify the theme properties:
JavaScript
Copy
SEEKAdPostingWidget.render(document.getElementById('seekWidget1ContainerDiv'), {
  mode: 'Create',
  onChange: function (event) {},
  getAuthToken: function () {
    return Promise.resolve('browser token');
  },
  draftAdvertisement: {
    positionTitle: 'Developer',
    jobCategoryId: 'seekAnzPublicTest:jobCategory:seek:2EFstqFvP',
    positionLocationId: 'seekAnzPublicTest:location:seek:2TCFhBtw9',
    hirerJobReference: 'Premium521'
  },
  theme: {
    selectionColor: '#e82b85',
    linkColor: '#e82b85',
    contractBarPrimaryBackgroundColor: '#e82b85',
    contractBarSecondaryBackgroundColor: '#f6d2e0',
    errorColor: '#ff0000'
  }
});
See the Ad Selection Panel page for more information on each theme property.

2021-06

Application questionnaire input limits

We’ve tightened the byte limit on String input fields of the createApplicationQuestionnaire mutation from 2,048 to 255 bytes in UTF-8 encoding. This aligns with the default limit for the SEEK API.

self query

We’ve added a self query to return information about an access token’s organizations.This can be a convenient alternative to the hiringOrganization query when working with browser tokens. Instead of needing to specify the hirer ID explicitly, it returns the SEEK hirer the browser token is scoped to.
QueryResult
CopyGraphQL Explorer
query {
  self {
    hirer {
      id {
        value
      }
      name
      seekApiCapabilities {
        relationshipTypeCodes
        applicationMethodCodes
      }
    }
  }
}

2021-05

Ad Selection Panel now returns paymentDueExcludingTax

We’ve introduced a paymentDueExcludingTax property in the onChange callback for the Ad Selection Panel which will give your software the pricing information needed to update invoicing systems if necessary.
JavaScript
Copy
SEEKAdPostingWidget.render(document.getElementById('seekWidget1ContainerDiv'), {
  mode: 'Create',
  onChange: function (event) {
    const { advertisement } = event;
    const { paymentDueExcludingTax } = advertisement;


    console.log(`$${paymentDueExcludingTax.value} ${paymentDueExcludingTax.currency} will be invoiced to the hirer`);
  },
  getAuthToken: function () {
    return Promise.resolve('browser token');
  },
  draftAdvertisement: {...},
});

Update webhook subscription conflicts

We’ve introduced a new result format for updateWebhookSubscriptionDeliveryConfiguration.Webhook subscriptions must be unique based on their schemeId, eventTypeCode, hirerId & url. Attempting to create a duplicate webhook subscription with createWebhookSubscription would correctly return a mutation conflict. However, we didn’t properly handle updating a webhook subscription’s url to conflict with an existing subscription.💥 If your software uses updateWebhookSubscriptionDeliveryConfiguration, update the selection set to account for this change:
GraphQL
Copy
mutation($input: UpdateWebhookSubscriptionDeliveryConfigurationInput!) {
  updateWebhookSubscriptionDeliveryConfiguration(input: $input) {
-     webhookSubscription {
-       url
-       maxEventsPerAttempt
-     }
+     __typename
+     ... on UpdateWebhookSubscriptionDeliveryConfigurationPayload_Success {
+       webhookSubscription {
+         url
+         maxEventsPerAttempt
+       }
+     }
+     ... on UpdateWebhookSubscriptionDeliveryConfigurationPayload_Conflict {
+       conflictingWebhookSubscription {
+         id {
+           value
+         }
+       }
    }
  }
}
Then, update your code to check for conflicts in one of two new ways:
JavaScript
Copy
if (
   // Option 1: test for existence of conflict field
   response.data?.conflictingWebhookSubscription
   // Option 2: test name of the response type
   response.data?.__typename === 'CreateWebhookSubscriptionDeliveryConfigurationPayload_Conflict'
) {
  // Handle conflict here
}

Hirer configuration queries

SEEK’s support team configures hirers to work with the SEEK API:Previously, integration partners haven’t had visibility into SEEK’s configuration. This required manual reconciliation with our partners to avoid unexpected failures.We’ve extended the SEEK API to support automatically detecting hirer configuration:
  • The HiringOrganization object now has a seekApiCapabilities field. This allows you to query a hirer’s active relationships and allowed application methods.You can retrieve a HiringOrganization using either the hiringOrganization query or the seekAnzAdvertiser query:
    By hirer IDBy SEEK advertiser ID
    CopyGraphQL Explorer
    query ($id: String!) {
      hiringOrganization(id: $id) {
        name
        seekApiCapabilities {
          relationshipTypeCodes
          applicationMethodCodes
        }
      }
    }
  • The new hiringOrganizations query allows you to list all the SEEK hirers you have an active relationship with. You can optionally filter on the hirer’s name or specific relationship types.You can use this to retrieve a complete list of your SEEK hirers, including their identifiers and API capabilities:
    QueryVariablesResult
    CopyGraphQL Explorer
    query ($schemeId: String!, $first: Int) {
      hiringOrganizations(schemeId: $schemeId, first: $first) {
        edges {
          node {
            id {
              value
            }
            name
            seekApiCapabilities {
              relationshipTypeCodes
              applicationMethodCodes
            }
          }
        }
        pageInfo {
          hasNextPage
          endCursor
        }
      }
    }

2021-04

Mutation input field limits

A default maximum length for String mutation input fields is now documented in the SEEK API’s request limits. Exceptions to this default are explicitly documented in the GraphQL schema.An operation containing an input field that exceeds its length limit will receive a BAD_USER_INPUT error response.

PositionProfileClosed event

We’ve added a new PositionProfileClosed event that’s emitted whenever a job ad has been closed.It’s recommended that you update your software’s internal state based on PositionProfileClosed events instead of scheduled end dates. This ensures your software remains synchronised with SEEK, particularly when a hirer contacts our Customer Service team to close a job ad early.This is an example of a webhook body containing a PositionProfileClosed event:
JSON
Copy
{
  "events": [
    {
      "id": "seekAnzPublicTest:event:events:5dEQGJWnR6mSyUwnL14VGA",
      "type": "PositionProfileClosed",
      // The date the job ad was closed
      "createDateTime": "2019-09-20T21:02:27.101Z",


      // This can be passed to the `positionProfile` query to retrieve the job ad's final state
      "positionProfileId": "seekAnzPublicTest:positionProfile:jobAd:26d9DVAzs"
    }
  ],
  "subscriptionId": "seekAnzPublicTest:webhookSubscription:events:9H6GD9v2o8hQw7aBBG2sAU",
  "url": "https://example.com/webhook"
}

Webhook subscription mutation split

It’s currently possible to update some config options of a webhook subscription, using the updateWebhookSubscriptionDeliveryConfiguration mutation. Previously, this mutation required the signingAlgorithmCode as a mandatory string, which in turn required that secret was also provided, which meant that the secret string for webhook signing had to be included in every request to update a webhook subscription. This made simple updates like changing the maxAttemptsPerEvent unnecessarily difficult.To allow easier update actions, this mutation has been split in two. To update maxEventsPerAttempt or url, continue to use the updateWebhookSubscriptionDeliveryConfiguration mutation as before. To make changes to the signing config options, use the new updateWebhookSubscriptionSigningConfiguration mutation, which takes the signingAlgorithmCode and secret options. Both mutations still return the full WebhookSubscription.
| New mutation examples
Update delivery configUpdate signing config
CopyGraphQL Explorer
mutation updateWebhookDeliveryConfig(
  $webhookSubscriptionId: String!
  $url: String!
  $maxEventsPerAttempt: Int
) {
  updateWebhookSubscriptionDeliveryConfiguration(
    input: {
      webhookSubscription: {
        id: $webhookSubscriptionId
        url: $url
        maxEventsPerAttempt: $maxEventsPerAttempt
      }
    }
  ) {
    ... on UpdateWebhookSubscriptionDeliveryConfigurationPayload_Success {
      webhookSubscription {
        id {
          value
        }
        url
        maxEventsPerAttempt
      }
    }
    ... on UpdateWebhookSubscriptionDeliveryConfigurationPayload_Conflict {
      conflictingWebhookSubscription {
        id {
          value
        }
      }
    }
  }
}

Ad selection message visibility

When ad products are shown to hirers, they may have associated messages. Some messages should always be visible and others should be visible when a product is selected or not selected.The seekAnzHirerAdvertisementCreationProducts, seekAnzHirerAdvertisementModificationProducts and seekAnzHirerAdvertisementModificationProductsAlt queries have been extended to include a field named visibilityCode. It has 3 possible values:
  1. Always indicates that the message should always be visible.
  2. ProductSelected indicates that the message should be visible when the product is selected.
  3. ProductNotSelected indicates that the message should be visible when the product is not selected.
QueryVariablesResult
CopyGraphQL Explorer
query seekAnzHirerAdvertisementProducts(
  $advertisementId: String!
  $hirerId: String!
  $draftAdvertisement: SeekAnzAdProductAdvertisementDraftInput!
) {
  seekAnzHirerAdvertisementModificationProducts(
    hirerId: $hirerId
    advertisementId: $advertisementId
    draftAdvertisement: $draftAdvertisement
  ) {
    name
    messages {
      visibilityCode
      content
    }
  }
}

2021-03

Ad selection features

We’ve extended ad selection to indicate when an ad product supports branding and search bullets.This allows you to update your UI to either show or hide your branding and search bullet fields depending on the selected product:
  • Query the graph for ad product features.
    QueryVariablesResult
    CopyGraphQL Explorer
    query seekAnzHirerAdvertisementProducts(
      $advertisementId: String!
      $hirerId: String!
      $draftAdvertisement: SeekAnzAdProductAdvertisementDraftInput!
    ) {
      seekAnzHirerAdvertisementCreationProducts(
        hirerId: $hirerId
        draftAdvertisement: $draftAdvertisement
      ) {
        ...productFields
      }
    

      seekAnzHirerAdvertisementModificationProducts(
        hirerId: $hirerId
        advertisementId: $advertisementId
        draftAdvertisement: $draftAdvertisement
      ) {
        ...productFields
      }
    }
    

    fragment productFields on SeekAnzAdProduct {
      name
      features {
        brandingIndicator
        searchBulletPointsIndicator
      }
    }
  • Get the features in the onChange event raised by the Ad Selection Panel.
    JavaScript
    Copy
    SEEKAdPostingWidget.render(document.getElementById('seekWidget1ContainerDiv'), {
      mode: 'Create',
      onChange: function (event) {
        const { advertisement } = event;
        const { features } = advertisement;
        const { brandingIndicator, searchBulletPointsIndicator } = features;
    

        console.log(`Branding ${brandingIndicator : 'is' : 'is not'} supported`);
        console.log(`Search bullet points ${searchBulletPointsIndicator : 'are' : 'are not'} supported`);
    

        if (brandingIndicator) {
          // show field to select a brand
        } else {
          // hide brand field
        }
        if (searchBulletPointsIndicator) {
          // show fields to enter bullet points
        } else {
          // hide bullet point fields
        }
      },
      getAuthToken: function () {
        return Promise.resolve('browser token');
      },
      draftAdvertisement: {
        positionTitle: 'Developer',
        jobCategoryId: 'seekAnzPublicTest:jobCategory:seek:2EFstqFvP',
        positionLocationId: 'seekAnzPublicTest:location:seek:2TCFhBtw9',
        hirerJobReference: 'Premium521',
      },
    });

2020-12

Replay webhook subscriptions

We’ve extended webhook subscriptions with a new mutation replayWebhookSubscription, which resends undelivered events from the past 90 days to your subscription endpoint.This makes it easy for you to recover from downtime without building a bespoke replay mechanism on top of the events query.
MutationVariables
CopyGraphQL Explorer
mutation ($input: ReplayWebhookSubscriptionInput!) {
  replayWebhookSubscription(input: $input) {
    webhookSubscription {
      id {
        value
      }
    }
  }
}

2020-11

Profile Apply extensions

We’ve extended Profile Apply with additional structured information on the CandidateProfile object:
  • certifications lists certifications and licences the candidate holds.
  • education.descriptions adds free-text descriptions to the candidate’s education history.
QueryVariables
CopyGraphQL Explorer
query ($id: String!) {
  candidateProfile(id: $id) {
    education {
      descriptions
    }
    certifications {
      name
      issuingAuthority {
        name
      }
      issued
      effectiveTimePeriod {
        validTo
      }
      descriptions
    }
  }
}

2020-09

Mutation conflicts

We’ve introduced a new result format for mutations that create objects. This enables explicit handling of mutation conflicts.💥 The new format can be seen in the createWebhookSubscription and uploadCandidate mutations. If your software creates webhook subscriptions, update the selection set to account for this change:
GraphQL
Copy
mutation($input: CreateWebhookSubscriptionInput!) {
  createWebhookSubscription(input: $input) {
-     webhookSubscription {
-       id {
-         value
-       }
-     }
+     __typename
+     ... on CreateWebhookSubscriptionPayload_Success {
+       webhookSubscription {
+         id {
+           value
+         }
+       }
+     }
+     ... on CreateWebhookSubscriptionPayload_Conflict {
+       conflictingWebhookSubscription {
+         id {
+           value
+         }
+       }
    }
  }
}
Then, update your code to check for conflicts in one of two new ways:
JavaScript
Copy
if (
-   // Old: make assumptions based on semi-structured errors array
-   response.errors?.some(
-     (err) =>
-       err.extensions.code === 'BAD_USER_INPUT' &&
-       err.message === 'Subscription already exists',
-   )
+   // Option 1: test for existence of conflict field
+   response.data?.conflictingWebhookSubscription
+   // Option 2: test name of the response type
+   response.data?.__typename === 'CreateWebhookSubscriptionPayload_Conflict'
) {
  // Handle conflict here
}

2020-08

Job Posting features

We’ve extended Job Posting with two new features:
  • Query the nearest locations for a geolocation.This enables you to suggest a SEEK location closest to an end user, or map to a SEEK location from an internal location hierarchy.
    QueryVariables
    CopyGraphQL Explorer
    query ($first: Int, $geoLocation: GeoLocationInput!, $schemeId: String!) {
      nearestLocations(
        first: $first
        geoLocation: $geoLocation
        schemeId: $schemeId
      ) {
        contextualName
      }
    }
  • Query the brands available for StandOut and Premium ads.This enables you to include a brand preview and picker in your posting flow.
    QueryVariables
    CopyGraphQL Explorer
    query ($after: String, $first: Int, $hirerId: String!) {
      advertisementBrandings(after: $after, first: $first, hirerId: $hirerId) {
        edges {
          node {
            name
          }
        }
      }
    }

Documentation updates

We’ve extended our documentation with new guidance:
  • GraphQL usageWe’ve documented some introductory concepts specific to the SEEK API, along with general guidance for using GraphQL in your software. This includes strong advice around using GraphQL variables to prevent code injection.
  • Reprocessing webhooksWe’ve included advice on reprocessing “duplicate” webhooks. In the rare event of a data quality issue, this allows SEEK to perform remediation and prompt your software to automatically re-retrieve the affected objects.
  • SEEK Application Export migrationWe’ve described a new transition approach that allows you to run both integrations simultaneously and deduplicate applications rather than candidates. We’ve also noted some potential gotchas.
We’ve refreshed our schema documentation site! It should be easier to navigate and drill down into nested objects.

2020-07

Profile Apply

When a candidate applies on SEEK through a supported channel, they consent to share a snapshot of their SEEK Profile with the hirer.We’ve extended Application Export with more structured information on the CandidateProfile object:
  • employment includes multiple roles from the candidate’s employment history, along with a description of their achievements and responsibilities in each role.
  • education describes educational programs that the candidate has completed and is currently pursuing.
  • qualifications lists the self-asserted skills of the candidate.
QueryVariables
CopyGraphQL Explorer
query ($id: String!) {
  candidateProfile(id: $id) {
    employment {
      positionHistories {
        descriptions
      }
    }
    education {
      educationDegrees {
        name
      }
    }
    qualifications {
      competencyName
    }
  }
}
See our documentation on exporting candidate profiles for more information.
Events: Polling
Use cases: Job Posting