Trade Me Jobs API Integration

Sync Job Listings to Trade Me Jobs with a Custom API Integration

For recruitment agencies, employers, and job platforms across New Zealand, publishing the same vacancy across an internal recruitment system and Trade Me Jobs can create unnecessary administrative work. Recruiters may already have the job title, description, salary, employment type, location, company details, application instructions, and other information stored inside an ATS, CRM, HR system, or custom recruitment website.

When that information then has to be manually recreated on Trade Me Jobs, every change becomes another task. A salary adjustment, updated job description, changed application URL, altered location, or expired vacancy may need to be updated in multiple places.

A custom Trade Me Jobs API integration can connect your recruitment platform directly with Trade Me, allowing supported job-position operations to be managed programmatically. Trade Me’s current API documentation includes dedicated Job Position, Job Company, Job Catalogue, Job Payment, Job Agent, and Job Listing methods. :contentReference[oaicite:0]{index=0}

---

Why build a custom Trade Me Jobs API integration?

A custom integration allows your recruitment platform to remain the central place where recruiters manage vacancy information while the API handles supported Trade Me operations.

• Reduce duplicate data entry: Create and maintain job positions from your existing ATS, CRM, HR system, or recruitment website.
• Synchronize job changes: Update supported listing information when recruiters change the source record.
• Automate job publishing: Send eligible vacancies to Trade Me Jobs without manually entering the same information again.
• Standardize job data: Map your internal fields to Trade Me’s job-position structure.
• Automate relisting workflows: Use supported position operations to relist or create similar positions.
• Improve recruitment operations: Keep your internal recruitment database and Trade Me listing workflow connected.

---

Understanding the Trade Me Jobs API architecture

Trade Me’s API uses REST-style endpoints, with GET methods generally used to retrieve information and POST methods for operations that create or modify data. Protected API operations require authentication and application registration. :contentReference[oaicite:1]{index=1}

The Jobs API provides dedicated functionality for managing job positions, companies, job catalogues, payments, job agents, and related listing information. :contentReference[oaicite:2]{index=2}

ATS / CRM / Recruitment Website
              |
              v
+------------------------------+
| Custom Trade Me Integration  |
+------------------------------+
              |
       +------+------+
       |             |
       v             v
   Data Mapping   Validation
       |             |
       +------+------+
              |
              v
        OAuth / API Layer
              |
              v
       Trade Me Jobs API
              |
              v
       Trade Me Job Position

This architecture allows your existing recruitment application to keep its own database structure while the integration translates the data into the structure expected by Trade Me.

---

What job data can be synchronized?

Trade Me’s Jobs search and API documentation exposes job-related fields including position title, category, job type, salary information, location, company, application method, contract length, keywords, reference, and listing content. The exact fields and operations available for publishing or updating depend on the applicable Trade Me Jobs API workflow. :contentReference[oaicite:3]{index=3}

• Job title: Position title and vacancy headline.
• Job description: Main job description, responsibilities, requirements, and additional content.
• Job category: Job category and subcategory mapping.
• Employment type: Permanent, contract, temporary, or other supported employment classifications.
• Salary information: Salary ranges, hourly rates, pay type, and applicable salary transparency information.
• Location: City, district, region, and job location information.
• Company: Employer or recruitment company information.
• Application method: Trade Me application, external website, ATS, or other supported application workflow.
• Reference number: Your internal vacancy or requisition reference.
• Contract information: Contract length and employment duration where applicable.
• Keywords: Search and classification terms associated with the position.
• Application instructions: Instructions explaining how candidates should apply.

---

Custom job data mapping between your ATS and Trade Me

Your recruitment system may have completely different field names and structures from Trade Me. Instead of changing your existing database, a middleware layer can translate your internal job record into the appropriate API request.

Internal ATS Field                 Trade Me Job Field
---------------------------------------------------------
job.title                    --->  Position Title
job.description              --->  Job Description
job.category                 --->  Job Category
job.subcategory              --->  Job Subcategory
job.salary_min               --->  Salary / Pay Data
job.salary_max               --->  Salary / Pay Data
job.location                 --->  Job Location
job.employment_type          --->  Employment Type
job.contract_length          --->  Contract Length
job.reference                --->  Reference
job.company                  --->  Company
job.application_url          --->  Application Method
job.instructions             --->  Application Instructions
job.keywords                 --->  Keywords

The integration can also perform transformations before sending the data. For example, an internal employment-type ID can be converted into the corresponding Trade Me catalogue value.

