# Export Subscription Ramps

> For the complete machine-readable documentation index, see [llms.txt](https://apidocs.chargebee.com/llms.txt).


[Idempotency Supported](/docs/api/idempotency)

[Eventually Consistent](/docs/api/read-consistency)

Starts an export job for [subscription ramps](/docs/api/ramps) data. The exported zip file contains CSV files with ramp-related data.

### Best practice[](#best-practice)

For a full data export, use filters to export in batches, as suggested in the samples below.

## Sample Request

### Export all ramps that are in scheduled state.

#### cURL

```bash
curl  https://{site}.chargebee.com/api/v2/exports/ramps \
     -u {site_api_key}:\
     -d export_type="DATA" \
     -d "ramp[status][is]"="SCHEDULED"
```

#### .NET

```dotnet
using ChargeBee.Api;
using ChargeBee.Models;
using ChargeBee.Models.Enums;

ApiConfig.Configure("{site}","{site_api_key}");
EntityResult result = Export.Ramps()
		.ExportType(ExportTypeEnum.Data)
		.RampStatus().Is(Ramp.StatusEnum.Scheduled)
		.Request();

Export export = result.Export;
```

#### Go

```go
package main
import (
    "fmt"
    "github.com/chargebee/chargebee-go/v3"
    "github.com/chargebee/chargebee-go/v3/filter"
    exportAction "github.com/chargebee/chargebee-go/v3/actions/export"
    "github.com/chargebee/chargebee-go/v3/models/export"
    enum "github.com/chargebee/chargebee-go/v3/enum"
)
func main() {
    chargebee.Configure("{site_api_key}","{site}");
    res,err := exportAction.Ramps(&export.RampsRequestParams{
        ExportType : enum.ExportTypeData,
        Ramp : &export.RampsRampParams{
            Status : &filter.EnumFilter{
                Is : "scheduled",
            },
        },
    }).Request()
    if err != nil {
        fmt.Println(err)
    } else {
        Export := res.Export
    }
}
```

#### Go

```go
package main

import (
  "fmt"
  "github.com/chargebee/chargebee-go/v4"
)

func main() {
  config := &chargebee.ClientConfig{
    SiteName: "{site}",
    ApiKey: "{site_api_key}",
  }    
  client := chargebee.NewClient(config)
  req := &chargebee.ExportRampsRequest{
    ExportType : chargebee.ExportTypeData,
    Ramp : &chargebee.ExportRampsRamp{
        Status : &chargebee.EnumFilter{
            Is : "scheduled",
        },
    },
}
  res, err := client.Export.Ramps(req)
      if err != nil {
        fmt.Println(err)
    } else {
        Export := res.Export
    }
}
```

#### Java

```java
import com.chargebee.*;
import com.chargebee.ListResult;
import com.chargebee.models.*;
import com.chargebee.models.enums.*;
import java.io.IOException;

public class Sample {

    public static void main(String args[]) throws IOException, Exception {
        Environment.configure("{site}", "{site_api_key}");
        Result result = Export.ramps()
            .exportType(ExportType.DATA)
            .rampStatus().is(Ramp.Status.SCHEDULED)
            .request();

        Export export = result.export();
    }
}
```

#### Java

```java
import com.chargebee.v4.client.ChargebeeClient;
import com.chargebee.v4.models.export.Export;
import com.chargebee.v4.models.export.params.ExportRampsParams;
import com.chargebee.v4.models.export.responses.ExportRampsResponse;

public class ExportRamps {

    public static void main(String[] args) {
        ChargebeeClient client = ChargebeeClient.builder()
            .apiKey("{site_api_key}")
            .siteName("{site}")
            .build();

        ExportRampsParams.RampParams ramp =
            ExportRampsParams.RampParams.builder()
                .status()
                .is(ExportRampsParams.RampParams.Status.SCHEDULED)
                .build();

        ExportRampsParams params = ExportRampsParams.builder()
            .exportType(ExportRampsParams.ExportType.DATA)
            .ramp(ramp)
            .build();

        ExportRampsResponse response = client.exports().ramps(params);

        Export export = response.getExport();
    }
}
```

#### Node.js

```node
import Chargebee from "chargebee";

const chargebee = new Chargebee({
    site: "{site}",
    apiKey: "{site_api_key}",
});

try {
    const result = await chargebee.export.ramps({
        export_type: "data",
        ramp: {
            status: {
                is: "scheduled"
            }
        }
    });

    console.log(result);
    const export_response = result.export;
} catch (err) {
    console.log(err);
}
```

#### PHP

```php
<?php

require __DIR__ . '/vendor/autoload.php';

use Chargebee\ChargebeeClient;

$chargebee = new ChargebeeClient(options: [
    "site" => "{site}",
    "apiKey" => "{site_api_key}",
]);
$result = $chargebee->export()->ramps([
    "export_type" => "data",
    "ramp" => [
        "status" => [
            "is" => "scheduled"
        ]
    ]
]);
$export = $result->export;
```

#### Python

```python
import chargebee
from chargebee import Chargebee, Filters

cb_client = Chargebee(api_key="{site_api_key}", site="{site}")
response = cb_client.Export.ramps(
    cb_client.Export.RampsParams(
        export_type=chargebee.ExportType.DATA,
        ramp=cb_client.Export.RampsRampParams(
            status=Filters.EnumFilter(IS=chargebee.Ramp.Status.SCHEDULED)
        )
    )
)
export = response.export
```

#### Ruby

```ruby
require 'chargebee'

ChargeBee.configure(:site => "{site}",
  :api_key => "{site_api_key}")

result = ChargeBee::Export.ramps({
  :export_type => "DATA",
  "ramp[status][is]" => "scheduled"
})

export = result.export
```

### Exports all ramps that belong to the given subscription.

#### cURL

```bash
curl  https://{site}.chargebee.com/api/v2/exports/ramps \
     -u {site_api_key}:\
     -d export_type="IMPORT_FRIENDLY_DATA" \
     -d "ramp[subscription_id][is]"="8asz3SQ0jFhbG3Dr"
```

#### .NET

```dotnet
using ChargeBee.Api;
using ChargeBee.Models;
using ChargeBee.Models.Enums;

ApiConfig.Configure("{site}","{site_api_key}");
EntityResult result = Export.Ramps()
		.ExportType(ExportTypeEnum.ImportFriendlyData)
		.RampSubscriptionId().Is("8asz3SQ0jFhbG3Dr")
		.Request();

Export export = result.Export;
```

#### Go

```go
package main
import (
    "fmt"
    "github.com/chargebee/chargebee-go/v3"
    "github.com/chargebee/chargebee-go/v3/filter"
    exportAction "github.com/chargebee/chargebee-go/v3/actions/export"
    "github.com/chargebee/chargebee-go/v3/models/export"
    enum "github.com/chargebee/chargebee-go/v3/enum"
)
func main() {
    chargebee.Configure("{site_api_key}","{site}");
    res,err := exportAction.Ramps(&export.RampsRequestParams{
        ExportType : enum.ExportTypeImportFriendlyData,
        Ramp : &export.RampsRampParams{
            SubscriptionId : &filter.StringFilter{
                Is : "8asz3SQ0jFhbG3Dr",
            },
        },
    }).Request()
    if err != nil {
        fmt.Println(err)
    } else {
        Export := res.Export
    }
}
```

#### Go

```go
package main

import (
  "fmt"
  "github.com/chargebee/chargebee-go/v4"
)

func main() {
  config := &chargebee.ClientConfig{
    SiteName: "{site}",
    ApiKey: "{site_api_key}",
  }    
  client := chargebee.NewClient(config)
  req := &chargebee.ExportRampsRequest{
    ExportType : chargebee.ExportTypeImportFriendlyData,
    Ramp : &chargebee.ExportRampsRamp{
        SubscriptionId : &chargebee.StringFilter{
            Is : "8asz3SQ0jFhbG3Dr",
        },
    },
}
  res, err := client.Export.Ramps(req)
      if err != nil {
        fmt.Println(err)
    } else {
        Export := res.Export
    }
}
```

#### Java

```java
import com.chargebee.*;
import com.chargebee.ListResult;
import com.chargebee.models.*;
import com.chargebee.models.enums.*;
import java.io.IOException;

public class Sample {

    public static void main(String args[]) throws IOException, Exception {
        Environment.configure("{site}", "{site_api_key}");
        Result result = Export.ramps()
            .exportType(ExportType.IMPORT_FRIENDLY_DATA)
            .rampSubscriptionId().is("8asz3SQ0jFhbG3Dr")
            .request();

        Export export = result.export();
    }
}
```

#### Java

```java
import com.chargebee.v4.client.ChargebeeClient;
import com.chargebee.v4.models.export.Export;
import com.chargebee.v4.models.export.params.ExportRampsParams;
import com.chargebee.v4.models.export.responses.ExportRampsResponse;

public class ExportRamps {

    public static void main(String[] args) {
        ChargebeeClient client = ChargebeeClient.builder()
            .apiKey("{site_api_key}")
            .siteName("{site}")
            .build();

        ExportRampsParams.RampParams ramp =
            ExportRampsParams.RampParams.builder()
                .subscriptionId()
                .is("8asz3SQ0jFhbG3Dr")
                .build();

        ExportRampsParams params = ExportRampsParams.builder()
            .exportType(ExportRampsParams.ExportType.IMPORT_FRIENDLY_DATA)
            .ramp(ramp)
            .build();

        ExportRampsResponse response = client.exports().ramps(params);

        Export export = response.getExport();
    }
}
```

#### Node.js

```node
import Chargebee from "chargebee";

const chargebee = new Chargebee({
    site: "{site}",
    apiKey: "{site_api_key}",
});

try {
    const result = await chargebee.export.ramps({
        export_type: "import_friendly_data",
        ramp: {
            subscription_id: {
                is: "8asz3SQ0jFhbG3Dr"
            }
        }
    });

    console.log(result);
    const export_response = result.export;
} catch (err) {
    console.log(err);
}
```

#### PHP

```php
<?php

require __DIR__ . '/vendor/autoload.php';

use Chargebee\ChargebeeClient;

$chargebee = new ChargebeeClient(options: [
    "site" => "{site}",
    "apiKey" => "{site_api_key}",
]);
$result = $chargebee->export()->ramps([
    "export_type" => "import_friendly_data",
    "ramp" => [
        "subscription_id" => [
            "is" => "8asz3SQ0jFhbG3Dr"
        ]
    ]
]);
$export = $result->export;
```

#### Python

```python
import chargebee
from chargebee import Chargebee, Filters

cb_client = Chargebee(api_key="{site_api_key}", site="{site}")
response = cb_client.Export.ramps(
    cb_client.Export.RampsParams(
        export_type=chargebee.ExportType.IMPORT_FRIENDLY_DATA,
        ramp=cb_client.Export.RampsRampParams(
            subscription_id=Filters.StringFilter(IS="8asz3SQ0jFhbG3Dr")
        )
    )
)
export = response.export
```

#### Ruby

```ruby
require 'chargebee'

ChargeBee.configure(:site => "{site}",
  :api_key => "{site_api_key}")

result = ChargeBee::Export.ramps({
  :export_type => "IMPORT_FRIENDLY_DATA",
  "ramp[subscription_id][is]" => "8asz3SQ0jFhbG3Dr"
})

export = result.export
```

### Exports ramps whose changes take effect between January 1, 2024, and May 31, 2024.

#### cURL

```bash
curl  https://{site}.chargebee.com/api/v2/exports/ramps \
     -u {site_api_key}:\
     -d export_type="IMPORT_FRIENDLY_DATA" \
     -d "ramp[effective_from][between]"='[1704067200,1717199999]'
```

#### .NET

```dotnet
using ChargeBee.Api;
using ChargeBee.Models;
using ChargeBee.Models.Enums;
using Newtonsoft.Json.Linq;

ApiConfig.Configure("{site}","{site_api_key}");
EntityResult result = Export.Ramps()
		.ExportType(ExportTypeEnum.ImportFriendlyData)
		.RampEffectiveFrom().Between(DateTimeOffset.FromUnixTimeSeconds(1704067200).UtcDateTime, DateTimeOffset.FromUnixTimeSeconds(1717199999).UtcDateTime)
		.Request();

Export export = result.Export;
```

#### Go

```go
package main
import (
    "fmt"
    "github.com/chargebee/chargebee-go/v3"
    "github.com/chargebee/chargebee-go/v3/filter"
    exportAction "github.com/chargebee/chargebee-go/v3/actions/export"
    "github.com/chargebee/chargebee-go/v3/models/export"
    enum "github.com/chargebee/chargebee-go/v3/enum"
)
func main() {
    chargebee.Configure("{site_api_key}","{site}");
    res,err := exportAction.Ramps(&export.RampsRequestParams{
        ExportType : enum.ExportTypeImportFriendlyData,
        Ramp : &export.RampsRampParams{
            EffectiveFrom : &filter.TimestampFilter{
                Between : []int64{1704067200,1717199999},
            },
        },
    }).Request()
    if err != nil {
        fmt.Println(err)
    } else {
        Export := res.Export
    }
}
```

#### Go

```go
package main

import (
  "fmt"
  "github.com/chargebee/chargebee-go/v4"
)

func main() {
  config := &chargebee.ClientConfig{
    SiteName: "{site}",
    ApiKey: "{site_api_key}",
  }    
  client := chargebee.NewClient(config)
  req := &chargebee.ExportRampsRequest{
    ExportType : chargebee.ExportTypeImportFriendlyData,
    Ramp : &chargebee.ExportRampsRamp{
        EffectiveFrom : &chargebee.TimestampFilter{
            Between : []int64{1704067200,1717199999},
        },
    },
}
  res, err := client.Export.Ramps(req)
      if err != nil {
        fmt.Println(err)
    } else {
        Export := res.Export
    }
}
```

#### Java

```java
import com.chargebee.*;
import com.chargebee.ListResult;
import com.chargebee.models.*;
import com.chargebee.models.enums.*;
import java.io.IOException;
import java.sql.Timestamp;

public class Sample {

    public static void main(String args[]) throws IOException, Exception {
        Environment.configure("{site}", "{site_api_key}");
        Result result = Export.ramps()
            .exportType(ExportType.IMPORT_FRIENDLY_DATA)
            .rampEffectiveFrom().between(new Timestamp(1704067200L * 1000), new Timestamp(1717199999L * 1000))
            .request();

        Export export = result.export();
    }
}
```

#### Java

```java
import com.chargebee.v4.client.ChargebeeClient;
import com.chargebee.v4.models.export.Export;
import com.chargebee.v4.models.export.params.ExportRampsParams;
import com.chargebee.v4.models.export.responses.ExportRampsResponse;
import java.sql.Timestamp;

public class ExportRamps {

    public static void main(String[] args) {
        ChargebeeClient client = ChargebeeClient.builder()
            .apiKey("{site_api_key}")
            .siteName("{site}")
            .build();

        ExportRampsParams.RampParams ramp =
            ExportRampsParams.RampParams.builder()
                .effectiveFrom()
                .between(new Timestamp(1704067200L * 1000), new Timestamp(1717199999L * 1000))
                .build();

        ExportRampsParams params = ExportRampsParams.builder()
            .exportType(ExportRampsParams.ExportType.IMPORT_FRIENDLY_DATA)
            .ramp(ramp)
            .build();

        ExportRampsResponse response = client.exports().ramps(params);

        Export export = response.getExport();
    }
}
```

#### Node.js

```node
import Chargebee from "chargebee";

const chargebee = new Chargebee({
    site: "{site}",
    apiKey: "{site_api_key}",
});

try {
    const result = await chargebee.export.ramps({
        export_type: "import_friendly_data",
        ramp: {
            effective_from: {
                between: [1704067200, 1717199999]
            }
        }
    });

    console.log(result);
    const export_response = result.export;
} catch (err) {
    console.log(err);
}
```

#### PHP

```php
<?php

require __DIR__ . '/vendor/autoload.php';

use Chargebee\ChargebeeClient;

$chargebee = new ChargebeeClient(options: [
    "site" => "{site}",
    "apiKey" => "{site_api_key}",
]);
$result = $chargebee->export()->ramps([
    "export_type" => "import_friendly_data",
    "ramp" => [
        "effective_from" => [
            "between" => [1704067200, 1717199999]
        ]
    ]
]);
$export = $result->export;
```

#### Python

```python
import chargebee
from chargebee import Chargebee, Filters

cb_client = Chargebee(api_key="{site_api_key}", site="{site}")
response = cb_client.Export.ramps(
    cb_client.Export.RampsParams(
        export_type=chargebee.ExportType.IMPORT_FRIENDLY_DATA,
        ramp=cb_client.Export.RampsRampParams(
            effective_from=Filters.TimestampFilter(BETWEEN=[1704067200, 1717199999])
        )
    )
)
export = response.export
```

#### Ruby

```ruby
require 'chargebee'

ChargeBee.configure(:site => "{site}",
  :api_key => "{site_api_key}")

result = ChargeBee::Export.ramps({
  :export_type => "IMPORT_FRIENDLY_DATA",
  "ramp[effective_from][between]" => "[1704067200,1717199999]"
})

export = result.export
```

### Exports ramps updated from January 1, 2024 onwards.

#### cURL

```bash
curl  https://{site}.chargebee.com/api/v2/exports/ramps \
     -u {site_api_key}:\
     -d export_type="IMPORT_FRIENDLY_DATA" \
     -d "ramp[updated_at][after]"="1704067200"
```

#### .NET

```dotnet
using ChargeBee.Api;
using ChargeBee.Models;
using ChargeBee.Models.Enums;

ApiConfig.Configure("{site}","{site_api_key}");
EntityResult result = Export.Ramps()
		.ExportType(ExportTypeEnum.ImportFriendlyData)
		.RampUpdatedAt().After(DateTimeOffset.FromUnixTimeSeconds(1704067200).UtcDateTime)
		.Request();

Export export = result.Export;
```

#### Go

```go
package main
import (
    "fmt"
    "github.com/chargebee/chargebee-go/v3"
    "github.com/chargebee/chargebee-go/v3/filter"
    exportAction "github.com/chargebee/chargebee-go/v3/actions/export"
    "github.com/chargebee/chargebee-go/v3/models/export"
    enum "github.com/chargebee/chargebee-go/v3/enum"
)
func main() {
    chargebee.Configure("{site_api_key}","{site}");
    res,err := exportAction.Ramps(&export.RampsRequestParams{
        ExportType : enum.ExportTypeImportFriendlyData,
        Ramp : &export.RampsRampParams{
            UpdatedAt : &filter.TimestampFilter{
                After : 1704067200,
            },
        },
    }).Request()
    if err != nil {
        fmt.Println(err)
    } else {
        Export := res.Export
    }
}
```

#### Go

```go
package main

import (
  "fmt"
  "github.com/chargebee/chargebee-go/v4"
)

func main() {
  config := &chargebee.ClientConfig{
    SiteName: "{site}",
    ApiKey: "{site_api_key}",
  }    
  client := chargebee.NewClient(config)
  req := &chargebee.ExportRampsRequest{
    ExportType : chargebee.ExportTypeImportFriendlyData,
    Ramp : &chargebee.ExportRampsRamp{
        UpdatedAt : &chargebee.TimestampFilter{
            After : 1704067200,
        },
    },
}
  res, err := client.Export.Ramps(req)
      if err != nil {
        fmt.Println(err)
    } else {
        Export := res.Export
    }
}
```

#### Java

```java
import com.chargebee.*;
import com.chargebee.ListResult;
import com.chargebee.models.*;
import com.chargebee.models.enums.*;
import java.io.IOException;
import java.sql.Timestamp;

public class Sample {

    public static void main(String args[]) throws IOException, Exception {
        Environment.configure("{site}", "{site_api_key}");
        Result result = Export.ramps()
            .exportType(ExportType.IMPORT_FRIENDLY_DATA)
            .rampUpdatedAt().after(new Timestamp(1704067200L * 1000))
            .request();

        Export export = result.export();
    }
}
```

#### Java

```java
import com.chargebee.v4.client.ChargebeeClient;
import com.chargebee.v4.models.export.Export;
import com.chargebee.v4.models.export.params.ExportRampsParams;
import com.chargebee.v4.models.export.responses.ExportRampsResponse;
import java.sql.Timestamp;

public class ExportRamps {

    public static void main(String[] args) {
        ChargebeeClient client = ChargebeeClient.builder()
            .apiKey("{site_api_key}")
            .siteName("{site}")
            .build();

        ExportRampsParams.RampParams ramp =
            ExportRampsParams.RampParams.builder()
                .updatedAt()
                .after(new Timestamp(1704067200L * 1000))
                .build();

        ExportRampsParams params = ExportRampsParams.builder()
            .exportType(ExportRampsParams.ExportType.IMPORT_FRIENDLY_DATA)
            .ramp(ramp)
            .build();

        ExportRampsResponse response = client.exports().ramps(params);

        Export export = response.getExport();
    }
}
```

#### Node.js

```node
import Chargebee from "chargebee";

const chargebee = new Chargebee({
    site: "{site}",
    apiKey: "{site_api_key}",
});

try {
    const result = await chargebee.export.ramps({
        export_type: "import_friendly_data",
        ramp: {
            updated_at: {
                after: 1704067200
            }
        }
    });

    console.log(result);
    const export_response = result.export;
} catch (err) {
    console.log(err);
}
```

#### PHP

```php
<?php

require __DIR__ . '/vendor/autoload.php';

use Chargebee\ChargebeeClient;

$chargebee = new ChargebeeClient(options: [
    "site" => "{site}",
    "apiKey" => "{site_api_key}",
]);
$result = $chargebee->export()->ramps([
    "export_type" => "import_friendly_data",
    "ramp" => [
        "updated_at" => [
            "after" => 1704067200
        ]
    ]
]);
$export = $result->export;
```

#### Python

```python
import chargebee
from chargebee import Chargebee, Filters

cb_client = Chargebee(api_key="{site_api_key}", site="{site}")
response = cb_client.Export.ramps(
    cb_client.Export.RampsParams(
        export_type=chargebee.ExportType.IMPORT_FRIENDLY_DATA,
        ramp=cb_client.Export.RampsRampParams(
            updated_at=Filters.TimestampFilter(AFTER="1704067200")
        )
    )
)
export = response.export
```

#### Ruby

```ruby
require 'chargebee'

ChargeBee.configure(:site => "{site}",
  :api_key => "{site_api_key}")

result = ChargeBee::Export.ramps({
  :export_type => "IMPORT_FRIENDLY_DATA",
  "ramp[updated_at][after]" => 1704067200
})

export = result.export
```

### Exports all ramps updated during the year 2023.

#### cURL

```bash
curl  https://{site}.chargebee.com/api/v2/exports/ramps \
     -u {site_api_key}:\
     -d export_type="IMPORT_FRIENDLY_DATA" \
     -d "ramp[updated_at][between]"='[1672531200,1704067199]'
```

#### .NET

```dotnet
using ChargeBee.Api;
using ChargeBee.Models;
using ChargeBee.Models.Enums;
using Newtonsoft.Json.Linq;

ApiConfig.Configure("{site}","{site_api_key}");
EntityResult result = Export.Ramps()
		.ExportType(ExportTypeEnum.ImportFriendlyData)
		.RampUpdatedAt().Between(DateTimeOffset.FromUnixTimeSeconds(1672531200).UtcDateTime, DateTimeOffset.FromUnixTimeSeconds(1704067199).UtcDateTime)
		.Request();

Export export = result.Export;
```

#### Go

```go
package main
import (
    "fmt"
    "github.com/chargebee/chargebee-go/v3"
    "github.com/chargebee/chargebee-go/v3/filter"
    exportAction "github.com/chargebee/chargebee-go/v3/actions/export"
    "github.com/chargebee/chargebee-go/v3/models/export"
    enum "github.com/chargebee/chargebee-go/v3/enum"
)
func main() {
    chargebee.Configure("{site_api_key}","{site}");
    res,err := exportAction.Ramps(&export.RampsRequestParams{
        ExportType : enum.ExportTypeImportFriendlyData,
        Ramp : &export.RampsRampParams{
            UpdatedAt : &filter.TimestampFilter{
                Between : []int64{1672531200,1704067199},
            },
        },
    }).Request()
    if err != nil {
        fmt.Println(err)
    } else {
        Export := res.Export
    }
}
```

#### Go

```go
package main

import (
  "fmt"
  "github.com/chargebee/chargebee-go/v4"
)

func main() {
  config := &chargebee.ClientConfig{
    SiteName: "{site}",
    ApiKey: "{site_api_key}",
  }    
  client := chargebee.NewClient(config)
  req := &chargebee.ExportRampsRequest{
    ExportType : chargebee.ExportTypeImportFriendlyData,
    Ramp : &chargebee.ExportRampsRamp{
        UpdatedAt : &chargebee.TimestampFilter{
            Between : []int64{1672531200,1704067199},
        },
    },
}
  res, err := client.Export.Ramps(req)
      if err != nil {
        fmt.Println(err)
    } else {
        Export := res.Export
    }
}
```

#### Java

```java
import com.chargebee.*;
import com.chargebee.ListResult;
import com.chargebee.models.*;
import com.chargebee.models.enums.*;
import java.io.IOException;
import java.sql.Timestamp;

public class Sample {

    public static void main(String args[]) throws IOException, Exception {
        Environment.configure("{site}", "{site_api_key}");
        Result result = Export.ramps()
            .exportType(ExportType.IMPORT_FRIENDLY_DATA)
            .rampUpdatedAt().between(new Timestamp(1672531200L * 1000), new Timestamp(1704067199L * 1000))
            .request();

        Export export = result.export();
    }
}
```

#### Java

```java
import com.chargebee.v4.client.ChargebeeClient;
import com.chargebee.v4.models.export.Export;
import com.chargebee.v4.models.export.params.ExportRampsParams;
import com.chargebee.v4.models.export.responses.ExportRampsResponse;
import java.sql.Timestamp;

public class ExportRamps {

    public static void main(String[] args) {
        ChargebeeClient client = ChargebeeClient.builder()
            .apiKey("{site_api_key}")
            .siteName("{site}")
            .build();

        ExportRampsParams.RampParams ramp =
            ExportRampsParams.RampParams.builder()
                .updatedAt()
                .between(new Timestamp(1672531200L * 1000), new Timestamp(1704067199L * 1000))
                .build();

        ExportRampsParams params = ExportRampsParams.builder()
            .exportType(ExportRampsParams.ExportType.IMPORT_FRIENDLY_DATA)
            .ramp(ramp)
            .build();

        ExportRampsResponse response = client.exports().ramps(params);

        Export export = response.getExport();
    }
}
```

#### Node.js

```node
import Chargebee from "chargebee";

const chargebee = new Chargebee({
    site: "{site}",
    apiKey: "{site_api_key}",
});

try {
    const result = await chargebee.export.ramps({
        export_type: "import_friendly_data",
        ramp: {
            updated_at: {
                between: [1672531200, 1704067199]
            }
        }
    });

    console.log(result);
    const export_response = result.export;
} catch (err) {
    console.log(err);
}
```

#### PHP

```php
<?php

require __DIR__ . '/vendor/autoload.php';

use Chargebee\ChargebeeClient;

$chargebee = new ChargebeeClient(options: [
    "site" => "{site}",
    "apiKey" => "{site_api_key}",
]);
$result = $chargebee->export()->ramps([
    "export_type" => "import_friendly_data",
    "ramp" => [
        "updated_at" => [
            "between" => [1672531200, 1704067199]
        ]
    ]
]);
$export = $result->export;
```

#### Python

```python
import chargebee
from chargebee import Chargebee, Filters

cb_client = Chargebee(api_key="{site_api_key}", site="{site}")
response = cb_client.Export.ramps(
    cb_client.Export.RampsParams(
        export_type=chargebee.ExportType.IMPORT_FRIENDLY_DATA,
        ramp=cb_client.Export.RampsRampParams(
            updated_at=Filters.TimestampFilter(BETWEEN=[1672531200, 1704067199])
        )
    )
)
export = response.export
```

#### Ruby

```ruby
require 'chargebee'

ChargeBee.configure(:site => "{site}",
  :api_key => "{site_api_key}")

result = ChargeBee::Export.ramps({
  :export_type => "IMPORT_FRIENDLY_DATA",
  "ramp[updated_at][between]" => "[1672531200,1704067199]"
})

export = result.export
```

## Sample Response

```json
{
  "export": {
    "created_at": 1527791400,
    "id": "__test__KyVnHhSBWTC8J8p",
    "mime_type": "zip",
    "object": "export",
    "operation_type": "Subscription Ramps",
    "status": "in_process"
  }
}
```

## URL Format

**POST** https://[site].chargebee.com/api/v2/exports/ramps

## Input Parameters

- `export_type` (optional, enumerated string, default=data)
  Determines the format of the data. Returns the export type based on the selected value.
  Possible enum values:
    - `data`
      Provides the full set of data for the subscription ramps in multiple `.csv` files.
    - `import_friendly_data`
      Provides a `.csv` file whose columns match the [`ramp`](/docs/api/ramps/ramp-object) schema. This file format can be readily imported through the UI by using [Bulk Operations](https://www.chargebee.com/docs/bulk-operations.html).

- `ramp` (optional, enumerated string)
  Parameters for ramp
  - `status` (optional, enumerated string)
    The execution status of the ramp. Use this filter to export ramps in a specific status, such as `scheduled` , `succeeded` , `failed` , or `draft`.
  - `subscription_id` (optional, string)
    The ID of the subscription for which the ramp was created. Use this filter to export ramps that belong to specific subscriptions.
  - `effective_from` (optional, timestamp(UTC) in seconds)
    To filter based on `effective_from` , the time when the changes defined in the ramp are applied to the subscription by executing the ramp.
    - `after` (optional, timestamp(UTC) in seconds)
    - `before` (optional, timestamp(UTC) in seconds)
    - `on` (optional, timestamp(UTC) in seconds)
  - `updated_at` (optional, timestamp(UTC) in seconds)
    To filter based on `updated_at`. This attribute will be present only if the resource has been updated after 2016-09-28. It is advisable when using this filter, to pass the `sort_by` input parameter as `updated_at` for a faster response. [Learn more](/docs/api/exports) about the best practice before performing full export.
    - `after` (optional, timestamp(UTC) in seconds)
    - `before` (optional, timestamp(UTC) in seconds)
    - `on` (optional, timestamp(UTC) in seconds)

## Returns

- `export` (Export object)
  Resource object representing export