# Create segment

POST https://app.launchdarkly.com/api/v2/segments/{projectKey}/{environmentKey}
Content-Type: application/json

Create a new segment.

Reference: https://launchdarkly.com/docs/api/segments/post-segment

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: LaunchDarkly REST API
  version: 1.0.0
paths:
  /api/v2/segments/{projectKey}/{environmentKey}:
    post:
      operationId: post-segment
      summary: Create segment
      description: Create a new segment.
      tags:
        - subpackage_segments
      parameters:
        - name: projectKey
          in: path
          description: The project key
          required: true
          schema:
            type: string
            format: string
        - name: environmentKey
          in: path
          description: The environment key
          required: true
          schema:
            type: string
            format: string
        - name: Authorization
          in: header
          required: true
          schema:
            type: string
      responses:
        '201':
          description: Segment response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UserSegment'
        '400':
          description: Invalid request
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InvalidRequestErrorRep'
        '401':
          description: Invalid access token
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnauthorizedErrorRep'
        '403':
          description: Forbidden
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ForbiddenErrorRep'
        '404':
          description: Invalid resource identifier
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/NotFoundErrorRep'
        '429':
          description: Rate limited
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RateLimitedErrorRep'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/SegmentBody'
servers:
  - url: https://app.launchdarkly.com
  - url: https://app.launchdarkly.us