---

Automated Trade Me Jobs publishing workflow

1. Retrieve vacancies: The integration reads new or modified positions from your ATS, CRM, HR platform, website API, or database.
2. Check eligibility: Business rules determine which vacancies should be submitted to Trade Me.
3. Validate required fields: The connector checks title, category, employment information, location, salary, company, and other required data.
4. Map the data: Internal fields are converted into the Trade Me Jobs position structure.
5. Authenticate: The integration uses the configured Trade Me application and OAuth credentials.
6. Create or update the position: The appropriate supported Job Position operation is executed.
7. Store identifiers: The Trade Me position ID is associated with the internal vacancy ID.
8. Monitor the result: API responses and errors are recorded for future troubleshooting.

---

Trade Me Jobs OAuth authentication

Protected Trade Me APIs require authentication as a Trade Me member. Trade Me’s documented OAuth flow allows an application to request authorization and obtain an access token without asking users to provide their Trade Me password to the application. :contentReference[oaicite:4]{index=4}

The general architecture looks like this:

Recruitment Application
        |
        v
Trade Me OAuth Request
        |
        v
User Authorizes Application
        |
        v
OAuth Access Token
        |
        v
Authenticated Jobs API Requests

Trade Me also requires applications to be registered, and production applications are subject to its approval process and applicable terms and conditions. :contentReference[oaicite:5]{index=5}

For a production integration, authentication credentials should be stored securely on the server rather than exposed in browser-side JavaScript or frontend code.

---

Job position creation and updates

The Trade Me API includes dedicated Job Position Methods. The API reference documents a POST operation for creating a job position, a GET operation for retrieving positions, and a POST operation for updating an existing job position. It also provides an operation for relisting or listing a similar position as a child of an existing position. :contentReference[oaicite:6]{index=6}

This makes it possible to design workflows such as:

New Vacancy
     |
     v
Validate
     |
     v
Create Trade Me Position
     |
     v
Store Trade Me Position ID
     |
     +----------------------+
     |                      |
     v                      v
Job Updated             Job Relist Needed
     |                      |
     v                      v
Update Position         Relist / Similar Position

The integration can maintain the relationship between your internal requisition ID and the Trade Me position ID so subsequent operations target the correct job.

---

Trade Me Jobs catalogue integration

Job listings often depend on controlled values rather than completely free-form text. Trade Me provides dedicated Jobs Catalogue methods for values such as employment duration types, employment types, pay types, hourly-rate values, salary values, preferred application modes, and position packages. :contentReference[oaicite:7]{index=7}

A custom integration can retrieve and cache relevant catalogue information so that your ATS fields can be mapped consistently.

• Employment types: Map internal employment classifications to supported Trade Me values.
• Employment duration: Map contract or employment duration information.
• Pay types: Map hourly, salary, contract, or other applicable pay structures.
• Salary values: Use supported salary values where required by the API workflow.
• Application modes: Map how candidates are expected to apply.
• Position packages: Retrieve applicable job package information where required.

---

Salary and pay information synchronization

Salary information is often maintained in structured fields inside an ATS, while job advertisements may use different presentation rules.

A custom connector can apply your business rules before submitting the position, including:

• Minimum and maximum salary values.
• Hourly versus annual compensation.
• Contract or fixed-rate payment structures.
• Salary visibility rules.
• Internal salary bands converted to the supported Trade Me format.

Trade Me’s Jobs API documentation also exposes salary-transparency information in job search results, including whether a position has opted into salary data display and an approximate pay-range representation. :contentReference[oaicite:8]{index=8}

---

Automating job lifecycle management

A recruitment integration should not stop after the initial job publication. Vacancies have a lifecycle that can include draft, published, updated, expired, closed, and relisted states.

Draft Vacancy
     |
     v
Ready for Publishing
     |
     v
Trade Me Position
     |
     +------> Job Description Changed
     |
     +------> Salary Changed
     |
     +------> Location Changed
     |
     +------> Application URL Changed
     |
     +------> Position Closed
     |
     v
Relist / Update / Close

Your internal ATS can remain the source of truth while the integration translates relevant state changes into supported Trade Me operations.

---

Job company and employer synchronization

Trade Me provides dedicated Job Company Methods, including functionality for creating a company for the authenticated member or retrieving existing companies. :contentReference[oaicite:9]{index=9}

