Namely

Overview

Namely is an all-in-one HR platform designed specifically for mid-market companies (50-1000 employees). They combine HRIS, payroll, benefits, and talent management in a single platform, with a strong focus on open API architecture and third-party integrations.

Platform Strengths

Open API Philosophy: Robust REST API available
Partner Ecosystem: 30+ integration partners
Mid-Market Focus: Built for 50-1000 employees
Modern Architecture: Cloud-native platform

Developer Access

API Documentation: developers.namely.com
Authentication: OAuth 2.0
Rate Limits: Standard throttling applies
Sandbox: Available for partners

Integration Capabilities

API Access Levels

Full Partner Access

Becoming a Namely partner provides:

Complete API Access: All endpoints available
Sandbox Environment: Test company for development
Technical Support: Direct developer support
Marketplace Listing: Visibility to Namely customers

Requirements:

Submit partnership application
Technical review process
Business case presentation
Ongoing relationship management

Customer-Level Access

Existing Namely customers can:

Limited API Access: Read-only for most endpoints
Internal Use Only: No commercial distribution
Basic Support: Community forums and docs
Rate Limits: More restrictive than partners

Getting Started:

# Contact Namely support
hello@namely.com

# Request API credentials
# Provide use case documentation

Third-Party Connectors

Access Namely through unified API providers:

Merge API

const merge = require('@mergeapi/merge-node-client');

const client = new merge.MergeClient({
  apiKey: 'YOUR_API_KEY'
});

// Access Namely data through unified interface
const employees = await client.hris.employees.list({
  integrationSlug: 'namely'
});

Benefits:

Instant access (no Namely approval needed)
Standardized data models
Multiple HRIS with one integration
Managed authentication

API Documentation

Authentication Flow

Register Your Application

POST https://api.namely.com/oauth/applications
{
  "name": "Tallyfy Integration",
  "redirect_uri": "https://app.tallyfy.com/oauth/namely/callback"
}

Implement OAuth 2.0

// Authorization URL
const authUrl = `https://[company].namely.com/api/v1/oauth/authorize?
  response_type=code&
  client_id=${CLIENT_ID}&
  redirect_uri=${REDIRECT_URI}&
  state=${STATE}`;

// Exchange code for token
const tokenResponse = await fetch('https://[company].namely.com/api/v1/oauth/token', {
  method: 'POST',
  body: JSON.stringify({
    grant_type: 'authorization_code',
    code: authCode,
    client_id: CLIENT_ID,
    client_secret: CLIENT_SECRET,
    redirect_uri: REDIRECT_URI
  })
});

Make API Calls

const employees = await fetch('https://[company].namely.com/api/v1/employees', {
  headers: {
    'Authorization': `Bearer ${accessToken}`,
    'Accept': 'application/json'
  }
});

Key API Endpoints

Employee Management

GET /api/v1/employees
GET /api/v1/employees/{id}
POST /api/v1/employees
PUT /api/v1/employees/{id}

Time & Attendance

GET /api/v1/time_off_requests
POST /api/v1/time_off_requests
GET /api/v1/timesheets
POST /api/v1/timesheets

Payroll Data

GET /api/v1/payrolls
GET /api/v1/pay_periods
GET /api/v1/earnings
GET /api/v1/deductions

Benefits

GET /api/v1/benefit_plans
GET /api/v1/enrollments
POST /api/v1/enrollments
PUT /api/v1/enrollments/{id}

Webhook Support

Namely supports webhooks for real-time event notifications:

// Register webhook endpoint
const webhook = {
  url: 'https://app.tallyfy.com/webhooks/namely',
  events: [
    'employee.created',
    'employee.updated',
    'employee.terminated',
    'time_off_request.submitted',
    'time_off_request.approved'
  ],
  secret: 'webhook_secret'
};

// Webhook handler
app.post('/webhooks/namely', (req, res) => {
  const signature = req.headers['x-namely-signature'];
  const payload = req.body;

  if (verifySignature(payload, signature, webhook.secret)) {
    switch(payload.event) {
      case 'employee.created':
        createOnboardingProcess(payload.data);
        break;
      case 'employee.terminated':
        createOffboardingProcess(payload.data);
        break;
    }
  }

  res.sendStatus(200);
});

Common Integration Patterns

Employee Onboarding Automation

Webhook Trigger
- Namely sends employee.created event
- Contains new employee data

Create Tallyfy Process

async function createOnboardingProcess(employee) {
  const process = await tallyfy.processes.create({
    template: 'employee-onboarding',
    data: {
      employeeId: employee.id,
      name: employee.full_name,
      email: employee.email,
      department: employee.department,
      manager: employee.reports_to,
      startDate: employee.start_date
    }
  });

  // Store Namely ID for updates
  await tallyfy.metadata.set(process.id, 'namely_id', employee.id);
}

Sync Progress Back

// Update Namely custom field with onboarding status
await namely.employees.update(employee.id, {
  custom_fields: {
    onboarding_status: 'In Progress',
    onboarding_completion: '60%'
  }
});

Time-Off Request Workflow