components:
  schemas:
    SegmentBody:
      type: object
      properties:
        name:
          type: string
          description: A human-friendly name for the segment
        key:
          type: string
          description: A unique key used to reference the segment
        description:
          type: string
          description: A description of the segment's purpose
        tags:
          type: array
          items:
            type: string
          description: Tags for the segment
        unbounded:
          type: boolean
          description: >-
            Whether to create a standard segment (<code>false</code>) or a big
            segment (<code>true</code>). Standard segments include rule-based
            and smaller list-based segments. Big segments include larger
            list-based segments and synced segments. Only use a big segment if
            you need to add more than 15,000 individual targets.
        unboundedContextKind:
          type: string
          description: For big segments, the targeted context kind.
      required:
        - name
        - key
      title: SegmentBody
    UnixMillis:
      type: integer
      format: int64
      title: UnixMillis
    SegmentTarget:
      type: object
      properties:
        values:
          type: array
          items:
            type: string
        contextKind:
          type: string
      title: SegmentTarget
    Link:
      type: object
      properties:
        href:
          type: string
          description: The URL of the link
        type:
          type: string
          description: The type of the link
      title: Link
    Operator:
      type: string
      title: Operator
    Clause:
      type: object
      properties:
        _id:
          type: string
        attribute:
          type: string
        op:
          $ref: '#/components/schemas/Operator'
        values:
          type: array
          items:
            description: Any type
        contextKind:
          type: string
        negate:
          type: boolean
      required:
        - attribute
        - op
        - values
        - negate
      title: Clause
    UserSegmentRule:
      type: object
      properties:
        _id:
          type: string
        clauses:
          type: array
          items:
            $ref: '#/components/schemas/Clause'
        weight:
          type: integer
        rolloutContextKind:
          type: string
        bucketBy:
          type: string
        description:
          type: string
      required:
        - clauses
      title: UserSegmentRule
    ActionIdentifier:
      type: string
      title: ActionIdentifier
    ActionSpecifier:
      type: string
      title: ActionSpecifier
    AccessDeniedReasonEffect:
      type: string
      enum:
        - allow
        - deny
      description: Whether this statement should allow or deny actions on the resources.
      title: AccessDeniedReasonEffect
    AccessDeniedReason:
      type: object
      properties:
        resources:
          type: array
          items:
            type: string
          description: Resource specifier strings
        notResources:
          type: array
          items:
            type: string
          description: >-
            Targeted resources are the resources NOT in this list. The
            <code>resources</code> and <code>notActions</code> fields must be
            empty to use this field.
        actions:
          type: array
          items:
            $ref: '#/components/schemas/ActionSpecifier'
          description: Actions to perform on a resource
        notActions:
          type: array
          items:
            $ref: '#/components/schemas/ActionSpecifier'
          description: >-
            Targeted actions are the actions NOT in this list. The
            <code>actions</code> and <code>notResources</code> fields must be
            empty to use this field.
        effect:
          $ref: '#/components/schemas/AccessDeniedReasonEffect'
          description: >-
            Whether this statement should allow or deny actions on the
            resources.
        role_name:
          type: string
      required:
        - effect
      title: AccessDeniedReason
    AccessDenied:
      type: object
      properties:
        action:
          $ref: '#/components/schemas/ActionIdentifier'
        reason:
          $ref: '#/components/schemas/AccessDeniedReason'
      required:
        - action
        - reason
      title: AccessDenied
    AccessAllowedReasonEffect:
      type: string
      enum:
        - allow
        - deny
      description: Whether this statement should allow or deny actions on the resources.
      title: AccessAllowedReasonEffect
    AccessAllowedReason:
      type: object
      properties:
        resources:
          type: array
          items:
            type: string
          description: Resource specifier strings
        notResources:
          type: array
          items:
            type: string
          description: >-
            Targeted resources are the resources NOT in this list. The
            <code>resources</code> and <code>notActions</code> fields must be
            empty to use this field.
        actions:
          type: array
          items:
            $ref: '#/components/schemas/ActionSpecifier'
          description: Actions to perform on a resource
        notActions:
          type: array
          items:
            $ref: '#/components/schemas/ActionSpecifier'
          description: >-
            Targeted actions are the actions NOT in this list. The
            <code>actions</code> and <code>notResources</code> fields must be
            empty to use this field.
        effect:
          $ref: '#/components/schemas/AccessAllowedReasonEffect'
          description: >-
            Whether this statement should allow or deny actions on the
            resources.
        role_name:
          type: string
      required:
        - effect
      title: AccessAllowedReason
    AccessAllowedRep:
      type: object
      properties:
        action:
          $ref: '#/components/schemas/ActionIdentifier'
        reason:
          $ref: '#/components/schemas/AccessAllowedReason'
      required:
        - action
        - reason
      title: AccessAllowedRep
    Access:
      type: object
      properties:
        denied:
          type: array
          items:
            $ref: '#/components/schemas/AccessDenied'
        allowed:
          type: array
          items:
            $ref: '#/components/schemas/AccessAllowedRep'
      required:
        - denied
        - allowed
      title: Access
    FlagListingRep:
      type: object
      properties:
        name:
          type: string
          description: The flag name
        key:
          type: string
          description: The flag key
        _links:
          type: object
          additionalProperties:
            $ref: '#/components/schemas/Link'
        _site:
          $ref: '#/components/schemas/Link'
      required:
        - name
        - key
      title: FlagListingRep
    SegmentId:
      type: string
      title: SegmentId
    SegmentMetadata:
      type: object
      properties:
        envId:
          type: string
        segmentId:
          $ref: '#/components/schemas/SegmentId'
        version:
          type: integer
        includedCount:
          type: integer
        excludedCount:
          type: integer
        lastModified:
          $ref: '#/components/schemas/UnixMillis'
        deleted:
          type: boolean
      title: SegmentMetadata
    UserSegment:
      type: object
      properties:
        name:
          type: string
          description: A human-friendly name for the segment.
        description:
          type: string
          description: >-
            A description of the segment's purpose. Defaults to
            <code>null</code> and is omitted in the response if not provided.
        tags:
          type: array
          items:
            type: string
          description: Tags for the segment. Defaults to an empty array.
        creationDate:
          $ref: '#/components/schemas/UnixMillis'
          description: Timestamp of when the segment was created
        lastModifiedDate:
          $ref: '#/components/schemas/UnixMillis'
          description: Timestamp of when the segment was last modified
        key:
          type: string
          description: A unique key used to reference the segment
        included:
          type: array
          items:
            type: string
          description: >-
            An array of keys for included targets. Included individual targets
            are always segment members, regardless of segment rules. For
            list-based segments over 15,000 entries, also called big segments,
            this array is either empty or omitted.
        excluded:
          type: array
          items:
            type: string
          description: >-
            An array of keys for excluded targets. Segment rules bypass
            individual excluded targets, so they will never be included based on
            rules. Excluded targets may still be included explicitly. This value
            is omitted for list-based segments over 15,000 entries, also called
            big segments.
        includedContexts:
          type: array
          items:
            $ref: '#/components/schemas/SegmentTarget'
        excludedContexts:
          type: array
          items:
            $ref: '#/components/schemas/SegmentTarget'
        _links:
          type: object
          additionalProperties:
            $ref: '#/components/schemas/Link'
          description: The location and content type of related resources
        rules:
          type: array
          items:
            $ref: '#/components/schemas/UserSegmentRule'
          description: An array of the targeting rules for this segment.
        version:
          type: integer
          description: Version of the segment
        deleted:
          type: boolean
          description: Whether the segment has been deleted
        _access:
          $ref: '#/components/schemas/Access'
        _flags:
          type: array
          items:
            $ref: '#/components/schemas/FlagListingRep'
          description: >-
            A list of flags targeting this segment. Only included when getting a
            single segment, using the <code>getSegment</code> endpoint.
        unbounded:
          type: boolean
          description: >-
            Whether this is a standard segment (<code>false</code>) or a big
            segment (<code>true</code>). Standard segments include rule-based
            segments and smaller list-based segments. Big segments include
            larger list-based segments and synced segments. If omitted, the
            segment is a standard segment.
        unboundedContextKind:
          type: string
          description: For big segments, the targeted context kind.
        generation:
          type: integer
          description: For big segments, how many times this segment has been created.
        _unboundedMetadata:
          $ref: '#/components/schemas/SegmentMetadata'
          description: >-
            Details on the external data store backing this segment. Only
            applies to big segments.
        _external:
          type: string
          description: >-
            The external data store backing this segment. Only applies to synced
            segments.
        _externalLink:
          type: string
          description: >-
            The URL for the external data store backing this segment. Only
            applies to synced segments.
        _importInProgress:
          type: boolean
          description: >-
            Whether an import is currently in progress for the specified
            segment. Only applies to big segments.
      required:
        - name
        - tags
        - creationDate
        - lastModifiedDate
        - key
        - _links
        - rules
        - version
        - deleted
        - generation
      title: UserSegment
    InvalidRequestErrorRep:
      type: object
      properties:
        code:
          type: string
          description: Specific error code encountered
        message:
          type: string
          description: Description of the error
      required:
        - code
        - message
      title: InvalidRequestErrorRep
    UnauthorizedErrorRep:
      type: object
      properties:
        code:
          type: string
          description: Specific error code encountered
        message:
          type: string
          description: Description of the error
      required:
        - code
        - message
      title: UnauthorizedErrorRep
    ForbiddenErrorRep:
      type: object
      properties:
        code:
          type: string
          description: Specific error code encountered
        message:
          type: string
          description: Description of the error
      required:
        - code
        - message
      title: ForbiddenErrorRep
    NotFoundErrorRep:
      type: object
      properties:
        code:
          type: string
          description: Specific error code encountered
        message:
          type: string
          description: Description of the error
      required:
        - code
        - message
      title: NotFoundErrorRep
    RateLimitedErrorRep:
      type: object
      properties:
        code:
          type: string
          description: Specific error code encountered
        message:
          type: string
          description: Description of the error
      required:
        - code
        - message
      title: RateLimitedErrorRep
  securitySchemes:
    ApiKey:
      type: apiKey
      in: header
      name: Authorization