This can be useful for recruitment platforms managing vacancies for multiple employers or agencies that need to associate job positions with the appropriate company information.

A custom integration can maintain an internal relationship such as:

Internal Company ID
       |
       v
Trade Me Company ID
       |
       +---- Job Position A
       +---- Job Position B
       +---- Job Position C

This avoids repeatedly creating or resolving the same company relationship during every synchronization cycle.

---

External ATS and application workflow integration

Many recruitment websites already have their own application process. Candidates may apply through an ATS, company website, recruitment portal, or another application system.

Trade Me’s Jobs data includes application-related information such as whether online applications are supported and whether applications are handled through Trade Me, a third-party website, or an ATS integration. :contentReference[oaicite:10]{index=10}

A custom integration can therefore map your existing application workflow into the supported Trade Me configuration rather than forcing your recruitment platform to change its internal application process.

---

Trade Me Jobs search API integration

The Trade Me API also provides a dedicated Jobs Search endpoint. It supports parameters including job category, district, salary ranges, hourly rates, keywords, member listings, and date filtering. Responses are available in JSON and XML, and the endpoint is rate limited. :contentReference[oaicite:11]{index=11}

This can be useful when building an authorized application that needs to retrieve job information or integrate relevant Trade Me Jobs data into a supported workflow.

• Search by job category.
• Search using keywords.
• Filter by district.
• Filter by salary range.
• Filter by hourly rate.
• Filter by member listing.
• Filter by listing date.
• Sort search results using supported options.

Any implementation should follow Trade Me’s current API use-case requirements, terms, authentication rules, and applicable access restrictions. :contentReference[oaicite:12]{index=12}

---

Sync queues, retries and error handling

A production recruitment integration should be designed to handle temporary API failures without losing job updates.

• Validation errors: Store the affected vacancy and identify the missing or invalid field.
• Authentication errors: Detect invalid or expired authorization and flag the connection for attention.
• Network errors: Retry temporary connectivity failures.
• Rate limiting: Respect Trade Me’s API limits and schedule additional requests appropriately.
• Duplicate prevention: Maintain internal-to-Trade Me position IDs.
• Failed updates: Place unsuccessful operations into a retry queue.
• Audit logs: Record each create, update, and synchronization result.

For a larger recruitment database, background workers can process jobs in batches rather than performing every API request during a recruiter’s browser session.

---

WordPress Trade Me Jobs API integration

If your recruitment website runs on WordPress, we can build the Trade Me Jobs connector as a custom plugin around your existing job-management system.

• Custom Post Types: Synchronize vacancies stored as WordPress job posts.
• ACF / Meta Box: Map custom salary, location, employment, and company fields.
• Custom recruitment plugins: Connect existing job-management functionality to the Trade Me API.
• WP-Cron: Schedule periodic synchronization.
• WP-CLI: Process large vacancy databases from the command line.
• Admin dashboard: Display Trade Me position IDs, sync status, errors, and retry actions.

The same architecture can also be implemented as standalone middleware when the job database is hosted outside WordPress.

---

Supported recruitment technology stacks

We can integrate Trade Me Jobs with your existing technical environment rather than requiring a specific recruitment platform.

• WordPress / PHP: Custom plugins, CPT, REST APIs, WP-CLI, and cron jobs.
• Laravel: Queue-based recruitment integrations and scheduled synchronization.
• Node.js: API middleware, workers, background jobs, and recruitment automation.
• React / Next.js: Headless recruitment portals connected to a custom backend.
• Custom ATS: Direct API-to-API integration between your applicant tracking system and Trade Me.
• HR / recruitment platforms: Custom connectors for systems exposing REST, JSON, XML, or database-based vacancy data.

---

Build your custom Trade Me Jobs API integration

If your recruitment team is manually entering the same vacancies into multiple systems, a custom Trade Me Jobs API integration can connect your existing recruitment workflow with the Trade Me Jobs platform.

Whether your vacancies originate from a WordPress recruitment website, ATS, CRM, HR system, Laravel application, Node.js platform, XML/JSON feed, or custom database, we can build the integration around your existing architecture.

The result is a centralized workflow where recruiters continue managing vacancies from their primary system while the integration handles supported Trade Me API operations, field mapping, authentication, synchronization, error handling, and monitoring.

📩 Contact me on Upwork to discuss your custom Trade Me Jobs API integration, recruitment automation, ATS integration, or WordPress job portal project.

---

FAQs: Trade Me Jobs API Integration

---