// Listen for time-off requests
namely.webhooks.on('time_off_request.submitted', async (request) => {
  // Create approval process in Tallyfy
  const approval = await tallyfy.processes.create({
    template: 'time-off-approval',
    data: {
      employee: request.employee_name,
      type: request.time_off_type,
      startDate: request.start_date,
      endDate: request.end_date,
      days: request.days_requested,
      manager: request.approver
    }
  });

  // When approved in Tallyfy
  tallyfy.on('process.completed', async (process) => {
    if (process.template === 'time-off-approval') {
      await namely.timeOffRequests.approve(request.id);
    }
  });
});

Integration Best Practices

Data Synchronization

Error Handling

class NamelyIntegration {
  async syncWithRetry(operation, maxRetries = 3) {
    let lastError;

    for (let i = 0; i < maxRetries; i++) {
      try {
        return await operation();
      } catch (error) {
        lastError = error;

        if (error.status === 429) {
          // Rate limit - exponential backoff
          await sleep(Math.pow(2, i) * 1000);
        } else if (error.status === 401) {
          // Token expired - refresh
          await this.refreshToken();
        } else if (error.status >= 500) {
          // Server error - retry with delay
          await sleep(5000);
        } else {
          // Client error - don't retry
          throw error;
        }
      }
    }

    throw lastError;
  }
}

Rate Limiting

Namely implements standard rate limiting:

Default: 1000 requests per hour
Burst: 100 requests per minute
Headers: Check X-RateLimit-Remaining

// Rate limit handler
const rateLimiter = {
  remaining: 1000,
  resetTime: null,

  async executeWithLimit(fn) {
    if (this.remaining <= 10) {
      const waitTime = this.resetTime - Date.now();
      if (waitTime > 0) {
        await sleep(waitTime);
      }
    }

    const response = await fn();

    // Update limits from headers
    this.remaining = parseInt(response.headers['x-ratelimit-remaining']);
    this.resetTime = parseInt(response.headers['x-ratelimit-reset']) * 1000;

    return response;
  }
};

Marketplace Integration

Namely Connect Portal

Namely Connect allows clients to set up integrations directly:

Submit Integration
- Apply at namely.com/partners
- Provide integration documentation
- Complete technical review
Marketplace Listing
- Create integration profile
- Add setup instructions
- Provide support contact
Client Activation
- Clients discover in Namely Connect
- One-click OAuth authorization
- Automatic provisioning

Alternative Approaches

Using Unified APIs

Merge API Access Namely + 30 other HRIS through one API

Finch Unified employment API including Namely

Apideck Single API for 200+ HRIS including Namely

Custom Middleware

// Simple Namely-to-Tallyfy middleware
const express = require('express');
const app = express();

class NamelyTallyfyBridge {
  constructor(namelyConfig, tallyfyConfig) {
    this.namely = new NamelyClient(namelyConfig);
    this.tallyfy = new TallyfyClient(tallyfyConfig);
  }

  async syncEmployees() {
    const employees = await this.namely.employees.list();

    for (const emp of employees) {
      await this.tallyfy.users.upsert({
        externalId: emp.id,
        email: emp.email,
        name: emp.full_name,
        department: emp.department
      });
    }
  }

  startScheduledSync() {
    // Real-time webhooks
    this.setupWebhooks();

    // Daily full sync
    schedule.daily(() => this.syncEmployees());

    // Hourly incremental sync
    schedule.hourly(() => this.syncRecentChanges());
  }
}

Implementation Checklist

Week 1: Setup & Authentication

Request Namely API access
Implement OAuth 2.0 flow
Test basic API calls
Set up development environment

Week 2: Core Integration

Map data models
Build sync functions
Implement webhooks
Add error handling

Week 3: Process Automation

Create Tallyfy templates
Connect trigger events
Build status sync
Test workflows

Week 4: Production Deployment

Security review
Load testing
Documentation
Go-live

Support Resources

Developer Resources

Community

Developer forums (partner access)
Integration examples on GitHub
Namely Connect partner network

Conclusion

Namely offers solid API capabilities for mid-market HR integration. While partner access provides the best experience, alternatives like unified APIs offer quick paths to integration. Their open ecosystem philosophy and growing partner network make Namely a good choice for companies seeking HR automation through Tallyfy.

Vendors > Paylocity

Tallyfy is building native integration with Paylocity to automatically transform HCM data into intelligent workflows that orchestrate the complete employee lifecycle from application to termination including automated onboarding payroll processing compliance tracking and IT provisioning without manual handoffs or compliance gaps.

Vendors > BambooHR

Tallyfy is building a native BambooHR integration that syncs employee data in real-time to automate workflows like onboarding offboarding and organizational changes while offering immediate API-based connection options and marketplace partnership plans.

Vendors > Zenefits

Zenefits now part of TriNet is an all-in-one HR platform for small and medium businesses that offers comprehensive HR benefits payroll and compliance features but has restricted API access requiring approval processes that can take weeks to months making integration challenging compared to modern alternatives like unified API providers or file-based approaches.

Vendors > HiBob

Tallyfy integrates with HiBob to automatically orchestrate comprehensive people workflows triggered by HR platform events like new hires time-off requests and role changes while maintaining HiBob as the central people data platform.

Get in touch

About Tallyfy