```

## SDK Code Examples

```python
import requests

url = "https://app.launchdarkly.com/api/v2/segments/projectKey/environmentKey"

payload = {
    "name": "Example segment",
    "key": "segment-key-123abc"
}
headers = {
    "Authorization": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://app.launchdarkly.com/api/v2/segments/projectKey/environmentKey';
const options = {
  method: 'POST',
  headers: {Authorization: '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"name":"Example segment","key":"segment-key-123abc"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://app.launchdarkly.com/api/v2/segments/projectKey/environmentKey"

	payload := strings.NewReader("{\n  \"name\": \"Example segment\",\n  \"key\": \"segment-key-123abc\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://app.launchdarkly.com/api/v2/segments/projectKey/environmentKey")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"name\": \"Example segment\",\n  \"key\": \"segment-key-123abc\"\n}"

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://app.launchdarkly.com/api/v2/segments/projectKey/environmentKey")
  .header("Authorization", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"name\": \"Example segment\",\n  \"key\": \"segment-key-123abc\"\n}")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://app.launchdarkly.com/api/v2/segments/projectKey/environmentKey', [
  'body' => '{
  "name": "Example segment",
  "key": "segment-key-123abc"
}',
  'headers' => [
    'Authorization' => '<apiKey>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://app.launchdarkly.com/api/v2/segments/projectKey/environmentKey");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"Example segment\",\n  \"key\": \"segment-key-123abc\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "name": "Example segment",
  "key": "segment-key-123abc"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://app.launchdarkly.com/api/v2/segments/projectKey/environmentKey")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```